From e48ae20a7938b01aee62806bfcdafe8a0883b1e4 Mon Sep 17 00:00:00 2001 From: Mike Schuchardt Date: Fri, 6 Jun 2025 08:37:59 -0700 Subject: [PATCH] build: Update to header 1.4.317 --- include/vulkan/utility/vk_dispatch_table.h | 24 + include/vulkan/utility/vk_format_utils.h | 26 +- include/vulkan/utility/vk_safe_struct.hpp | 747 ++++++++ include/vulkan/utility/vk_struct_helper.hpp | 42 + include/vulkan/vk_enum_string_helper.h | 335 +++- scripts/known_good.json | 2 +- src/vulkan/vk_safe_struct_ext.cpp | 105 ++ src/vulkan/vk_safe_struct_khr.cpp | 789 +++++++++ src/vulkan/vk_safe_struct_utils.cpp | 162 ++ src/vulkan/vk_safe_struct_vendor.cpp | 1775 +++++++++++++++++++ 10 files changed, 3984 insertions(+), 23 deletions(-) diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h index 1c0f82a..1a4a031 100644 --- a/include/vulkan/utility/vk_dispatch_table.h +++ b/include/vulkan/utility/vk_dispatch_table.h @@ -160,6 +160,7 @@ typedef struct VkuInstanceDispatchTable_ { PFN_vkCreateScreenSurfaceQNX CreateScreenSurfaceQNX; PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX GetPhysicalDeviceScreenPresentationSupportQNX; #endif // VK_USE_PLATFORM_SCREEN_QNX + PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM GetPhysicalDeviceExternalTensorPropertiesARM; PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV GetPhysicalDeviceOpticalFlowImageFormatsNV; PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV GetPhysicalDeviceCooperativeVectorPropertiesNV; PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV; @@ -480,6 +481,7 @@ typedef struct VkuDeviceDispatchTable_ { PFN_vkGetRenderingAreaGranularityKHR GetRenderingAreaGranularityKHR; PFN_vkGetDeviceImageSubresourceLayoutKHR GetDeviceImageSubresourceLayoutKHR; PFN_vkGetImageSubresourceLayout2KHR GetImageSubresourceLayout2KHR; + PFN_vkWaitForPresent2KHR WaitForPresent2KHR; PFN_vkCreatePipelineBinariesKHR CreatePipelineBinariesKHR; PFN_vkDestroyPipelineBinaryKHR DestroyPipelineBinaryKHR; PFN_vkGetPipelineKeyKHR GetPipelineKeyKHR; @@ -742,6 +744,16 @@ typedef struct VkuDeviceDispatchTable_ { PFN_vkCmdSetShadingRateImageEnableNV CmdSetShadingRateImageEnableNV; PFN_vkCmdSetRepresentativeFragmentTestEnableNV CmdSetRepresentativeFragmentTestEnableNV; PFN_vkCmdSetCoverageReductionModeNV CmdSetCoverageReductionModeNV; + PFN_vkCreateTensorARM CreateTensorARM; + PFN_vkDestroyTensorARM DestroyTensorARM; + PFN_vkCreateTensorViewARM CreateTensorViewARM; + PFN_vkDestroyTensorViewARM DestroyTensorViewARM; + PFN_vkGetTensorMemoryRequirementsARM GetTensorMemoryRequirementsARM; + PFN_vkBindTensorMemoryARM BindTensorMemoryARM; + PFN_vkGetDeviceTensorMemoryRequirementsARM GetDeviceTensorMemoryRequirementsARM; + PFN_vkCmdCopyTensorARM CmdCopyTensorARM; + PFN_vkGetTensorOpaqueCaptureDescriptorDataARM GetTensorOpaqueCaptureDescriptorDataARM; + PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM GetTensorViewOpaqueCaptureDescriptorDataARM; PFN_vkGetShaderModuleIdentifierEXT GetShaderModuleIdentifierEXT; PFN_vkGetShaderModuleCreateInfoIdentifierEXT GetShaderModuleCreateInfoIdentifierEXT; PFN_vkCreateOpticalFlowSessionNV CreateOpticalFlowSessionNV; @@ -1132,6 +1144,7 @@ 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->WaitForPresent2KHR = (PFN_vkWaitForPresent2KHR)gdpa(device, "vkWaitForPresent2KHR"); table->CreatePipelineBinariesKHR = (PFN_vkCreatePipelineBinariesKHR)gdpa(device, "vkCreatePipelineBinariesKHR"); table->DestroyPipelineBinaryKHR = (PFN_vkDestroyPipelineBinaryKHR)gdpa(device, "vkDestroyPipelineBinaryKHR"); table->GetPipelineKeyKHR = (PFN_vkGetPipelineKeyKHR)gdpa(device, "vkGetPipelineKeyKHR"); @@ -1394,6 +1407,16 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch table->CmdSetShadingRateImageEnableNV = (PFN_vkCmdSetShadingRateImageEnableNV)gdpa(device, "vkCmdSetShadingRateImageEnableNV"); table->CmdSetRepresentativeFragmentTestEnableNV = (PFN_vkCmdSetRepresentativeFragmentTestEnableNV)gdpa(device, "vkCmdSetRepresentativeFragmentTestEnableNV"); table->CmdSetCoverageReductionModeNV = (PFN_vkCmdSetCoverageReductionModeNV)gdpa(device, "vkCmdSetCoverageReductionModeNV"); + table->CreateTensorARM = (PFN_vkCreateTensorARM)gdpa(device, "vkCreateTensorARM"); + table->DestroyTensorARM = (PFN_vkDestroyTensorARM)gdpa(device, "vkDestroyTensorARM"); + table->CreateTensorViewARM = (PFN_vkCreateTensorViewARM)gdpa(device, "vkCreateTensorViewARM"); + table->DestroyTensorViewARM = (PFN_vkDestroyTensorViewARM)gdpa(device, "vkDestroyTensorViewARM"); + table->GetTensorMemoryRequirementsARM = (PFN_vkGetTensorMemoryRequirementsARM)gdpa(device, "vkGetTensorMemoryRequirementsARM"); + table->BindTensorMemoryARM = (PFN_vkBindTensorMemoryARM)gdpa(device, "vkBindTensorMemoryARM"); + table->GetDeviceTensorMemoryRequirementsARM = (PFN_vkGetDeviceTensorMemoryRequirementsARM)gdpa(device, "vkGetDeviceTensorMemoryRequirementsARM"); + table->CmdCopyTensorARM = (PFN_vkCmdCopyTensorARM)gdpa(device, "vkCmdCopyTensorARM"); + table->GetTensorOpaqueCaptureDescriptorDataARM = (PFN_vkGetTensorOpaqueCaptureDescriptorDataARM)gdpa(device, "vkGetTensorOpaqueCaptureDescriptorDataARM"); + table->GetTensorViewOpaqueCaptureDescriptorDataARM = (PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM)gdpa(device, "vkGetTensorViewOpaqueCaptureDescriptorDataARM"); table->GetShaderModuleIdentifierEXT = (PFN_vkGetShaderModuleIdentifierEXT)gdpa(device, "vkGetShaderModuleIdentifierEXT"); table->GetShaderModuleCreateInfoIdentifierEXT = (PFN_vkGetShaderModuleCreateInfoIdentifierEXT)gdpa(device, "vkGetShaderModuleCreateInfoIdentifierEXT"); table->CreateOpticalFlowSessionNV = (PFN_vkCreateOpticalFlowSessionNV)gdpa(device, "vkCreateOpticalFlowSessionNV"); @@ -1607,6 +1630,7 @@ static inline void vkuInitInstanceDispatchTable(VkInstance instance, VkuInstance table->CreateScreenSurfaceQNX = (PFN_vkCreateScreenSurfaceQNX)gipa(instance, "vkCreateScreenSurfaceQNX"); table->GetPhysicalDeviceScreenPresentationSupportQNX = (PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX)gipa(instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX"); #endif // VK_USE_PLATFORM_SCREEN_QNX + table->GetPhysicalDeviceExternalTensorPropertiesARM = (PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM)gipa(instance, "vkGetPhysicalDeviceExternalTensorPropertiesARM"); table->GetPhysicalDeviceOpticalFlowImageFormatsNV = (PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)gipa(instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV"); table->GetPhysicalDeviceCooperativeVectorPropertiesNV = (PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV)gipa(instance, "vkGetPhysicalDeviceCooperativeVectorPropertiesNV"); table->GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = (PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV)gipa(instance, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV"); diff --git a/include/vulkan/utility/vk_format_utils.h b/include/vulkan/utility/vk_format_utils.h index d182b05..177c97c 100644 --- a/include/vulkan/utility/vk_format_utils.h +++ b/include/vulkan/utility/vk_format_utils.h @@ -24,6 +24,7 @@ extern "C" { enum VKU_FORMAT_NUMERICAL_TYPE { VKU_FORMAT_NUMERICAL_TYPE_NONE = 0, + VKU_FORMAT_NUMERICAL_TYPE_BOOL, VKU_FORMAT_NUMERICAL_TYPE_SFIXED5, VKU_FORMAT_NUMERICAL_TYPE_SFLOAT, VKU_FORMAT_NUMERICAL_TYPE_SINT, @@ -132,6 +133,10 @@ enum VKU_FORMAT_COMPATIBILITY_CLASS { // -> VKU_FORMAT_INVALID_INDEX inline uint32_t vkuGetPlaneIndex(VkImageAspectFlagBits aspect); +// Returns whether a VkFormat is of the numerical format BOOL +// Format must only contain one numerical format, so formats like D16_UNORM_S8_UINT always return false +inline bool vkuFormatIsBOOL(VkFormat format); + // Returns whether a VkFormat is of the numerical format SFIXED5 // Format must only contain one numerical format, so formats like D16_UNORM_S8_UINT always return false inline bool vkuFormatIsSFIXED5(VkFormat format); @@ -354,7 +359,7 @@ struct VKU_FORMAT_INFO { uint32_t component_count; struct VKU_FORMAT_COMPONENT_INFO components[VKU_FORMAT_MAX_COMPONENTS]; }; -const struct VKU_FORMAT_INFO vku_formats[264] = { +const struct VKU_FORMAT_INFO vku_formats[265] = { { VKU_FORMAT_COMPATIBILITY_CLASS_NONE, 0, 0, {0, 0, 0}, 0, {} }, { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}} }, { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}, {VKU_FORMAT_COMPONENT_TYPE_B, 4}, {VKU_FORMAT_COMPONENT_TYPE_A, 4}} }, @@ -602,6 +607,7 @@ const struct VKU_FORMAT_INFO vku_formats[264] = { { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT_2PLANE_444, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_R, 16}} }, { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 4}, {VKU_FORMAT_COMPONENT_TYPE_R, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}, {VKU_FORMAT_COMPONENT_TYPE_B, 4}} }, { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 4}, {VKU_FORMAT_COMPONENT_TYPE_B, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}, {VKU_FORMAT_COMPONENT_TYPE_R, 4}} }, + { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}} }, { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}} }, { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 1}, {VKU_FORMAT_COMPONENT_TYPE_B, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 5}, {VKU_FORMAT_COMPONENT_TYPE_R, 5}} }, { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_ALPHA, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}} }, @@ -627,9 +633,10 @@ inline const struct VKU_FORMAT_INFO vkuGetFormatInfo(VkFormat format) { else if (VK_FORMAT_G8B8G8R8_422_UNORM <= format && format <= VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM ) { return vku_formats[format - VK_FORMAT_G8B8G8R8_422_UNORM + 207]; } else if (VK_FORMAT_G8_B8R8_2PLANE_444_UNORM <= format && format <= VK_FORMAT_G16_B16R16_2PLANE_444_UNORM ) { return vku_formats[format - VK_FORMAT_G8_B8R8_2PLANE_444_UNORM + 241]; } else if (VK_FORMAT_A4R4G4B4_UNORM_PACK16 <= format && format <= VK_FORMAT_A4B4G4R4_UNORM_PACK16 ) { return vku_formats[format - VK_FORMAT_A4R4G4B4_UNORM_PACK16 + 245]; } - else if (VK_FORMAT_R16G16_SFIXED5_NV <= format && format <= VK_FORMAT_R16G16_SFIXED5_NV ) { return vku_formats[format - VK_FORMAT_R16G16_SFIXED5_NV + 247]; } - else if (VK_FORMAT_A1B5G5R5_UNORM_PACK16 <= format && format <= VK_FORMAT_A8_UNORM ) { return vku_formats[format - VK_FORMAT_A1B5G5R5_UNORM_PACK16 + 248]; } - else if (VK_FORMAT_R10X6_UINT_PACK16_ARM <= format && format <= VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM ) { return vku_formats[format - VK_FORMAT_R10X6_UINT_PACK16_ARM + 250]; } + else if (VK_FORMAT_R8_BOOL_ARM <= format && format <= VK_FORMAT_R8_BOOL_ARM ) { return vku_formats[format - VK_FORMAT_R8_BOOL_ARM + 247]; } + else if (VK_FORMAT_R16G16_SFIXED5_NV <= format && format <= VK_FORMAT_R16G16_SFIXED5_NV ) { return vku_formats[format - VK_FORMAT_R16G16_SFIXED5_NV + 248]; } + else if (VK_FORMAT_A1B5G5R5_UNORM_PACK16 <= format && format <= VK_FORMAT_A8_UNORM ) { return vku_formats[format - VK_FORMAT_A1B5G5R5_UNORM_PACK16 + 249]; } + else if (VK_FORMAT_R10X6_UINT_PACK16_ARM <= format && format <= VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM ) { return vku_formats[format - VK_FORMAT_R10X6_UINT_PACK16_ARM + 251]; } // Default case - return VK_FORMAT_UNDEFINED else { return vku_formats[0]; @@ -734,6 +741,16 @@ inline const struct VKU_FORMAT_MULTIPLANE_COMPATIBILITY vkuGetFormatCompatibilit }; } +// Return true if all components in a format are an BOOL +bool vkuFormatIsBOOL(VkFormat format) { + switch (format) { + case VK_FORMAT_R8_BOOL_ARM: + return true; + default: + return false; + } +} + // Return true if all components in a format are an SFIXED5 bool vkuFormatIsSFIXED5(VkFormat format) { switch (format) { @@ -1693,6 +1710,7 @@ inline bool vkuFormatIs8bit(VkFormat format) { case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM: + case VK_FORMAT_R8_BOOL_ARM: return true; default: return false; diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp index 32358f7..6efbbf3 100644 --- a/include/vulkan/utility/vk_safe_struct.hpp +++ b/include/vulkan/utility/vk_safe_struct.hpp @@ -8488,6 +8488,110 @@ struct safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR { return reinterpret_cast(this); } }; +struct safe_VkSurfaceCapabilitiesPresentId2KHR { + VkStructureType sType; + void* pNext{}; + VkBool32 presentId2Supported; + + safe_VkSurfaceCapabilitiesPresentId2KHR(const VkSurfaceCapabilitiesPresentId2KHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSurfaceCapabilitiesPresentId2KHR(const safe_VkSurfaceCapabilitiesPresentId2KHR& copy_src); + safe_VkSurfaceCapabilitiesPresentId2KHR& operator=(const safe_VkSurfaceCapabilitiesPresentId2KHR& copy_src); + safe_VkSurfaceCapabilitiesPresentId2KHR(); + ~safe_VkSurfaceCapabilitiesPresentId2KHR(); + void initialize(const VkSurfaceCapabilitiesPresentId2KHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSurfaceCapabilitiesPresentId2KHR* copy_src, PNextCopyState* copy_state = {}); + VkSurfaceCapabilitiesPresentId2KHR* ptr() { return reinterpret_cast(this); } + VkSurfaceCapabilitiesPresentId2KHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPresentId2KHR { + VkStructureType sType; + const void* pNext{}; + uint32_t swapchainCount; + const uint64_t* pPresentIds{}; + + safe_VkPresentId2KHR(const VkPresentId2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPresentId2KHR(const safe_VkPresentId2KHR& copy_src); + safe_VkPresentId2KHR& operator=(const safe_VkPresentId2KHR& copy_src); + safe_VkPresentId2KHR(); + ~safe_VkPresentId2KHR(); + void initialize(const VkPresentId2KHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPresentId2KHR* copy_src, PNextCopyState* copy_state = {}); + VkPresentId2KHR* ptr() { return reinterpret_cast(this); } + VkPresentId2KHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDevicePresentId2FeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 presentId2; + + safe_VkPhysicalDevicePresentId2FeaturesKHR(const VkPhysicalDevicePresentId2FeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePresentId2FeaturesKHR(const safe_VkPhysicalDevicePresentId2FeaturesKHR& copy_src); + safe_VkPhysicalDevicePresentId2FeaturesKHR& operator=(const safe_VkPhysicalDevicePresentId2FeaturesKHR& copy_src); + safe_VkPhysicalDevicePresentId2FeaturesKHR(); + ~safe_VkPhysicalDevicePresentId2FeaturesKHR(); + void initialize(const VkPhysicalDevicePresentId2FeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePresentId2FeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePresentId2FeaturesKHR* ptr() { return reinterpret_cast(this); } + VkPhysicalDevicePresentId2FeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSurfaceCapabilitiesPresentWait2KHR { + VkStructureType sType; + void* pNext{}; + VkBool32 presentWait2Supported; + + safe_VkSurfaceCapabilitiesPresentWait2KHR(const VkSurfaceCapabilitiesPresentWait2KHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSurfaceCapabilitiesPresentWait2KHR(const safe_VkSurfaceCapabilitiesPresentWait2KHR& copy_src); + safe_VkSurfaceCapabilitiesPresentWait2KHR& operator=(const safe_VkSurfaceCapabilitiesPresentWait2KHR& copy_src); + safe_VkSurfaceCapabilitiesPresentWait2KHR(); + ~safe_VkSurfaceCapabilitiesPresentWait2KHR(); + void initialize(const VkSurfaceCapabilitiesPresentWait2KHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSurfaceCapabilitiesPresentWait2KHR* copy_src, PNextCopyState* copy_state = {}); + VkSurfaceCapabilitiesPresentWait2KHR* ptr() { return reinterpret_cast(this); } + VkSurfaceCapabilitiesPresentWait2KHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDevicePresentWait2FeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 presentWait2; + + safe_VkPhysicalDevicePresentWait2FeaturesKHR(const VkPhysicalDevicePresentWait2FeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePresentWait2FeaturesKHR(const safe_VkPhysicalDevicePresentWait2FeaturesKHR& copy_src); + safe_VkPhysicalDevicePresentWait2FeaturesKHR& operator=(const safe_VkPhysicalDevicePresentWait2FeaturesKHR& copy_src); + safe_VkPhysicalDevicePresentWait2FeaturesKHR(); + ~safe_VkPhysicalDevicePresentWait2FeaturesKHR(); + void initialize(const VkPhysicalDevicePresentWait2FeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePresentWait2FeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePresentWait2FeaturesKHR* ptr() { return reinterpret_cast(this); } + VkPhysicalDevicePresentWait2FeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPresentWait2InfoKHR { + VkStructureType sType; + const void* pNext{}; + uint64_t presentId; + uint64_t timeout; + + safe_VkPresentWait2InfoKHR(const VkPresentWait2InfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPresentWait2InfoKHR(const safe_VkPresentWait2InfoKHR& copy_src); + safe_VkPresentWait2InfoKHR& operator=(const safe_VkPresentWait2InfoKHR& copy_src); + safe_VkPresentWait2InfoKHR(); + ~safe_VkPresentWait2InfoKHR(); + void initialize(const VkPresentWait2InfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPresentWait2InfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPresentWait2InfoKHR* ptr() { return reinterpret_cast(this); } + VkPresentWait2InfoKHR const* ptr() const { return reinterpret_cast(this); } +}; struct safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR { VkStructureType sType; void* pNext{}; @@ -9172,6 +9276,76 @@ struct safe_VkVideoEncodeAV1RateControlLayerInfoKHR { return reinterpret_cast(this); } }; +struct safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 videoDecodeVP9; + + safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR(const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR(const safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR& copy_src); + safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR& operator=(const safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR& copy_src); + safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR(); + ~safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR(); + void initialize(const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVideoDecodeVP9FeaturesKHR* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceVideoDecodeVP9FeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkVideoDecodeVP9ProfileInfoKHR { + VkStructureType sType; + const void* pNext{}; + StdVideoVP9Profile stdProfile; + + safe_VkVideoDecodeVP9ProfileInfoKHR(const VkVideoDecodeVP9ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoDecodeVP9ProfileInfoKHR(const safe_VkVideoDecodeVP9ProfileInfoKHR& copy_src); + safe_VkVideoDecodeVP9ProfileInfoKHR& operator=(const safe_VkVideoDecodeVP9ProfileInfoKHR& copy_src); + safe_VkVideoDecodeVP9ProfileInfoKHR(); + ~safe_VkVideoDecodeVP9ProfileInfoKHR(); + void initialize(const VkVideoDecodeVP9ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeVP9ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeVP9ProfileInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoDecodeVP9ProfileInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoDecodeVP9CapabilitiesKHR { + VkStructureType sType; + void* pNext{}; + StdVideoVP9Level maxLevel; + + safe_VkVideoDecodeVP9CapabilitiesKHR(const VkVideoDecodeVP9CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoDecodeVP9CapabilitiesKHR(const safe_VkVideoDecodeVP9CapabilitiesKHR& copy_src); + safe_VkVideoDecodeVP9CapabilitiesKHR& operator=(const safe_VkVideoDecodeVP9CapabilitiesKHR& copy_src); + safe_VkVideoDecodeVP9CapabilitiesKHR(); + ~safe_VkVideoDecodeVP9CapabilitiesKHR(); + void initialize(const VkVideoDecodeVP9CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeVP9CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeVP9CapabilitiesKHR* ptr() { return reinterpret_cast(this); } + VkVideoDecodeVP9CapabilitiesKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoDecodeVP9PictureInfoKHR { + VkStructureType sType; + const void* pNext{}; + const StdVideoDecodeVP9PictureInfo* pStdPictureInfo{}; + int32_t referenceNameSlotIndices[VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR]; + uint32_t uncompressedHeaderOffset; + uint32_t compressedHeaderOffset; + uint32_t tilesOffset; + + safe_VkVideoDecodeVP9PictureInfoKHR(const VkVideoDecodeVP9PictureInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoDecodeVP9PictureInfoKHR(const safe_VkVideoDecodeVP9PictureInfoKHR& copy_src); + safe_VkVideoDecodeVP9PictureInfoKHR& operator=(const safe_VkVideoDecodeVP9PictureInfoKHR& copy_src); + safe_VkVideoDecodeVP9PictureInfoKHR(); + ~safe_VkVideoDecodeVP9PictureInfoKHR(); + void initialize(const VkVideoDecodeVP9PictureInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeVP9PictureInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeVP9PictureInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoDecodeVP9PictureInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; struct safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR { VkStructureType sType; void* pNext{}; @@ -9210,6 +9384,44 @@ struct safe_VkVideoInlineQueryInfoKHR { VkVideoInlineQueryInfoKHR* ptr() { return reinterpret_cast(this); } VkVideoInlineQueryInfoKHR const* ptr() const { return reinterpret_cast(this); } }; +struct safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 unifiedImageLayouts; + VkBool32 unifiedImageLayoutsVideo; + + safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(const safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR& copy_src); + safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR& operator=( + const safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR& copy_src); + safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(); + ~safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(); + void initialize(const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAttachmentFeedbackLoopInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkBool32 feedbackLoopEnable; + + safe_VkAttachmentFeedbackLoopInfoEXT(const VkAttachmentFeedbackLoopInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkAttachmentFeedbackLoopInfoEXT(const safe_VkAttachmentFeedbackLoopInfoEXT& copy_src); + safe_VkAttachmentFeedbackLoopInfoEXT& operator=(const safe_VkAttachmentFeedbackLoopInfoEXT& copy_src); + safe_VkAttachmentFeedbackLoopInfoEXT(); + ~safe_VkAttachmentFeedbackLoopInfoEXT(); + void initialize(const VkAttachmentFeedbackLoopInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAttachmentFeedbackLoopInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkAttachmentFeedbackLoopInfoEXT* ptr() { return reinterpret_cast(this); } + VkAttachmentFeedbackLoopInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; struct safe_VkCalibratedTimestampInfoKHR { VkStructureType sType; const void* pNext{}; @@ -9648,6 +9860,63 @@ struct safe_VkMemoryBarrierAccessFlags3KHR { VkMemoryBarrierAccessFlags3KHR* ptr() { return reinterpret_cast(this); } VkMemoryBarrierAccessFlags3KHR const* ptr() const { return reinterpret_cast(this); } }; +struct safe_VkPhysicalDeviceMaintenance9FeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 maintenance9; + + safe_VkPhysicalDeviceMaintenance9FeaturesKHR(const VkPhysicalDeviceMaintenance9FeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMaintenance9FeaturesKHR(const safe_VkPhysicalDeviceMaintenance9FeaturesKHR& copy_src); + safe_VkPhysicalDeviceMaintenance9FeaturesKHR& operator=(const safe_VkPhysicalDeviceMaintenance9FeaturesKHR& copy_src); + safe_VkPhysicalDeviceMaintenance9FeaturesKHR(); + ~safe_VkPhysicalDeviceMaintenance9FeaturesKHR(); + void initialize(const VkPhysicalDeviceMaintenance9FeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMaintenance9FeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMaintenance9FeaturesKHR* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMaintenance9FeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMaintenance9PropertiesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 image2DViewOf3DSparse; + VkDefaultVertexAttributeValueKHR defaultVertexAttributeValue; + + safe_VkPhysicalDeviceMaintenance9PropertiesKHR(const VkPhysicalDeviceMaintenance9PropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMaintenance9PropertiesKHR(const safe_VkPhysicalDeviceMaintenance9PropertiesKHR& copy_src); + safe_VkPhysicalDeviceMaintenance9PropertiesKHR& operator=(const safe_VkPhysicalDeviceMaintenance9PropertiesKHR& copy_src); + safe_VkPhysicalDeviceMaintenance9PropertiesKHR(); + ~safe_VkPhysicalDeviceMaintenance9PropertiesKHR(); + void initialize(const VkPhysicalDeviceMaintenance9PropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMaintenance9PropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMaintenance9PropertiesKHR* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMaintenance9PropertiesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkQueueFamilyOwnershipTransferPropertiesKHR { + VkStructureType sType; + void* pNext{}; + uint32_t optimalImageTransferToQueueFamilies; + + safe_VkQueueFamilyOwnershipTransferPropertiesKHR(const VkQueueFamilyOwnershipTransferPropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkQueueFamilyOwnershipTransferPropertiesKHR(const safe_VkQueueFamilyOwnershipTransferPropertiesKHR& copy_src); + safe_VkQueueFamilyOwnershipTransferPropertiesKHR& operator=(const safe_VkQueueFamilyOwnershipTransferPropertiesKHR& copy_src); + safe_VkQueueFamilyOwnershipTransferPropertiesKHR(); + ~safe_VkQueueFamilyOwnershipTransferPropertiesKHR(); + void initialize(const VkQueueFamilyOwnershipTransferPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkQueueFamilyOwnershipTransferPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkQueueFamilyOwnershipTransferPropertiesKHR* ptr() { + return reinterpret_cast(this); + } + VkQueueFamilyOwnershipTransferPropertiesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; struct safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR { VkStructureType sType; void* pNext{}; @@ -17841,6 +18110,465 @@ struct safe_VkDirectDriverLoadingListLUNARG { VkDirectDriverLoadingListLUNARG* ptr() { return reinterpret_cast(this); } VkDirectDriverLoadingListLUNARG const* ptr() const { return reinterpret_cast(this); } }; +struct safe_VkTensorDescriptionARM { + VkStructureType sType; + const void* pNext{}; + VkTensorTilingARM tiling; + VkFormat format; + uint32_t dimensionCount; + const int64_t* pDimensions{}; + const int64_t* pStrides{}; + VkTensorUsageFlagsARM usage; + + safe_VkTensorDescriptionARM(const VkTensorDescriptionARM* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkTensorDescriptionARM(const safe_VkTensorDescriptionARM& copy_src); + safe_VkTensorDescriptionARM& operator=(const safe_VkTensorDescriptionARM& copy_src); + safe_VkTensorDescriptionARM(); + ~safe_VkTensorDescriptionARM(); + void initialize(const VkTensorDescriptionARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkTensorDescriptionARM* copy_src, PNextCopyState* copy_state = {}); + VkTensorDescriptionARM* ptr() { return reinterpret_cast(this); } + VkTensorDescriptionARM const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkTensorCreateInfoARM { + VkStructureType sType; + const void* pNext{}; + VkTensorCreateFlagsARM flags; + safe_VkTensorDescriptionARM* pDescription{}; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices{}; + + safe_VkTensorCreateInfoARM(const VkTensorCreateInfoARM* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkTensorCreateInfoARM(const safe_VkTensorCreateInfoARM& copy_src); + safe_VkTensorCreateInfoARM& operator=(const safe_VkTensorCreateInfoARM& copy_src); + safe_VkTensorCreateInfoARM(); + ~safe_VkTensorCreateInfoARM(); + void initialize(const VkTensorCreateInfoARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkTensorCreateInfoARM* copy_src, PNextCopyState* copy_state = {}); + VkTensorCreateInfoARM* ptr() { return reinterpret_cast(this); } + VkTensorCreateInfoARM const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkTensorViewCreateInfoARM { + VkStructureType sType; + const void* pNext{}; + VkTensorViewCreateFlagsARM flags; + VkTensorARM tensor; + VkFormat format; + + safe_VkTensorViewCreateInfoARM(const VkTensorViewCreateInfoARM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkTensorViewCreateInfoARM(const safe_VkTensorViewCreateInfoARM& copy_src); + safe_VkTensorViewCreateInfoARM& operator=(const safe_VkTensorViewCreateInfoARM& copy_src); + safe_VkTensorViewCreateInfoARM(); + ~safe_VkTensorViewCreateInfoARM(); + void initialize(const VkTensorViewCreateInfoARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkTensorViewCreateInfoARM* copy_src, PNextCopyState* copy_state = {}); + VkTensorViewCreateInfoARM* ptr() { return reinterpret_cast(this); } + VkTensorViewCreateInfoARM const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkTensorMemoryRequirementsInfoARM { + VkStructureType sType; + const void* pNext{}; + VkTensorARM tensor; + + safe_VkTensorMemoryRequirementsInfoARM(const VkTensorMemoryRequirementsInfoARM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkTensorMemoryRequirementsInfoARM(const safe_VkTensorMemoryRequirementsInfoARM& copy_src); + safe_VkTensorMemoryRequirementsInfoARM& operator=(const safe_VkTensorMemoryRequirementsInfoARM& copy_src); + safe_VkTensorMemoryRequirementsInfoARM(); + ~safe_VkTensorMemoryRequirementsInfoARM(); + void initialize(const VkTensorMemoryRequirementsInfoARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkTensorMemoryRequirementsInfoARM* copy_src, PNextCopyState* copy_state = {}); + VkTensorMemoryRequirementsInfoARM* ptr() { return reinterpret_cast(this); } + VkTensorMemoryRequirementsInfoARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkBindTensorMemoryInfoARM { + VkStructureType sType; + const void* pNext{}; + VkTensorARM tensor; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + + safe_VkBindTensorMemoryInfoARM(const VkBindTensorMemoryInfoARM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkBindTensorMemoryInfoARM(const safe_VkBindTensorMemoryInfoARM& copy_src); + safe_VkBindTensorMemoryInfoARM& operator=(const safe_VkBindTensorMemoryInfoARM& copy_src); + safe_VkBindTensorMemoryInfoARM(); + ~safe_VkBindTensorMemoryInfoARM(); + void initialize(const VkBindTensorMemoryInfoARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBindTensorMemoryInfoARM* copy_src, PNextCopyState* copy_state = {}); + VkBindTensorMemoryInfoARM* ptr() { return reinterpret_cast(this); } + VkBindTensorMemoryInfoARM const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkWriteDescriptorSetTensorARM { + VkStructureType sType; + const void* pNext{}; + uint32_t tensorViewCount; + VkTensorViewARM* pTensorViews{}; + + safe_VkWriteDescriptorSetTensorARM(const VkWriteDescriptorSetTensorARM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkWriteDescriptorSetTensorARM(const safe_VkWriteDescriptorSetTensorARM& copy_src); + safe_VkWriteDescriptorSetTensorARM& operator=(const safe_VkWriteDescriptorSetTensorARM& copy_src); + safe_VkWriteDescriptorSetTensorARM(); + ~safe_VkWriteDescriptorSetTensorARM(); + void initialize(const VkWriteDescriptorSetTensorARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkWriteDescriptorSetTensorARM* copy_src, PNextCopyState* copy_state = {}); + VkWriteDescriptorSetTensorARM* ptr() { return reinterpret_cast(this); } + VkWriteDescriptorSetTensorARM const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkTensorFormatPropertiesARM { + VkStructureType sType; + const void* pNext{}; + VkFormatFeatureFlags2 optimalTilingTensorFeatures; + VkFormatFeatureFlags2 linearTilingTensorFeatures; + + safe_VkTensorFormatPropertiesARM(const VkTensorFormatPropertiesARM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkTensorFormatPropertiesARM(const safe_VkTensorFormatPropertiesARM& copy_src); + safe_VkTensorFormatPropertiesARM& operator=(const safe_VkTensorFormatPropertiesARM& copy_src); + safe_VkTensorFormatPropertiesARM(); + ~safe_VkTensorFormatPropertiesARM(); + void initialize(const VkTensorFormatPropertiesARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkTensorFormatPropertiesARM* copy_src, PNextCopyState* copy_state = {}); + VkTensorFormatPropertiesARM* ptr() { return reinterpret_cast(this); } + VkTensorFormatPropertiesARM const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceTensorPropertiesARM { + VkStructureType sType; + void* pNext{}; + uint32_t maxTensorDimensionCount; + uint64_t maxTensorElements; + uint64_t maxPerDimensionTensorElements; + int64_t maxTensorStride; + uint64_t maxTensorSize; + uint32_t maxTensorShaderAccessArrayLength; + uint32_t maxTensorShaderAccessSize; + uint32_t maxDescriptorSetStorageTensors; + uint32_t maxPerStageDescriptorSetStorageTensors; + uint32_t maxDescriptorSetUpdateAfterBindStorageTensors; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageTensors; + VkBool32 shaderStorageTensorArrayNonUniformIndexingNative; + VkShaderStageFlags shaderTensorSupportedStages; + + safe_VkPhysicalDeviceTensorPropertiesARM(const VkPhysicalDeviceTensorPropertiesARM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceTensorPropertiesARM(const safe_VkPhysicalDeviceTensorPropertiesARM& copy_src); + safe_VkPhysicalDeviceTensorPropertiesARM& operator=(const safe_VkPhysicalDeviceTensorPropertiesARM& copy_src); + safe_VkPhysicalDeviceTensorPropertiesARM(); + ~safe_VkPhysicalDeviceTensorPropertiesARM(); + void initialize(const VkPhysicalDeviceTensorPropertiesARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceTensorPropertiesARM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceTensorPropertiesARM* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceTensorPropertiesARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkTensorMemoryBarrierARM { + VkStructureType sType; + const void* pNext{}; + VkPipelineStageFlags2 srcStageMask; + VkAccessFlags2 srcAccessMask; + VkPipelineStageFlags2 dstStageMask; + VkAccessFlags2 dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkTensorARM tensor; + + safe_VkTensorMemoryBarrierARM(const VkTensorMemoryBarrierARM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkTensorMemoryBarrierARM(const safe_VkTensorMemoryBarrierARM& copy_src); + safe_VkTensorMemoryBarrierARM& operator=(const safe_VkTensorMemoryBarrierARM& copy_src); + safe_VkTensorMemoryBarrierARM(); + ~safe_VkTensorMemoryBarrierARM(); + void initialize(const VkTensorMemoryBarrierARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkTensorMemoryBarrierARM* copy_src, PNextCopyState* copy_state = {}); + VkTensorMemoryBarrierARM* ptr() { return reinterpret_cast(this); } + VkTensorMemoryBarrierARM const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkTensorDependencyInfoARM { + VkStructureType sType; + const void* pNext{}; + uint32_t tensorMemoryBarrierCount; + safe_VkTensorMemoryBarrierARM* pTensorMemoryBarriers{}; + + safe_VkTensorDependencyInfoARM(const VkTensorDependencyInfoARM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkTensorDependencyInfoARM(const safe_VkTensorDependencyInfoARM& copy_src); + safe_VkTensorDependencyInfoARM& operator=(const safe_VkTensorDependencyInfoARM& copy_src); + safe_VkTensorDependencyInfoARM(); + ~safe_VkTensorDependencyInfoARM(); + void initialize(const VkTensorDependencyInfoARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkTensorDependencyInfoARM* copy_src, PNextCopyState* copy_state = {}); + VkTensorDependencyInfoARM* ptr() { return reinterpret_cast(this); } + VkTensorDependencyInfoARM const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceTensorFeaturesARM { + VkStructureType sType; + void* pNext{}; + VkBool32 tensorNonPacked; + VkBool32 shaderTensorAccess; + VkBool32 shaderStorageTensorArrayDynamicIndexing; + VkBool32 shaderStorageTensorArrayNonUniformIndexing; + VkBool32 descriptorBindingStorageTensorUpdateAfterBind; + VkBool32 tensors; + + safe_VkPhysicalDeviceTensorFeaturesARM(const VkPhysicalDeviceTensorFeaturesARM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceTensorFeaturesARM(const safe_VkPhysicalDeviceTensorFeaturesARM& copy_src); + safe_VkPhysicalDeviceTensorFeaturesARM& operator=(const safe_VkPhysicalDeviceTensorFeaturesARM& copy_src); + safe_VkPhysicalDeviceTensorFeaturesARM(); + ~safe_VkPhysicalDeviceTensorFeaturesARM(); + void initialize(const VkPhysicalDeviceTensorFeaturesARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceTensorFeaturesARM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceTensorFeaturesARM* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceTensorFeaturesARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDeviceTensorMemoryRequirementsARM { + VkStructureType sType; + const void* pNext{}; + safe_VkTensorCreateInfoARM* pCreateInfo{}; + + safe_VkDeviceTensorMemoryRequirementsARM(const VkDeviceTensorMemoryRequirementsARM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDeviceTensorMemoryRequirementsARM(const safe_VkDeviceTensorMemoryRequirementsARM& copy_src); + safe_VkDeviceTensorMemoryRequirementsARM& operator=(const safe_VkDeviceTensorMemoryRequirementsARM& copy_src); + safe_VkDeviceTensorMemoryRequirementsARM(); + ~safe_VkDeviceTensorMemoryRequirementsARM(); + void initialize(const VkDeviceTensorMemoryRequirementsARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceTensorMemoryRequirementsARM* copy_src, PNextCopyState* copy_state = {}); + VkDeviceTensorMemoryRequirementsARM* ptr() { return reinterpret_cast(this); } + VkDeviceTensorMemoryRequirementsARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkTensorCopyARM { + VkStructureType sType; + const void* pNext{}; + uint32_t dimensionCount; + const uint64_t* pSrcOffset{}; + const uint64_t* pDstOffset{}; + const uint64_t* pExtent{}; + + safe_VkTensorCopyARM(const VkTensorCopyARM* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkTensorCopyARM(const safe_VkTensorCopyARM& copy_src); + safe_VkTensorCopyARM& operator=(const safe_VkTensorCopyARM& copy_src); + safe_VkTensorCopyARM(); + ~safe_VkTensorCopyARM(); + void initialize(const VkTensorCopyARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkTensorCopyARM* copy_src, PNextCopyState* copy_state = {}); + VkTensorCopyARM* ptr() { return reinterpret_cast(this); } + VkTensorCopyARM const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCopyTensorInfoARM { + VkStructureType sType; + const void* pNext{}; + VkTensorARM srcTensor; + VkTensorARM dstTensor; + uint32_t regionCount; + safe_VkTensorCopyARM* pRegions{}; + + safe_VkCopyTensorInfoARM(const VkCopyTensorInfoARM* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkCopyTensorInfoARM(const safe_VkCopyTensorInfoARM& copy_src); + safe_VkCopyTensorInfoARM& operator=(const safe_VkCopyTensorInfoARM& copy_src); + safe_VkCopyTensorInfoARM(); + ~safe_VkCopyTensorInfoARM(); + void initialize(const VkCopyTensorInfoARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyTensorInfoARM* copy_src, PNextCopyState* copy_state = {}); + VkCopyTensorInfoARM* ptr() { return reinterpret_cast(this); } + VkCopyTensorInfoARM const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkMemoryDedicatedAllocateInfoTensorARM { + VkStructureType sType; + const void* pNext{}; + VkTensorARM tensor; + + safe_VkMemoryDedicatedAllocateInfoTensorARM(const VkMemoryDedicatedAllocateInfoTensorARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMemoryDedicatedAllocateInfoTensorARM(const safe_VkMemoryDedicatedAllocateInfoTensorARM& copy_src); + safe_VkMemoryDedicatedAllocateInfoTensorARM& operator=(const safe_VkMemoryDedicatedAllocateInfoTensorARM& copy_src); + safe_VkMemoryDedicatedAllocateInfoTensorARM(); + ~safe_VkMemoryDedicatedAllocateInfoTensorARM(); + void initialize(const VkMemoryDedicatedAllocateInfoTensorARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryDedicatedAllocateInfoTensorARM* copy_src, PNextCopyState* copy_state = {}); + VkMemoryDedicatedAllocateInfoTensorARM* ptr() { return reinterpret_cast(this); } + VkMemoryDedicatedAllocateInfoTensorARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceExternalTensorInfoARM { + VkStructureType sType; + const void* pNext{}; + VkTensorCreateFlagsARM flags; + safe_VkTensorDescriptionARM* pDescription{}; + VkExternalMemoryHandleTypeFlagBits handleType; + + safe_VkPhysicalDeviceExternalTensorInfoARM(const VkPhysicalDeviceExternalTensorInfoARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceExternalTensorInfoARM(const safe_VkPhysicalDeviceExternalTensorInfoARM& copy_src); + safe_VkPhysicalDeviceExternalTensorInfoARM& operator=(const safe_VkPhysicalDeviceExternalTensorInfoARM& copy_src); + safe_VkPhysicalDeviceExternalTensorInfoARM(); + ~safe_VkPhysicalDeviceExternalTensorInfoARM(); + void initialize(const VkPhysicalDeviceExternalTensorInfoARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceExternalTensorInfoARM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceExternalTensorInfoARM* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceExternalTensorInfoARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkExternalTensorPropertiesARM { + VkStructureType sType; + const void* pNext{}; + VkExternalMemoryProperties externalMemoryProperties; + + safe_VkExternalTensorPropertiesARM(const VkExternalTensorPropertiesARM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExternalTensorPropertiesARM(const safe_VkExternalTensorPropertiesARM& copy_src); + safe_VkExternalTensorPropertiesARM& operator=(const safe_VkExternalTensorPropertiesARM& copy_src); + safe_VkExternalTensorPropertiesARM(); + ~safe_VkExternalTensorPropertiesARM(); + void initialize(const VkExternalTensorPropertiesARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExternalTensorPropertiesARM* copy_src, PNextCopyState* copy_state = {}); + VkExternalTensorPropertiesARM* ptr() { return reinterpret_cast(this); } + VkExternalTensorPropertiesARM const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkExternalMemoryTensorCreateInfoARM { + VkStructureType sType; + const void* pNext{}; + VkExternalMemoryHandleTypeFlags handleTypes; + + safe_VkExternalMemoryTensorCreateInfoARM(const VkExternalMemoryTensorCreateInfoARM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExternalMemoryTensorCreateInfoARM(const safe_VkExternalMemoryTensorCreateInfoARM& copy_src); + safe_VkExternalMemoryTensorCreateInfoARM& operator=(const safe_VkExternalMemoryTensorCreateInfoARM& copy_src); + safe_VkExternalMemoryTensorCreateInfoARM(); + ~safe_VkExternalMemoryTensorCreateInfoARM(); + void initialize(const VkExternalMemoryTensorCreateInfoARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExternalMemoryTensorCreateInfoARM* copy_src, PNextCopyState* copy_state = {}); + VkExternalMemoryTensorCreateInfoARM* ptr() { return reinterpret_cast(this); } + VkExternalMemoryTensorCreateInfoARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM { + VkStructureType sType; + void* pNext{}; + VkBool32 descriptorBufferTensorDescriptors; + + safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM(const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM(const safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM& copy_src); + safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM& operator=( + const safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM& copy_src); + safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM(); + ~safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM(); + void initialize(const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDescriptorBufferTensorFeaturesARM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDescriptorBufferTensorFeaturesARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM { + VkStructureType sType; + const void* pNext{}; + size_t tensorCaptureReplayDescriptorDataSize; + size_t tensorViewCaptureReplayDescriptorDataSize; + size_t tensorDescriptorSize; + + safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM(const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM( + const safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM& copy_src); + safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM& operator=( + const safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM& copy_src); + safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM(); + ~safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM(); + void initialize(const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDescriptorBufferTensorPropertiesARM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDescriptorBufferTensorPropertiesARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDescriptorGetTensorInfoARM { + VkStructureType sType; + const void* pNext{}; + VkTensorViewARM tensorView; + + safe_VkDescriptorGetTensorInfoARM(const VkDescriptorGetTensorInfoARM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDescriptorGetTensorInfoARM(const safe_VkDescriptorGetTensorInfoARM& copy_src); + safe_VkDescriptorGetTensorInfoARM& operator=(const safe_VkDescriptorGetTensorInfoARM& copy_src); + safe_VkDescriptorGetTensorInfoARM(); + ~safe_VkDescriptorGetTensorInfoARM(); + void initialize(const VkDescriptorGetTensorInfoARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDescriptorGetTensorInfoARM* copy_src, PNextCopyState* copy_state = {}); + VkDescriptorGetTensorInfoARM* ptr() { return reinterpret_cast(this); } + VkDescriptorGetTensorInfoARM const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkTensorCaptureDescriptorDataInfoARM { + VkStructureType sType; + const void* pNext{}; + VkTensorARM tensor; + + safe_VkTensorCaptureDescriptorDataInfoARM(const VkTensorCaptureDescriptorDataInfoARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkTensorCaptureDescriptorDataInfoARM(const safe_VkTensorCaptureDescriptorDataInfoARM& copy_src); + safe_VkTensorCaptureDescriptorDataInfoARM& operator=(const safe_VkTensorCaptureDescriptorDataInfoARM& copy_src); + safe_VkTensorCaptureDescriptorDataInfoARM(); + ~safe_VkTensorCaptureDescriptorDataInfoARM(); + void initialize(const VkTensorCaptureDescriptorDataInfoARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkTensorCaptureDescriptorDataInfoARM* copy_src, PNextCopyState* copy_state = {}); + VkTensorCaptureDescriptorDataInfoARM* ptr() { return reinterpret_cast(this); } + VkTensorCaptureDescriptorDataInfoARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkTensorViewCaptureDescriptorDataInfoARM { + VkStructureType sType; + const void* pNext{}; + VkTensorViewARM tensorView; + + safe_VkTensorViewCaptureDescriptorDataInfoARM(const VkTensorViewCaptureDescriptorDataInfoARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkTensorViewCaptureDescriptorDataInfoARM(const safe_VkTensorViewCaptureDescriptorDataInfoARM& copy_src); + safe_VkTensorViewCaptureDescriptorDataInfoARM& operator=(const safe_VkTensorViewCaptureDescriptorDataInfoARM& copy_src); + safe_VkTensorViewCaptureDescriptorDataInfoARM(); + ~safe_VkTensorViewCaptureDescriptorDataInfoARM(); + void initialize(const VkTensorViewCaptureDescriptorDataInfoARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkTensorViewCaptureDescriptorDataInfoARM* copy_src, PNextCopyState* copy_state = {}); + VkTensorViewCaptureDescriptorDataInfoARM* ptr() { return reinterpret_cast(this); } + VkTensorViewCaptureDescriptorDataInfoARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkFrameBoundaryTensorsARM { + VkStructureType sType; + const void* pNext{}; + uint32_t tensorCount; + VkTensorARM* pTensors{}; + + safe_VkFrameBoundaryTensorsARM(const VkFrameBoundaryTensorsARM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkFrameBoundaryTensorsARM(const safe_VkFrameBoundaryTensorsARM& copy_src); + safe_VkFrameBoundaryTensorsARM& operator=(const safe_VkFrameBoundaryTensorsARM& copy_src); + safe_VkFrameBoundaryTensorsARM(); + ~safe_VkFrameBoundaryTensorsARM(); + void initialize(const VkFrameBoundaryTensorsARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkFrameBoundaryTensorsARM* copy_src, PNextCopyState* copy_state = {}); + VkFrameBoundaryTensorsARM* ptr() { return reinterpret_cast(this); } + VkFrameBoundaryTensorsARM const* ptr() const { return reinterpret_cast(this); } +}; struct safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT { VkStructureType sType; void* pNext{}; @@ -19579,6 +20307,25 @@ struct safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT { return reinterpret_cast(this); } }; +struct safe_VkPhysicalDeviceShaderFloat8FeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderFloat8; + VkBool32 shaderFloat8CooperativeMatrix; + + safe_VkPhysicalDeviceShaderFloat8FeaturesEXT(const VkPhysicalDeviceShaderFloat8FeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderFloat8FeaturesEXT(const safe_VkPhysicalDeviceShaderFloat8FeaturesEXT& copy_src); + safe_VkPhysicalDeviceShaderFloat8FeaturesEXT& operator=(const safe_VkPhysicalDeviceShaderFloat8FeaturesEXT& copy_src); + safe_VkPhysicalDeviceShaderFloat8FeaturesEXT(); + ~safe_VkPhysicalDeviceShaderFloat8FeaturesEXT(); + void initialize(const VkPhysicalDeviceShaderFloat8FeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderFloat8FeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderFloat8FeaturesEXT* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceShaderFloat8FeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; struct safe_VkPhysicalDeviceRayTracingValidationFeaturesNV { VkStructureType sType; void* pNext{}; diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp index 581f997..38c27cb 100644 --- a/include/vulkan/utility/vk_struct_helper.hpp +++ b/include/vulkan/utility/vk_struct_helper.hpp @@ -451,6 +451,12 @@ template <> inline VkStructureType GetSType inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PRESENT_WAIT_2_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; } @@ -483,8 +489,14 @@ template <> inline VkStructureType GetSType() { template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT; } @@ -506,6 +518,9 @@ template <> inline VkStructureType GetSType inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR; } @@ -933,6 +948,30 @@ template <> inline VkStructureType GetSType inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_TENSOR_COPY_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT; } @@ -1022,6 +1061,7 @@ template <> inline VkStructureType GetSType inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV; } @@ -1224,6 +1264,8 @@ template<> inline VkObjectType GetObjectType() { ret template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA; } #endif // VK_USE_PLATFORM_FUCHSIA template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_MICROMAP_EXT; } +template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_TENSOR_ARM; } +template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_TENSOR_VIEW_ARM; } template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV; } template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_SHADER_EXT; } template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV; } diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h index 4921053..6df410d 100644 --- a/include/vulkan/vk_enum_string_helper.h +++ b/include/vulkan/vk_enum_string_helper.h @@ -1768,6 +1768,54 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG"; case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: return "VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG"; + case VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM: + return "VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM"; + case VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM: + return "VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM"; + case VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM: + return "VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM"; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM: + return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM"; + case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM: + return "VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM"; + case VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM: + return "VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM"; + case VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM: + return "VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM"; + case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM: + return "VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM"; + case VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM: + return "VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM"; + case VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM: + return "VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM"; + case VK_STRUCTURE_TYPE_TENSOR_COPY_ARM: + return "VK_STRUCTURE_TYPE_TENSOR_COPY_ARM"; + case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM: + return "VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM"; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM: + return "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM"; + case VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM: + return "VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM"; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM: + return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM"; + case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM: + return "VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM"; + case VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: + return "VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM"; + case VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: + return "VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM"; + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: + return "VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: @@ -1806,6 +1854,18 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD"; case VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD: return "VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD"; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR: + return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR"; + case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR: + return "VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR"; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR: + return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR"; + case VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR: + return "VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: @@ -1942,6 +2002,14 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR"; case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR: + return "VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR: + return "VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR: + return "VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR"; case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: @@ -1968,6 +2036,10 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR"; + case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT: + return "VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT"; case VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX: return "VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX"; case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX: @@ -2050,6 +2122,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: @@ -2122,6 +2196,12 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT"; case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR"; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR: + return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR"; case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR: @@ -2246,6 +2326,8 @@ static inline const char* string_VkImageLayout(VkImageLayout input_value) { return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR"; case VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT: return "VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT"; + case VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM: + return "VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM"; case VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR: return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR"; case VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT: @@ -2356,6 +2438,10 @@ static inline const char* string_VkObjectType(VkObjectType input_value) { return "VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA"; case VK_OBJECT_TYPE_MICROMAP_EXT: return "VK_OBJECT_TYPE_MICROMAP_EXT"; + case VK_OBJECT_TYPE_TENSOR_ARM: + return "VK_OBJECT_TYPE_TENSOR_ARM"; + case VK_OBJECT_TYPE_TENSOR_VIEW_ARM: + return "VK_OBJECT_TYPE_TENSOR_VIEW_ARM"; case VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV: return "VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV"; case VK_OBJECT_TYPE_SHADER_EXT: @@ -2918,6 +3004,8 @@ static inline const char* string_VkFormat(VkFormat input_value) { return "VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG"; case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: return "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG"; + case VK_FORMAT_R8_BOOL_ARM: + return "VK_FORMAT_R8_BOOL_ARM"; case VK_FORMAT_R16G16_SFIXED5_NV: return "VK_FORMAT_R16G16_SFIXED5_NV"; case VK_FORMAT_R10X6_UINT_PACK16_ARM: @@ -3624,6 +3712,8 @@ static inline const char* string_VkDescriptorType(VkDescriptorType input_value) return "VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM"; case VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM: return "VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM"; + case VK_DESCRIPTOR_TYPE_TENSOR_ARM: + return "VK_DESCRIPTOR_TYPE_TENSOR_ARM"; case VK_DESCRIPTOR_TYPE_MUTABLE_EXT: return "VK_DESCRIPTOR_TYPE_MUTABLE_EXT"; case VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV: @@ -4140,6 +4230,10 @@ static inline const char* string_VkComponentTypeKHR(VkComponentTypeKHR input_val return "VK_COMPONENT_TYPE_FLOAT_E4M3_NV"; case VK_COMPONENT_TYPE_FLOAT_E5M2_NV: return "VK_COMPONENT_TYPE_FLOAT_E5M2_NV"; + case VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT: + return "VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT"; + case VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT: + return "VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT"; default: return "Unhandled VkComponentTypeKHR"; } @@ -4214,6 +4308,16 @@ static inline const char* string_VkPhysicalDeviceLayeredApiKHR(VkPhysicalDeviceL return "Unhandled VkPhysicalDeviceLayeredApiKHR"; } } +static inline const char* string_VkDefaultVertexAttributeValueKHR(VkDefaultVertexAttributeValueKHR input_value) { + switch (input_value) { + case VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR: + return "VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR"; + case VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR: + return "VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR"; + default: + return "Unhandled VkDefaultVertexAttributeValueKHR"; + } +} static inline const char* string_VkDebugReportObjectTypeEXT(VkDebugReportObjectTypeEXT input_value) { switch (input_value) { case VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT: @@ -4994,6 +5098,16 @@ static inline const char* string_VkDirectDriverLoadingModeLUNARG(VkDirectDriverL return "Unhandled VkDirectDriverLoadingModeLUNARG"; } } +static inline const char* string_VkTensorTilingARM(VkTensorTilingARM input_value) { + switch (input_value) { + case VK_TENSOR_TILING_OPTIMAL_ARM: + return "VK_TENSOR_TILING_OPTIMAL_ARM"; + case VK_TENSOR_TILING_LINEAR_ARM: + return "VK_TENSOR_TILING_LINEAR_ARM"; + default: + return "Unhandled VkTensorTilingARM"; + } +} static inline const char* string_VkOpticalFlowPerformanceLevelNV(VkOpticalFlowPerformanceLevelNV input_value) { switch (input_value) { case VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV: @@ -5688,6 +5802,8 @@ static inline const char* string_VkImageUsageFlagBits(VkImageUsageFlagBits input return "VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM"; case VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM: return "VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM"; + case VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM: + return "VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM"; case VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM: return "VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM"; case VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR: @@ -6131,6 +6247,31 @@ static inline std::string string_VkQueryPipelineStatisticFlags(VkQueryPipelineSt return ret; } #endif // __cplusplus +static inline const char* string_VkQueryPoolCreateFlagBits(VkQueryPoolCreateFlagBits input_value) { + switch (input_value) { + case VK_QUERY_POOL_CREATE_RESET_BIT_KHR: + return "VK_QUERY_POOL_CREATE_RESET_BIT_KHR"; + default: + return "Unhandled VkQueryPoolCreateFlagBits"; + } +} + +#ifdef __cplusplus +static inline std::string string_VkQueryPoolCreateFlags(VkQueryPoolCreateFlags input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkQueryPoolCreateFlagBits(static_cast(1U << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkQueryPoolCreateFlags(0)"); + return ret; +} +#endif // __cplusplus static inline const char* string_VkQueryResultFlagBits(VkQueryResultFlagBits input_value) { switch (input_value) { case VK_QUERY_RESULT_64_BIT: @@ -6785,6 +6926,8 @@ static inline const char* string_VkDependencyFlagBits(VkDependencyFlagBits input return "VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT"; case VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR: return "VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR"; + case VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR: + return "VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR"; default: return "Unhandled VkDependencyFlagBits"; } @@ -7433,8 +7576,8 @@ static inline const char* string_VkResolveModeFlagBits(VkResolveModeFlagBits inp return "VK_RESOLVE_MODE_MIN_BIT"; case VK_RESOLVE_MODE_MAX_BIT: return "VK_RESOLVE_MODE_MAX_BIT"; - case VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID: - return "VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID"; + case VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID: + return "VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID"; default: return "Unhandled VkResolveModeFlagBits"; } @@ -7806,6 +7949,8 @@ static inline const char* string_VkFormatFeatureFlagBits2(uint64_t input_value) if (input_value == VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM) return "VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM"; if (input_value == VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM) return "VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM"; if (input_value == VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM) return "VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM"; + if (input_value == VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM) return "VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM"; + if (input_value == VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM) return "VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM"; if (input_value == VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV) return "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV"; if (input_value == VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV) return "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV"; if (input_value == VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV) return "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV"; @@ -7966,8 +8111,8 @@ static inline std::string string_VkBufferUsageFlags2(VkBufferUsageFlags2 input_v #endif // __cplusplus static inline const char* string_VkHostImageCopyFlagBits(VkHostImageCopyFlagBits input_value) { switch (input_value) { - case VK_HOST_IMAGE_COPY_MEMCPY: - return "VK_HOST_IMAGE_COPY_MEMCPY"; + case VK_HOST_IMAGE_COPY_MEMCPY_BIT: + return "VK_HOST_IMAGE_COPY_MEMCPY_BIT"; default: return "Unhandled VkHostImageCopyFlagBits"; } @@ -8071,6 +8216,10 @@ static inline const char* string_VkSwapchainCreateFlagBitsKHR(VkSwapchainCreateF return "VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR"; case VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT: return "VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT"; + case VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR: + return "VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR"; + case VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR: + return "VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR"; default: return "Unhandled VkSwapchainCreateFlagBitsKHR"; } @@ -8170,6 +8319,8 @@ static inline const char* string_VkVideoCodecOperationFlagBitsKHR(VkVideoCodecOp return "VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR"; case VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR: return "VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR"; + case VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR: + return "VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR"; default: return "Unhandled VkVideoCodecOperationFlagBitsKHR"; } @@ -9394,10 +9545,10 @@ static inline const char* string_VkGeometryInstanceFlagBitsKHR(VkGeometryInstanc return "VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR"; case VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR: return "VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR"; - case VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT: - return "VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT"; - case VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT: - return "VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT"; + case VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT: + return "VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT"; + case VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT: + return "VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT"; default: return "Unhandled VkGeometryInstanceFlagBitsKHR"; } @@ -9433,18 +9584,18 @@ static inline const char* string_VkBuildAccelerationStructureFlagBitsKHR(VkBuild return "VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR"; case VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV: return "VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV"; - case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT: - return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT"; - case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT: - return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT"; - case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT: - return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT"; + case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT: + return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT"; + case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT: + return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT"; + case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT: + return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT"; #ifdef VK_ENABLE_BETA_EXTENSIONS - case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV: - return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV"; + case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV: + return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV"; #endif // VK_ENABLE_BETA_EXTENSIONS - case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR: - return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR"; + case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR: + return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR"; default: return "Unhandled VkBuildAccelerationStructureFlagBitsKHR"; } @@ -9989,6 +10140,74 @@ static inline std::string string_VkMemoryDecompressionMethodFlagsNV(VkMemoryDeco return ret; } #endif // __cplusplus +static inline const char* string_VkTensorCreateFlagBitsARM(uint64_t input_value) { + if (input_value == VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM) return "VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM"; + if (input_value == VK_TENSOR_CREATE_PROTECTED_BIT_ARM) return "VK_TENSOR_CREATE_PROTECTED_BIT_ARM"; + if (input_value == VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM) return "VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM"; + return "Unhandled VkTensorCreateFlagBitsARM"; +} + +#ifdef __cplusplus +static inline std::string string_VkTensorCreateFlagsARM(VkTensorCreateFlagsARM input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkTensorCreateFlagBitsARM(static_cast(1ULL << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkTensorCreateFlagsARM(0)"); + return ret; +} +#endif // __cplusplus +static inline const char* string_VkTensorViewCreateFlagBitsARM(uint64_t input_value) { + if (input_value == VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM) return "VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM"; + return "Unhandled VkTensorViewCreateFlagBitsARM"; +} + +#ifdef __cplusplus +static inline std::string string_VkTensorViewCreateFlagsARM(VkTensorViewCreateFlagsARM input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkTensorViewCreateFlagBitsARM(static_cast(1ULL << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkTensorViewCreateFlagsARM(0)"); + return ret; +} +#endif // __cplusplus +static inline const char* string_VkTensorUsageFlagBitsARM(uint64_t input_value) { + if (input_value == VK_TENSOR_USAGE_SHADER_BIT_ARM) return "VK_TENSOR_USAGE_SHADER_BIT_ARM"; + if (input_value == VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM) return "VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM"; + if (input_value == VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM) return "VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM"; + if (input_value == VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM) return "VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM"; + return "Unhandled VkTensorUsageFlagBitsARM"; +} + +#ifdef __cplusplus +static inline std::string string_VkTensorUsageFlagsARM(VkTensorUsageFlagsARM input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkTensorUsageFlagBitsARM(static_cast(1ULL << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkTensorUsageFlagsARM(0)"); + return ret; +} +#endif // __cplusplus static inline const char* string_VkOpticalFlowGridSizeFlagBitsNV(VkOpticalFlowGridSizeFlagBitsNV input_value) { switch (input_value) { case VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV: @@ -11241,6 +11460,18 @@ static inline const char* string_VkStructureName(VkStructureType input_value) { return "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: return "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR"; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR: + return "VkSurfaceCapabilitiesPresentId2KHR"; + case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR: + return "VkPresentId2KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: + return "VkPhysicalDevicePresentId2FeaturesKHR"; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR: + return "VkSurfaceCapabilitiesPresentWait2KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: + return "VkPhysicalDevicePresentWait2FeaturesKHR"; + case VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR: + return "VkPresentWait2InfoKHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: return "VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: @@ -11305,10 +11536,22 @@ static inline const char* string_VkStructureName(VkStructureType input_value) { return "VkVideoEncodeAV1RateControlInfoKHR"; case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR: return "VkVideoEncodeAV1RateControlLayerInfoKHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: + return "VkPhysicalDeviceVideoDecodeVP9FeaturesKHR"; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR: + return "VkVideoDecodeVP9ProfileInfoKHR"; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR: + return "VkVideoDecodeVP9CapabilitiesKHR"; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR: + return "VkVideoDecodeVP9PictureInfoKHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: return "VkPhysicalDeviceVideoMaintenance1FeaturesKHR"; case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: return "VkVideoInlineQueryInfoKHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: + return "VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR"; + case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT: + return "VkAttachmentFeedbackLoopInfoEXT"; case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR: return "VkCalibratedTimestampInfoKHR"; case VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT: @@ -11351,6 +11594,12 @@ static inline const char* string_VkStructureName(VkStructureType input_value) { return "VkPhysicalDeviceMaintenance8FeaturesKHR"; case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR: return "VkMemoryBarrierAccessFlags3KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: + return "VkPhysicalDeviceMaintenance9FeaturesKHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: + return "VkPhysicalDeviceMaintenance9PropertiesKHR"; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR: + return "VkQueueFamilyOwnershipTransferPropertiesKHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR: return "VkPhysicalDeviceVideoMaintenance2FeaturesKHR"; case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR: @@ -12171,6 +12420,54 @@ static inline const char* string_VkStructureName(VkStructureType input_value) { return "VkDirectDriverLoadingInfoLUNARG"; case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: return "VkDirectDriverLoadingListLUNARG"; + case VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM: + return "VkTensorDescriptionARM"; + case VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM: + return "VkTensorCreateInfoARM"; + case VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM: + return "VkTensorViewCreateInfoARM"; + case VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM: + return "VkTensorMemoryRequirementsInfoARM"; + case VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM: + return "VkBindTensorMemoryInfoARM"; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM: + return "VkWriteDescriptorSetTensorARM"; + case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM: + return "VkTensorFormatPropertiesARM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM: + return "VkPhysicalDeviceTensorPropertiesARM"; + case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM: + return "VkTensorMemoryBarrierARM"; + case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM: + return "VkTensorDependencyInfoARM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: + return "VkPhysicalDeviceTensorFeaturesARM"; + case VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM: + return "VkDeviceTensorMemoryRequirementsARM"; + case VK_STRUCTURE_TYPE_TENSOR_COPY_ARM: + return "VkTensorCopyARM"; + case VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM: + return "VkCopyTensorInfoARM"; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM: + return "VkMemoryDedicatedAllocateInfoTensorARM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM: + return "VkPhysicalDeviceExternalTensorInfoARM"; + case VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM: + return "VkExternalTensorPropertiesARM"; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM: + return "VkExternalMemoryTensorCreateInfoARM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: + return "VkPhysicalDeviceDescriptorBufferTensorFeaturesARM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM: + return "VkPhysicalDeviceDescriptorBufferTensorPropertiesARM"; + case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM: + return "VkDescriptorGetTensorInfoARM"; + case VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: + return "VkTensorCaptureDescriptorDataInfoARM"; + case VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: + return "VkTensorViewCaptureDescriptorDataInfoARM"; + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: + return "VkFrameBoundaryTensorsARM"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: return "VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: @@ -12345,6 +12642,8 @@ static inline const char* string_VkStructureName(VkStructureType input_value) { return "VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: return "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: + return "VkPhysicalDeviceShaderFloat8FeaturesEXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: return "VkPhysicalDeviceRayTracingValidationFeaturesNV"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: diff --git a/scripts/known_good.json b/scripts/known_good.json index 71c8952..9bd946f 100644 --- a/scripts/known_good.json +++ b/scripts/known_good.json @@ -7,7 +7,7 @@ "sub_dir": "Vulkan-Headers", "build_dir": "Vulkan-Headers/build", "install_dir": "Vulkan-Headers/build/install", - "commit": "v1.4.316" + "commit": "v1.4.317" }, { "name": "googletest", diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp index 3289616..e12aaba 100644 --- a/src/vulkan/vk_safe_struct_ext.cpp +++ b/src/vulkan/vk_safe_struct_ext.cpp @@ -22,6 +22,54 @@ namespace vku { +safe_VkAttachmentFeedbackLoopInfoEXT::safe_VkAttachmentFeedbackLoopInfoEXT(const VkAttachmentFeedbackLoopInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), feedbackLoopEnable(in_struct->feedbackLoopEnable) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAttachmentFeedbackLoopInfoEXT::safe_VkAttachmentFeedbackLoopInfoEXT() + : sType(VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT), pNext(nullptr), feedbackLoopEnable() {} + +safe_VkAttachmentFeedbackLoopInfoEXT::safe_VkAttachmentFeedbackLoopInfoEXT(const safe_VkAttachmentFeedbackLoopInfoEXT& copy_src) { + sType = copy_src.sType; + feedbackLoopEnable = copy_src.feedbackLoopEnable; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAttachmentFeedbackLoopInfoEXT& safe_VkAttachmentFeedbackLoopInfoEXT::operator=( + const safe_VkAttachmentFeedbackLoopInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + feedbackLoopEnable = copy_src.feedbackLoopEnable; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAttachmentFeedbackLoopInfoEXT::~safe_VkAttachmentFeedbackLoopInfoEXT() { FreePnextChain(pNext); } + +void safe_VkAttachmentFeedbackLoopInfoEXT::initialize(const VkAttachmentFeedbackLoopInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + feedbackLoopEnable = in_struct->feedbackLoopEnable; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAttachmentFeedbackLoopInfoEXT::initialize(const safe_VkAttachmentFeedbackLoopInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + feedbackLoopEnable = copy_src->feedbackLoopEnable; + pNext = SafePnextCopy(copy_src->pNext); +} + safe_VkSetDescriptorBufferOffsetsInfoEXT::safe_VkSetDescriptorBufferOffsetsInfoEXT( const VkSetDescriptorBufferOffsetsInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), @@ -14301,6 +14349,63 @@ void safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT::initialize( pNext = SafePnextCopy(copy_src->pNext); } +safe_VkPhysicalDeviceShaderFloat8FeaturesEXT::safe_VkPhysicalDeviceShaderFloat8FeaturesEXT( + const VkPhysicalDeviceShaderFloat8FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shaderFloat8(in_struct->shaderFloat8), + shaderFloat8CooperativeMatrix(in_struct->shaderFloat8CooperativeMatrix) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderFloat8FeaturesEXT::safe_VkPhysicalDeviceShaderFloat8FeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT), + pNext(nullptr), + shaderFloat8(), + shaderFloat8CooperativeMatrix() {} + +safe_VkPhysicalDeviceShaderFloat8FeaturesEXT::safe_VkPhysicalDeviceShaderFloat8FeaturesEXT( + const safe_VkPhysicalDeviceShaderFloat8FeaturesEXT& copy_src) { + sType = copy_src.sType; + shaderFloat8 = copy_src.shaderFloat8; + shaderFloat8CooperativeMatrix = copy_src.shaderFloat8CooperativeMatrix; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderFloat8FeaturesEXT& safe_VkPhysicalDeviceShaderFloat8FeaturesEXT::operator=( + const safe_VkPhysicalDeviceShaderFloat8FeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderFloat8 = copy_src.shaderFloat8; + shaderFloat8CooperativeMatrix = copy_src.shaderFloat8CooperativeMatrix; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderFloat8FeaturesEXT::~safe_VkPhysicalDeviceShaderFloat8FeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderFloat8FeaturesEXT::initialize(const VkPhysicalDeviceShaderFloat8FeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderFloat8 = in_struct->shaderFloat8; + shaderFloat8CooperativeMatrix = in_struct->shaderFloat8CooperativeMatrix; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderFloat8FeaturesEXT::initialize(const safe_VkPhysicalDeviceShaderFloat8FeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderFloat8 = copy_src->shaderFloat8; + shaderFloat8CooperativeMatrix = copy_src->shaderFloat8CooperativeMatrix; + pNext = SafePnextCopy(copy_src->pNext); +} + safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT::safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT( const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp index 777704f..b74d2ee 100644 --- a/src/vulkan/vk_safe_struct_khr.cpp +++ b/src/vulkan/vk_safe_struct_khr.cpp @@ -11012,6 +11012,324 @@ void safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::initialize( pNext = SafePnextCopy(copy_src->pNext); } +safe_VkSurfaceCapabilitiesPresentId2KHR::safe_VkSurfaceCapabilitiesPresentId2KHR( + const VkSurfaceCapabilitiesPresentId2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), presentId2Supported(in_struct->presentId2Supported) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSurfaceCapabilitiesPresentId2KHR::safe_VkSurfaceCapabilitiesPresentId2KHR() + : sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR), pNext(nullptr), presentId2Supported() {} + +safe_VkSurfaceCapabilitiesPresentId2KHR::safe_VkSurfaceCapabilitiesPresentId2KHR( + const safe_VkSurfaceCapabilitiesPresentId2KHR& copy_src) { + sType = copy_src.sType; + presentId2Supported = copy_src.presentId2Supported; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSurfaceCapabilitiesPresentId2KHR& safe_VkSurfaceCapabilitiesPresentId2KHR::operator=( + const safe_VkSurfaceCapabilitiesPresentId2KHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + presentId2Supported = copy_src.presentId2Supported; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSurfaceCapabilitiesPresentId2KHR::~safe_VkSurfaceCapabilitiesPresentId2KHR() { FreePnextChain(pNext); } + +void safe_VkSurfaceCapabilitiesPresentId2KHR::initialize(const VkSurfaceCapabilitiesPresentId2KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + presentId2Supported = in_struct->presentId2Supported; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSurfaceCapabilitiesPresentId2KHR::initialize(const safe_VkSurfaceCapabilitiesPresentId2KHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentId2Supported = copy_src->presentId2Supported; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPresentId2KHR::safe_VkPresentId2KHR(const VkPresentId2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pPresentIds(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pPresentIds) { + pPresentIds = new uint64_t[in_struct->swapchainCount]; + memcpy((void*)pPresentIds, (void*)in_struct->pPresentIds, sizeof(uint64_t) * in_struct->swapchainCount); + } +} + +safe_VkPresentId2KHR::safe_VkPresentId2KHR() + : sType(VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR), pNext(nullptr), swapchainCount(), pPresentIds(nullptr) {} + +safe_VkPresentId2KHR::safe_VkPresentId2KHR(const safe_VkPresentId2KHR& copy_src) { + sType = copy_src.sType; + swapchainCount = copy_src.swapchainCount; + pPresentIds = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPresentIds) { + pPresentIds = new uint64_t[copy_src.swapchainCount]; + memcpy((void*)pPresentIds, (void*)copy_src.pPresentIds, sizeof(uint64_t) * copy_src.swapchainCount); + } +} + +safe_VkPresentId2KHR& safe_VkPresentId2KHR::operator=(const safe_VkPresentId2KHR& copy_src) { + if (©_src == this) return *this; + + if (pPresentIds) delete[] pPresentIds; + FreePnextChain(pNext); + + sType = copy_src.sType; + swapchainCount = copy_src.swapchainCount; + pPresentIds = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPresentIds) { + pPresentIds = new uint64_t[copy_src.swapchainCount]; + memcpy((void*)pPresentIds, (void*)copy_src.pPresentIds, sizeof(uint64_t) * copy_src.swapchainCount); + } + + return *this; +} + +safe_VkPresentId2KHR::~safe_VkPresentId2KHR() { + if (pPresentIds) delete[] pPresentIds; + FreePnextChain(pNext); +} + +void safe_VkPresentId2KHR::initialize(const VkPresentId2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pPresentIds) delete[] pPresentIds; + FreePnextChain(pNext); + sType = in_struct->sType; + swapchainCount = in_struct->swapchainCount; + pPresentIds = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pPresentIds) { + pPresentIds = new uint64_t[in_struct->swapchainCount]; + memcpy((void*)pPresentIds, (void*)in_struct->pPresentIds, sizeof(uint64_t) * in_struct->swapchainCount); + } +} + +void safe_VkPresentId2KHR::initialize(const safe_VkPresentId2KHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + swapchainCount = copy_src->swapchainCount; + pPresentIds = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pPresentIds) { + pPresentIds = new uint64_t[copy_src->swapchainCount]; + memcpy((void*)pPresentIds, (void*)copy_src->pPresentIds, sizeof(uint64_t) * copy_src->swapchainCount); + } +} + +safe_VkPhysicalDevicePresentId2FeaturesKHR::safe_VkPhysicalDevicePresentId2FeaturesKHR( + const VkPhysicalDevicePresentId2FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), presentId2(in_struct->presentId2) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePresentId2FeaturesKHR::safe_VkPhysicalDevicePresentId2FeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR), pNext(nullptr), presentId2() {} + +safe_VkPhysicalDevicePresentId2FeaturesKHR::safe_VkPhysicalDevicePresentId2FeaturesKHR( + const safe_VkPhysicalDevicePresentId2FeaturesKHR& copy_src) { + sType = copy_src.sType; + presentId2 = copy_src.presentId2; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePresentId2FeaturesKHR& safe_VkPhysicalDevicePresentId2FeaturesKHR::operator=( + const safe_VkPhysicalDevicePresentId2FeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + presentId2 = copy_src.presentId2; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePresentId2FeaturesKHR::~safe_VkPhysicalDevicePresentId2FeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePresentId2FeaturesKHR::initialize(const VkPhysicalDevicePresentId2FeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + presentId2 = in_struct->presentId2; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePresentId2FeaturesKHR::initialize(const safe_VkPhysicalDevicePresentId2FeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentId2 = copy_src->presentId2; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSurfaceCapabilitiesPresentWait2KHR::safe_VkSurfaceCapabilitiesPresentWait2KHR( + const VkSurfaceCapabilitiesPresentWait2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), presentWait2Supported(in_struct->presentWait2Supported) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSurfaceCapabilitiesPresentWait2KHR::safe_VkSurfaceCapabilitiesPresentWait2KHR() + : sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR), pNext(nullptr), presentWait2Supported() {} + +safe_VkSurfaceCapabilitiesPresentWait2KHR::safe_VkSurfaceCapabilitiesPresentWait2KHR( + const safe_VkSurfaceCapabilitiesPresentWait2KHR& copy_src) { + sType = copy_src.sType; + presentWait2Supported = copy_src.presentWait2Supported; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSurfaceCapabilitiesPresentWait2KHR& safe_VkSurfaceCapabilitiesPresentWait2KHR::operator=( + const safe_VkSurfaceCapabilitiesPresentWait2KHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + presentWait2Supported = copy_src.presentWait2Supported; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSurfaceCapabilitiesPresentWait2KHR::~safe_VkSurfaceCapabilitiesPresentWait2KHR() { FreePnextChain(pNext); } + +void safe_VkSurfaceCapabilitiesPresentWait2KHR::initialize(const VkSurfaceCapabilitiesPresentWait2KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + presentWait2Supported = in_struct->presentWait2Supported; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSurfaceCapabilitiesPresentWait2KHR::initialize(const safe_VkSurfaceCapabilitiesPresentWait2KHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentWait2Supported = copy_src->presentWait2Supported; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePresentWait2FeaturesKHR::safe_VkPhysicalDevicePresentWait2FeaturesKHR( + const VkPhysicalDevicePresentWait2FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), presentWait2(in_struct->presentWait2) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePresentWait2FeaturesKHR::safe_VkPhysicalDevicePresentWait2FeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR), pNext(nullptr), presentWait2() {} + +safe_VkPhysicalDevicePresentWait2FeaturesKHR::safe_VkPhysicalDevicePresentWait2FeaturesKHR( + const safe_VkPhysicalDevicePresentWait2FeaturesKHR& copy_src) { + sType = copy_src.sType; + presentWait2 = copy_src.presentWait2; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePresentWait2FeaturesKHR& safe_VkPhysicalDevicePresentWait2FeaturesKHR::operator=( + const safe_VkPhysicalDevicePresentWait2FeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + presentWait2 = copy_src.presentWait2; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePresentWait2FeaturesKHR::~safe_VkPhysicalDevicePresentWait2FeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePresentWait2FeaturesKHR::initialize(const VkPhysicalDevicePresentWait2FeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + presentWait2 = in_struct->presentWait2; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePresentWait2FeaturesKHR::initialize(const safe_VkPhysicalDevicePresentWait2FeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentWait2 = copy_src->presentWait2; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPresentWait2InfoKHR::safe_VkPresentWait2InfoKHR(const VkPresentWait2InfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), presentId(in_struct->presentId), timeout(in_struct->timeout) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPresentWait2InfoKHR::safe_VkPresentWait2InfoKHR() + : sType(VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR), pNext(nullptr), presentId(), timeout() {} + +safe_VkPresentWait2InfoKHR::safe_VkPresentWait2InfoKHR(const safe_VkPresentWait2InfoKHR& copy_src) { + sType = copy_src.sType; + presentId = copy_src.presentId; + timeout = copy_src.timeout; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPresentWait2InfoKHR& safe_VkPresentWait2InfoKHR::operator=(const safe_VkPresentWait2InfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + presentId = copy_src.presentId; + timeout = copy_src.timeout; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPresentWait2InfoKHR::~safe_VkPresentWait2InfoKHR() { FreePnextChain(pNext); } + +void safe_VkPresentWait2InfoKHR::initialize(const VkPresentWait2InfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + presentId = in_struct->presentId; + timeout = in_struct->timeout; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPresentWait2InfoKHR::initialize(const safe_VkPresentWait2InfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentId = copy_src->presentId; + timeout = copy_src->timeout; + pNext = SafePnextCopy(copy_src->pNext); +} + safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR( const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) @@ -13652,6 +13970,263 @@ void safe_VkVideoEncodeAV1RateControlLayerInfoKHR::initialize(const safe_VkVideo pNext = SafePnextCopy(copy_src->pNext); } +safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR::safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR( + const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), videoDecodeVP9(in_struct->videoDecodeVP9) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR::safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR), pNext(nullptr), videoDecodeVP9() {} + +safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR::safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR( + const safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR& copy_src) { + sType = copy_src.sType; + videoDecodeVP9 = copy_src.videoDecodeVP9; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR& safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR::operator=( + const safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + videoDecodeVP9 = copy_src.videoDecodeVP9; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR::~safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR::initialize(const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + videoDecodeVP9 = in_struct->videoDecodeVP9; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR::initialize(const safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + videoDecodeVP9 = copy_src->videoDecodeVP9; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoDecodeVP9ProfileInfoKHR::safe_VkVideoDecodeVP9ProfileInfoKHR(const VkVideoDecodeVP9ProfileInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), stdProfile(in_struct->stdProfile) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoDecodeVP9ProfileInfoKHR::safe_VkVideoDecodeVP9ProfileInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR), pNext(nullptr), stdProfile() {} + +safe_VkVideoDecodeVP9ProfileInfoKHR::safe_VkVideoDecodeVP9ProfileInfoKHR(const safe_VkVideoDecodeVP9ProfileInfoKHR& copy_src) { + sType = copy_src.sType; + stdProfile = copy_src.stdProfile; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoDecodeVP9ProfileInfoKHR& safe_VkVideoDecodeVP9ProfileInfoKHR::operator=( + const safe_VkVideoDecodeVP9ProfileInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + stdProfile = copy_src.stdProfile; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoDecodeVP9ProfileInfoKHR::~safe_VkVideoDecodeVP9ProfileInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoDecodeVP9ProfileInfoKHR::initialize(const VkVideoDecodeVP9ProfileInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + stdProfile = in_struct->stdProfile; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoDecodeVP9ProfileInfoKHR::initialize(const safe_VkVideoDecodeVP9ProfileInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stdProfile = copy_src->stdProfile; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoDecodeVP9CapabilitiesKHR::safe_VkVideoDecodeVP9CapabilitiesKHR(const VkVideoDecodeVP9CapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), maxLevel(in_struct->maxLevel) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoDecodeVP9CapabilitiesKHR::safe_VkVideoDecodeVP9CapabilitiesKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR), pNext(nullptr), maxLevel() {} + +safe_VkVideoDecodeVP9CapabilitiesKHR::safe_VkVideoDecodeVP9CapabilitiesKHR(const safe_VkVideoDecodeVP9CapabilitiesKHR& copy_src) { + sType = copy_src.sType; + maxLevel = copy_src.maxLevel; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoDecodeVP9CapabilitiesKHR& safe_VkVideoDecodeVP9CapabilitiesKHR::operator=( + const safe_VkVideoDecodeVP9CapabilitiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxLevel = copy_src.maxLevel; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoDecodeVP9CapabilitiesKHR::~safe_VkVideoDecodeVP9CapabilitiesKHR() { FreePnextChain(pNext); } + +void safe_VkVideoDecodeVP9CapabilitiesKHR::initialize(const VkVideoDecodeVP9CapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxLevel = in_struct->maxLevel; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoDecodeVP9CapabilitiesKHR::initialize(const safe_VkVideoDecodeVP9CapabilitiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxLevel = copy_src->maxLevel; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoDecodeVP9PictureInfoKHR::safe_VkVideoDecodeVP9PictureInfoKHR(const VkVideoDecodeVP9PictureInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + pStdPictureInfo(nullptr), + uncompressedHeaderOffset(in_struct->uncompressedHeaderOffset), + compressedHeaderOffset(in_struct->compressedHeaderOffset), + tilesOffset(in_struct->tilesOffset) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeVP9PictureInfo(*in_struct->pStdPictureInfo); + } + + for (uint32_t i = 0; i < VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = in_struct->referenceNameSlotIndices[i]; + } +} + +safe_VkVideoDecodeVP9PictureInfoKHR::safe_VkVideoDecodeVP9PictureInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR), + pNext(nullptr), + pStdPictureInfo(nullptr), + uncompressedHeaderOffset(), + compressedHeaderOffset(), + tilesOffset() {} + +safe_VkVideoDecodeVP9PictureInfoKHR::safe_VkVideoDecodeVP9PictureInfoKHR(const safe_VkVideoDecodeVP9PictureInfoKHR& copy_src) { + sType = copy_src.sType; + pStdPictureInfo = nullptr; + uncompressedHeaderOffset = copy_src.uncompressedHeaderOffset; + compressedHeaderOffset = copy_src.compressedHeaderOffset; + tilesOffset = copy_src.tilesOffset; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeVP9PictureInfo(*copy_src.pStdPictureInfo); + } + + for (uint32_t i = 0; i < VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = copy_src.referenceNameSlotIndices[i]; + } +} + +safe_VkVideoDecodeVP9PictureInfoKHR& safe_VkVideoDecodeVP9PictureInfoKHR::operator=( + const safe_VkVideoDecodeVP9PictureInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pStdPictureInfo) delete pStdPictureInfo; + FreePnextChain(pNext); + + sType = copy_src.sType; + pStdPictureInfo = nullptr; + uncompressedHeaderOffset = copy_src.uncompressedHeaderOffset; + compressedHeaderOffset = copy_src.compressedHeaderOffset; + tilesOffset = copy_src.tilesOffset; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeVP9PictureInfo(*copy_src.pStdPictureInfo); + } + + for (uint32_t i = 0; i < VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = copy_src.referenceNameSlotIndices[i]; + } + + return *this; +} + +safe_VkVideoDecodeVP9PictureInfoKHR::~safe_VkVideoDecodeVP9PictureInfoKHR() { + if (pStdPictureInfo) delete pStdPictureInfo; + FreePnextChain(pNext); +} + +void safe_VkVideoDecodeVP9PictureInfoKHR::initialize(const VkVideoDecodeVP9PictureInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdPictureInfo) delete pStdPictureInfo; + FreePnextChain(pNext); + sType = in_struct->sType; + pStdPictureInfo = nullptr; + uncompressedHeaderOffset = in_struct->uncompressedHeaderOffset; + compressedHeaderOffset = in_struct->compressedHeaderOffset; + tilesOffset = in_struct->tilesOffset; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeVP9PictureInfo(*in_struct->pStdPictureInfo); + } + + for (uint32_t i = 0; i < VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = in_struct->referenceNameSlotIndices[i]; + } +} + +void safe_VkVideoDecodeVP9PictureInfoKHR::initialize(const safe_VkVideoDecodeVP9PictureInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pStdPictureInfo = nullptr; + uncompressedHeaderOffset = copy_src->uncompressedHeaderOffset; + compressedHeaderOffset = copy_src->compressedHeaderOffset; + tilesOffset = copy_src->tilesOffset; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeVP9PictureInfo(*copy_src->pStdPictureInfo); + } + + for (uint32_t i = 0; i < VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = copy_src->referenceNameSlotIndices[i]; + } +} + safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR( const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), videoMaintenance1(in_struct->videoMaintenance1) { @@ -13757,6 +14332,65 @@ void safe_VkVideoInlineQueryInfoKHR::initialize(const safe_VkVideoInlineQueryInf pNext = SafePnextCopy(copy_src->pNext); } +safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR::safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR( + const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + unifiedImageLayouts(in_struct->unifiedImageLayouts), + unifiedImageLayoutsVideo(in_struct->unifiedImageLayoutsVideo) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR::safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR), + pNext(nullptr), + unifiedImageLayouts(), + unifiedImageLayoutsVideo() {} + +safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR::safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR( + const safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR& copy_src) { + sType = copy_src.sType; + unifiedImageLayouts = copy_src.unifiedImageLayouts; + unifiedImageLayoutsVideo = copy_src.unifiedImageLayoutsVideo; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR& safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR::operator=( + const safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + unifiedImageLayouts = copy_src.unifiedImageLayouts; + unifiedImageLayoutsVideo = copy_src.unifiedImageLayoutsVideo; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR::~safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR::initialize( + const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + unifiedImageLayouts = in_struct->unifiedImageLayouts; + unifiedImageLayoutsVideo = in_struct->unifiedImageLayoutsVideo; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR::initialize( + const safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + unifiedImageLayouts = copy_src->unifiedImageLayouts; + unifiedImageLayoutsVideo = copy_src->unifiedImageLayoutsVideo; + pNext = SafePnextCopy(copy_src->pNext); +} + safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR(const VkCalibratedTimestampInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), timeDomain(in_struct->timeDomain) { @@ -14835,6 +15469,161 @@ void safe_VkMemoryBarrierAccessFlags3KHR::initialize(const safe_VkMemoryBarrierA pNext = SafePnextCopy(copy_src->pNext); } +safe_VkPhysicalDeviceMaintenance9FeaturesKHR::safe_VkPhysicalDeviceMaintenance9FeaturesKHR( + const VkPhysicalDeviceMaintenance9FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), maintenance9(in_struct->maintenance9) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMaintenance9FeaturesKHR::safe_VkPhysicalDeviceMaintenance9FeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR), pNext(nullptr), maintenance9() {} + +safe_VkPhysicalDeviceMaintenance9FeaturesKHR::safe_VkPhysicalDeviceMaintenance9FeaturesKHR( + const safe_VkPhysicalDeviceMaintenance9FeaturesKHR& copy_src) { + sType = copy_src.sType; + maintenance9 = copy_src.maintenance9; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMaintenance9FeaturesKHR& safe_VkPhysicalDeviceMaintenance9FeaturesKHR::operator=( + const safe_VkPhysicalDeviceMaintenance9FeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maintenance9 = copy_src.maintenance9; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMaintenance9FeaturesKHR::~safe_VkPhysicalDeviceMaintenance9FeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMaintenance9FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance9FeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maintenance9 = in_struct->maintenance9; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMaintenance9FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance9FeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maintenance9 = copy_src->maintenance9; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMaintenance9PropertiesKHR::safe_VkPhysicalDeviceMaintenance9PropertiesKHR( + const VkPhysicalDeviceMaintenance9PropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + image2DViewOf3DSparse(in_struct->image2DViewOf3DSparse), + defaultVertexAttributeValue(in_struct->defaultVertexAttributeValue) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMaintenance9PropertiesKHR::safe_VkPhysicalDeviceMaintenance9PropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR), + pNext(nullptr), + image2DViewOf3DSparse(), + defaultVertexAttributeValue() {} + +safe_VkPhysicalDeviceMaintenance9PropertiesKHR::safe_VkPhysicalDeviceMaintenance9PropertiesKHR( + const safe_VkPhysicalDeviceMaintenance9PropertiesKHR& copy_src) { + sType = copy_src.sType; + image2DViewOf3DSparse = copy_src.image2DViewOf3DSparse; + defaultVertexAttributeValue = copy_src.defaultVertexAttributeValue; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMaintenance9PropertiesKHR& safe_VkPhysicalDeviceMaintenance9PropertiesKHR::operator=( + const safe_VkPhysicalDeviceMaintenance9PropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + image2DViewOf3DSparse = copy_src.image2DViewOf3DSparse; + defaultVertexAttributeValue = copy_src.defaultVertexAttributeValue; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMaintenance9PropertiesKHR::~safe_VkPhysicalDeviceMaintenance9PropertiesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMaintenance9PropertiesKHR::initialize(const VkPhysicalDeviceMaintenance9PropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + image2DViewOf3DSparse = in_struct->image2DViewOf3DSparse; + defaultVertexAttributeValue = in_struct->defaultVertexAttributeValue; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMaintenance9PropertiesKHR::initialize(const safe_VkPhysicalDeviceMaintenance9PropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + image2DViewOf3DSparse = copy_src->image2DViewOf3DSparse; + defaultVertexAttributeValue = copy_src->defaultVertexAttributeValue; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkQueueFamilyOwnershipTransferPropertiesKHR::safe_VkQueueFamilyOwnershipTransferPropertiesKHR( + const VkQueueFamilyOwnershipTransferPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), optimalImageTransferToQueueFamilies(in_struct->optimalImageTransferToQueueFamilies) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkQueueFamilyOwnershipTransferPropertiesKHR::safe_VkQueueFamilyOwnershipTransferPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR), + pNext(nullptr), + optimalImageTransferToQueueFamilies() {} + +safe_VkQueueFamilyOwnershipTransferPropertiesKHR::safe_VkQueueFamilyOwnershipTransferPropertiesKHR( + const safe_VkQueueFamilyOwnershipTransferPropertiesKHR& copy_src) { + sType = copy_src.sType; + optimalImageTransferToQueueFamilies = copy_src.optimalImageTransferToQueueFamilies; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkQueueFamilyOwnershipTransferPropertiesKHR& safe_VkQueueFamilyOwnershipTransferPropertiesKHR::operator=( + const safe_VkQueueFamilyOwnershipTransferPropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + optimalImageTransferToQueueFamilies = copy_src.optimalImageTransferToQueueFamilies; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkQueueFamilyOwnershipTransferPropertiesKHR::~safe_VkQueueFamilyOwnershipTransferPropertiesKHR() { FreePnextChain(pNext); } + +void safe_VkQueueFamilyOwnershipTransferPropertiesKHR::initialize(const VkQueueFamilyOwnershipTransferPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + optimalImageTransferToQueueFamilies = in_struct->optimalImageTransferToQueueFamilies; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkQueueFamilyOwnershipTransferPropertiesKHR::initialize(const safe_VkQueueFamilyOwnershipTransferPropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + optimalImageTransferToQueueFamilies = copy_src->optimalImageTransferToQueueFamilies; + pNext = SafePnextCopy(copy_src->pNext); +} + safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR( const VkPhysicalDeviceVideoMaintenance2FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), videoMaintenance2(in_struct->videoMaintenance2) { diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp index 79e058c..9cddc4e 100644 --- a/src/vulkan/vk_safe_struct_utils.cpp +++ b/src/vulkan/vk_safe_struct_utils.cpp @@ -764,6 +764,21 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: safe_pNext = new safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR: + safe_pNext = new safe_VkSurfaceCapabilitiesPresentId2KHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR: + safe_pNext = new safe_VkPresentId2KHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDevicePresentId2FeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR: + safe_pNext = new safe_VkSurfaceCapabilitiesPresentWait2KHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDevicePresentWait2FeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: safe_pNext = new safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -839,12 +854,30 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR: safe_pNext = new safe_VkVideoEncodeAV1RateControlLayerInfoKHR(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR: + safe_pNext = new safe_VkVideoDecodeVP9ProfileInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR: + safe_pNext = new safe_VkVideoDecodeVP9CapabilitiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR: + safe_pNext = new safe_VkVideoDecodeVP9PictureInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: safe_pNext = new safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(reinterpret_cast(pNext), copy_state, false); break; case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: safe_pNext = new safe_VkVideoInlineQueryInfoKHR(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT: + safe_pNext = new safe_VkAttachmentFeedbackLoopInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR: safe_pNext = new safe_VkVideoEncodeQuantizationMapCapabilitiesKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -896,6 +929,15 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR: safe_pNext = new safe_VkMemoryBarrierAccessFlags3KHR(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceMaintenance9FeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: + safe_pNext = new safe_VkPhysicalDeviceMaintenance9PropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR: + safe_pNext = new safe_VkQueueFamilyOwnershipTransferPropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR: safe_pNext = new safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -1784,6 +1826,42 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: safe_pNext = new safe_VkDirectDriverLoadingListLUNARG(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM: + safe_pNext = new safe_VkWriteDescriptorSetTensorARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM: + safe_pNext = new safe_VkTensorFormatPropertiesARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM: + safe_pNext = new safe_VkPhysicalDeviceTensorPropertiesARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM: + safe_pNext = new safe_VkTensorMemoryBarrierARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM: + safe_pNext = new safe_VkTensorDependencyInfoARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: + safe_pNext = new safe_VkPhysicalDeviceTensorFeaturesARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM: + safe_pNext = new safe_VkMemoryDedicatedAllocateInfoTensorARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM: + safe_pNext = new safe_VkExternalMemoryTensorCreateInfoARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: + safe_pNext = new safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM: + safe_pNext = new safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM: + safe_pNext = new safe_VkDescriptorGetTensorInfoARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: + safe_pNext = new safe_VkFrameBoundaryTensorsARM(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: safe_pNext = new safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(reinterpret_cast(pNext), copy_state, false); break; @@ -1986,6 +2064,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: safe_pNext = new safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceShaderFloat8FeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: safe_pNext = new safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(reinterpret_cast(pNext), copy_state, false); break; @@ -2854,6 +2935,21 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: delete reinterpret_cast(header); break; @@ -2929,12 +3025,30 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: delete reinterpret_cast(header); break; case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR: delete reinterpret_cast(header); break; @@ -2986,6 +3100,15 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR: delete reinterpret_cast(header); break; @@ -3874,6 +3997,42 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: delete reinterpret_cast(header); break; @@ -4076,6 +4235,9 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: delete reinterpret_cast(header); break; diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp index 9891ca4..a979a5a 100644 --- a/src/vulkan/vk_safe_struct_vendor.cpp +++ b/src/vulkan/vk_safe_struct_vendor.cpp @@ -12542,6 +12542,1781 @@ void safe_VkDirectDriverLoadingListLUNARG::initialize(const safe_VkDirectDriverL } } +safe_VkTensorDescriptionARM::safe_VkTensorDescriptionARM(const VkTensorDescriptionARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + tiling(in_struct->tiling), + format(in_struct->format), + dimensionCount(in_struct->dimensionCount), + pDimensions(nullptr), + pStrides(nullptr), + usage(in_struct->usage) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pDimensions) { + pDimensions = new int64_t[in_struct->dimensionCount]; + memcpy((void*)pDimensions, (void*)in_struct->pDimensions, sizeof(int64_t) * in_struct->dimensionCount); + } + + if (in_struct->pStrides) { + pStrides = new int64_t[in_struct->dimensionCount]; + memcpy((void*)pStrides, (void*)in_struct->pStrides, sizeof(int64_t) * in_struct->dimensionCount); + } +} + +safe_VkTensorDescriptionARM::safe_VkTensorDescriptionARM() + : sType(VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM), + pNext(nullptr), + tiling(), + format(), + dimensionCount(), + pDimensions(nullptr), + pStrides(nullptr), + usage() {} + +safe_VkTensorDescriptionARM::safe_VkTensorDescriptionARM(const safe_VkTensorDescriptionARM& copy_src) { + sType = copy_src.sType; + tiling = copy_src.tiling; + format = copy_src.format; + dimensionCount = copy_src.dimensionCount; + pDimensions = nullptr; + pStrides = nullptr; + usage = copy_src.usage; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDimensions) { + pDimensions = new int64_t[copy_src.dimensionCount]; + memcpy((void*)pDimensions, (void*)copy_src.pDimensions, sizeof(int64_t) * copy_src.dimensionCount); + } + + if (copy_src.pStrides) { + pStrides = new int64_t[copy_src.dimensionCount]; + memcpy((void*)pStrides, (void*)copy_src.pStrides, sizeof(int64_t) * copy_src.dimensionCount); + } +} + +safe_VkTensorDescriptionARM& safe_VkTensorDescriptionARM::operator=(const safe_VkTensorDescriptionARM& copy_src) { + if (©_src == this) return *this; + + if (pDimensions) delete[] pDimensions; + if (pStrides) delete[] pStrides; + FreePnextChain(pNext); + + sType = copy_src.sType; + tiling = copy_src.tiling; + format = copy_src.format; + dimensionCount = copy_src.dimensionCount; + pDimensions = nullptr; + pStrides = nullptr; + usage = copy_src.usage; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDimensions) { + pDimensions = new int64_t[copy_src.dimensionCount]; + memcpy((void*)pDimensions, (void*)copy_src.pDimensions, sizeof(int64_t) * copy_src.dimensionCount); + } + + if (copy_src.pStrides) { + pStrides = new int64_t[copy_src.dimensionCount]; + memcpy((void*)pStrides, (void*)copy_src.pStrides, sizeof(int64_t) * copy_src.dimensionCount); + } + + return *this; +} + +safe_VkTensorDescriptionARM::~safe_VkTensorDescriptionARM() { + if (pDimensions) delete[] pDimensions; + if (pStrides) delete[] pStrides; + FreePnextChain(pNext); +} + +void safe_VkTensorDescriptionARM::initialize(const VkTensorDescriptionARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pDimensions) delete[] pDimensions; + if (pStrides) delete[] pStrides; + FreePnextChain(pNext); + sType = in_struct->sType; + tiling = in_struct->tiling; + format = in_struct->format; + dimensionCount = in_struct->dimensionCount; + pDimensions = nullptr; + pStrides = nullptr; + usage = in_struct->usage; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pDimensions) { + pDimensions = new int64_t[in_struct->dimensionCount]; + memcpy((void*)pDimensions, (void*)in_struct->pDimensions, sizeof(int64_t) * in_struct->dimensionCount); + } + + if (in_struct->pStrides) { + pStrides = new int64_t[in_struct->dimensionCount]; + memcpy((void*)pStrides, (void*)in_struct->pStrides, sizeof(int64_t) * in_struct->dimensionCount); + } +} + +void safe_VkTensorDescriptionARM::initialize(const safe_VkTensorDescriptionARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + tiling = copy_src->tiling; + format = copy_src->format; + dimensionCount = copy_src->dimensionCount; + pDimensions = nullptr; + pStrides = nullptr; + usage = copy_src->usage; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pDimensions) { + pDimensions = new int64_t[copy_src->dimensionCount]; + memcpy((void*)pDimensions, (void*)copy_src->pDimensions, sizeof(int64_t) * copy_src->dimensionCount); + } + + if (copy_src->pStrides) { + pStrides = new int64_t[copy_src->dimensionCount]; + memcpy((void*)pStrides, (void*)copy_src->pStrides, sizeof(int64_t) * copy_src->dimensionCount); + } +} + +safe_VkTensorCreateInfoARM::safe_VkTensorCreateInfoARM(const VkTensorCreateInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + pDescription(nullptr), + sharingMode(in_struct->sharingMode), + queueFamilyIndexCount(0), + pQueueFamilyIndices(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pDescription) pDescription = new safe_VkTensorDescriptionARM(in_struct->pDescription); + + if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices, + sizeof(uint32_t) * in_struct->queueFamilyIndexCount); + queueFamilyIndexCount = in_struct->queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +safe_VkTensorCreateInfoARM::safe_VkTensorCreateInfoARM() + : sType(VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM), + pNext(nullptr), + flags(), + pDescription(nullptr), + sharingMode(), + queueFamilyIndexCount(), + pQueueFamilyIndices(nullptr) {} + +safe_VkTensorCreateInfoARM::safe_VkTensorCreateInfoARM(const safe_VkTensorCreateInfoARM& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pDescription = nullptr; + sharingMode = copy_src.sharingMode; + pQueueFamilyIndices = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pDescription) pDescription = new safe_VkTensorDescriptionARM(*copy_src.pDescription); + + if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount); + queueFamilyIndexCount = copy_src.queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +safe_VkTensorCreateInfoARM& safe_VkTensorCreateInfoARM::operator=(const safe_VkTensorCreateInfoARM& copy_src) { + if (©_src == this) return *this; + + if (pDescription) delete pDescription; + if (pQueueFamilyIndices) delete[] pQueueFamilyIndices; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pDescription = nullptr; + sharingMode = copy_src.sharingMode; + pQueueFamilyIndices = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pDescription) pDescription = new safe_VkTensorDescriptionARM(*copy_src.pDescription); + + if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount); + queueFamilyIndexCount = copy_src.queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } + + return *this; +} + +safe_VkTensorCreateInfoARM::~safe_VkTensorCreateInfoARM() { + if (pDescription) delete pDescription; + if (pQueueFamilyIndices) delete[] pQueueFamilyIndices; + FreePnextChain(pNext); +} + +void safe_VkTensorCreateInfoARM::initialize(const VkTensorCreateInfoARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pDescription) delete pDescription; + if (pQueueFamilyIndices) delete[] pQueueFamilyIndices; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pDescription = nullptr; + sharingMode = in_struct->sharingMode; + pQueueFamilyIndices = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (in_struct->pDescription) pDescription = new safe_VkTensorDescriptionARM(in_struct->pDescription); + + if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices, + sizeof(uint32_t) * in_struct->queueFamilyIndexCount); + queueFamilyIndexCount = in_struct->queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +void safe_VkTensorCreateInfoARM::initialize(const safe_VkTensorCreateInfoARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pDescription = nullptr; + sharingMode = copy_src->sharingMode; + pQueueFamilyIndices = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (copy_src->pDescription) pDescription = new safe_VkTensorDescriptionARM(*copy_src->pDescription); + + if ((copy_src->sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src->pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[copy_src->queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)copy_src->pQueueFamilyIndices, + sizeof(uint32_t) * copy_src->queueFamilyIndexCount); + queueFamilyIndexCount = copy_src->queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +safe_VkTensorViewCreateInfoARM::safe_VkTensorViewCreateInfoARM(const VkTensorViewCreateInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), tensor(in_struct->tensor), format(in_struct->format) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkTensorViewCreateInfoARM::safe_VkTensorViewCreateInfoARM() + : sType(VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM), pNext(nullptr), flags(), tensor(), format() {} + +safe_VkTensorViewCreateInfoARM::safe_VkTensorViewCreateInfoARM(const safe_VkTensorViewCreateInfoARM& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + tensor = copy_src.tensor; + format = copy_src.format; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkTensorViewCreateInfoARM& safe_VkTensorViewCreateInfoARM::operator=(const safe_VkTensorViewCreateInfoARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + tensor = copy_src.tensor; + format = copy_src.format; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkTensorViewCreateInfoARM::~safe_VkTensorViewCreateInfoARM() { FreePnextChain(pNext); } + +void safe_VkTensorViewCreateInfoARM::initialize(const VkTensorViewCreateInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + tensor = in_struct->tensor; + format = in_struct->format; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkTensorViewCreateInfoARM::initialize(const safe_VkTensorViewCreateInfoARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + tensor = copy_src->tensor; + format = copy_src->format; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkTensorMemoryRequirementsInfoARM::safe_VkTensorMemoryRequirementsInfoARM(const VkTensorMemoryRequirementsInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), tensor(in_struct->tensor) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkTensorMemoryRequirementsInfoARM::safe_VkTensorMemoryRequirementsInfoARM() + : sType(VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM), pNext(nullptr), tensor() {} + +safe_VkTensorMemoryRequirementsInfoARM::safe_VkTensorMemoryRequirementsInfoARM( + const safe_VkTensorMemoryRequirementsInfoARM& copy_src) { + sType = copy_src.sType; + tensor = copy_src.tensor; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkTensorMemoryRequirementsInfoARM& safe_VkTensorMemoryRequirementsInfoARM::operator=( + const safe_VkTensorMemoryRequirementsInfoARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + tensor = copy_src.tensor; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkTensorMemoryRequirementsInfoARM::~safe_VkTensorMemoryRequirementsInfoARM() { FreePnextChain(pNext); } + +void safe_VkTensorMemoryRequirementsInfoARM::initialize(const VkTensorMemoryRequirementsInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + tensor = in_struct->tensor; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkTensorMemoryRequirementsInfoARM::initialize(const safe_VkTensorMemoryRequirementsInfoARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + tensor = copy_src->tensor; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBindTensorMemoryInfoARM::safe_VkBindTensorMemoryInfoARM(const VkBindTensorMemoryInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), tensor(in_struct->tensor), memory(in_struct->memory), memoryOffset(in_struct->memoryOffset) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBindTensorMemoryInfoARM::safe_VkBindTensorMemoryInfoARM() + : sType(VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM), pNext(nullptr), tensor(), memory(), memoryOffset() {} + +safe_VkBindTensorMemoryInfoARM::safe_VkBindTensorMemoryInfoARM(const safe_VkBindTensorMemoryInfoARM& copy_src) { + sType = copy_src.sType; + tensor = copy_src.tensor; + memory = copy_src.memory; + memoryOffset = copy_src.memoryOffset; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBindTensorMemoryInfoARM& safe_VkBindTensorMemoryInfoARM::operator=(const safe_VkBindTensorMemoryInfoARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + tensor = copy_src.tensor; + memory = copy_src.memory; + memoryOffset = copy_src.memoryOffset; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBindTensorMemoryInfoARM::~safe_VkBindTensorMemoryInfoARM() { FreePnextChain(pNext); } + +void safe_VkBindTensorMemoryInfoARM::initialize(const VkBindTensorMemoryInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + tensor = in_struct->tensor; + memory = in_struct->memory; + memoryOffset = in_struct->memoryOffset; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBindTensorMemoryInfoARM::initialize(const safe_VkBindTensorMemoryInfoARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + tensor = copy_src->tensor; + memory = copy_src->memory; + memoryOffset = copy_src->memoryOffset; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkWriteDescriptorSetTensorARM::safe_VkWriteDescriptorSetTensorARM(const VkWriteDescriptorSetTensorARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), tensorViewCount(in_struct->tensorViewCount), pTensorViews(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (tensorViewCount && in_struct->pTensorViews) { + pTensorViews = new VkTensorViewARM[tensorViewCount]; + for (uint32_t i = 0; i < tensorViewCount; ++i) { + pTensorViews[i] = in_struct->pTensorViews[i]; + } + } +} + +safe_VkWriteDescriptorSetTensorARM::safe_VkWriteDescriptorSetTensorARM() + : sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM), pNext(nullptr), tensorViewCount(), pTensorViews(nullptr) {} + +safe_VkWriteDescriptorSetTensorARM::safe_VkWriteDescriptorSetTensorARM(const safe_VkWriteDescriptorSetTensorARM& copy_src) { + sType = copy_src.sType; + tensorViewCount = copy_src.tensorViewCount; + pTensorViews = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (tensorViewCount && copy_src.pTensorViews) { + pTensorViews = new VkTensorViewARM[tensorViewCount]; + for (uint32_t i = 0; i < tensorViewCount; ++i) { + pTensorViews[i] = copy_src.pTensorViews[i]; + } + } +} + +safe_VkWriteDescriptorSetTensorARM& safe_VkWriteDescriptorSetTensorARM::operator=( + const safe_VkWriteDescriptorSetTensorARM& copy_src) { + if (©_src == this) return *this; + + if (pTensorViews) delete[] pTensorViews; + FreePnextChain(pNext); + + sType = copy_src.sType; + tensorViewCount = copy_src.tensorViewCount; + pTensorViews = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (tensorViewCount && copy_src.pTensorViews) { + pTensorViews = new VkTensorViewARM[tensorViewCount]; + for (uint32_t i = 0; i < tensorViewCount; ++i) { + pTensorViews[i] = copy_src.pTensorViews[i]; + } + } + + return *this; +} + +safe_VkWriteDescriptorSetTensorARM::~safe_VkWriteDescriptorSetTensorARM() { + if (pTensorViews) delete[] pTensorViews; + FreePnextChain(pNext); +} + +void safe_VkWriteDescriptorSetTensorARM::initialize(const VkWriteDescriptorSetTensorARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pTensorViews) delete[] pTensorViews; + FreePnextChain(pNext); + sType = in_struct->sType; + tensorViewCount = in_struct->tensorViewCount; + pTensorViews = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (tensorViewCount && in_struct->pTensorViews) { + pTensorViews = new VkTensorViewARM[tensorViewCount]; + for (uint32_t i = 0; i < tensorViewCount; ++i) { + pTensorViews[i] = in_struct->pTensorViews[i]; + } + } +} + +void safe_VkWriteDescriptorSetTensorARM::initialize(const safe_VkWriteDescriptorSetTensorARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + tensorViewCount = copy_src->tensorViewCount; + pTensorViews = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (tensorViewCount && copy_src->pTensorViews) { + pTensorViews = new VkTensorViewARM[tensorViewCount]; + for (uint32_t i = 0; i < tensorViewCount; ++i) { + pTensorViews[i] = copy_src->pTensorViews[i]; + } + } +} + +safe_VkTensorFormatPropertiesARM::safe_VkTensorFormatPropertiesARM(const VkTensorFormatPropertiesARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + optimalTilingTensorFeatures(in_struct->optimalTilingTensorFeatures), + linearTilingTensorFeatures(in_struct->linearTilingTensorFeatures) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkTensorFormatPropertiesARM::safe_VkTensorFormatPropertiesARM() + : sType(VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM), + pNext(nullptr), + optimalTilingTensorFeatures(), + linearTilingTensorFeatures() {} + +safe_VkTensorFormatPropertiesARM::safe_VkTensorFormatPropertiesARM(const safe_VkTensorFormatPropertiesARM& copy_src) { + sType = copy_src.sType; + optimalTilingTensorFeatures = copy_src.optimalTilingTensorFeatures; + linearTilingTensorFeatures = copy_src.linearTilingTensorFeatures; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkTensorFormatPropertiesARM& safe_VkTensorFormatPropertiesARM::operator=(const safe_VkTensorFormatPropertiesARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + optimalTilingTensorFeatures = copy_src.optimalTilingTensorFeatures; + linearTilingTensorFeatures = copy_src.linearTilingTensorFeatures; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkTensorFormatPropertiesARM::~safe_VkTensorFormatPropertiesARM() { FreePnextChain(pNext); } + +void safe_VkTensorFormatPropertiesARM::initialize(const VkTensorFormatPropertiesARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + optimalTilingTensorFeatures = in_struct->optimalTilingTensorFeatures; + linearTilingTensorFeatures = in_struct->linearTilingTensorFeatures; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkTensorFormatPropertiesARM::initialize(const safe_VkTensorFormatPropertiesARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + optimalTilingTensorFeatures = copy_src->optimalTilingTensorFeatures; + linearTilingTensorFeatures = copy_src->linearTilingTensorFeatures; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceTensorPropertiesARM::safe_VkPhysicalDeviceTensorPropertiesARM( + const VkPhysicalDeviceTensorPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + maxTensorDimensionCount(in_struct->maxTensorDimensionCount), + maxTensorElements(in_struct->maxTensorElements), + maxPerDimensionTensorElements(in_struct->maxPerDimensionTensorElements), + maxTensorStride(in_struct->maxTensorStride), + maxTensorSize(in_struct->maxTensorSize), + maxTensorShaderAccessArrayLength(in_struct->maxTensorShaderAccessArrayLength), + maxTensorShaderAccessSize(in_struct->maxTensorShaderAccessSize), + maxDescriptorSetStorageTensors(in_struct->maxDescriptorSetStorageTensors), + maxPerStageDescriptorSetStorageTensors(in_struct->maxPerStageDescriptorSetStorageTensors), + maxDescriptorSetUpdateAfterBindStorageTensors(in_struct->maxDescriptorSetUpdateAfterBindStorageTensors), + maxPerStageDescriptorUpdateAfterBindStorageTensors(in_struct->maxPerStageDescriptorUpdateAfterBindStorageTensors), + shaderStorageTensorArrayNonUniformIndexingNative(in_struct->shaderStorageTensorArrayNonUniformIndexingNative), + shaderTensorSupportedStages(in_struct->shaderTensorSupportedStages) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceTensorPropertiesARM::safe_VkPhysicalDeviceTensorPropertiesARM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM), + pNext(nullptr), + maxTensorDimensionCount(), + maxTensorElements(), + maxPerDimensionTensorElements(), + maxTensorStride(), + maxTensorSize(), + maxTensorShaderAccessArrayLength(), + maxTensorShaderAccessSize(), + maxDescriptorSetStorageTensors(), + maxPerStageDescriptorSetStorageTensors(), + maxDescriptorSetUpdateAfterBindStorageTensors(), + maxPerStageDescriptorUpdateAfterBindStorageTensors(), + shaderStorageTensorArrayNonUniformIndexingNative(), + shaderTensorSupportedStages() {} + +safe_VkPhysicalDeviceTensorPropertiesARM::safe_VkPhysicalDeviceTensorPropertiesARM( + const safe_VkPhysicalDeviceTensorPropertiesARM& copy_src) { + sType = copy_src.sType; + maxTensorDimensionCount = copy_src.maxTensorDimensionCount; + maxTensorElements = copy_src.maxTensorElements; + maxPerDimensionTensorElements = copy_src.maxPerDimensionTensorElements; + maxTensorStride = copy_src.maxTensorStride; + maxTensorSize = copy_src.maxTensorSize; + maxTensorShaderAccessArrayLength = copy_src.maxTensorShaderAccessArrayLength; + maxTensorShaderAccessSize = copy_src.maxTensorShaderAccessSize; + maxDescriptorSetStorageTensors = copy_src.maxDescriptorSetStorageTensors; + maxPerStageDescriptorSetStorageTensors = copy_src.maxPerStageDescriptorSetStorageTensors; + maxDescriptorSetUpdateAfterBindStorageTensors = copy_src.maxDescriptorSetUpdateAfterBindStorageTensors; + maxPerStageDescriptorUpdateAfterBindStorageTensors = copy_src.maxPerStageDescriptorUpdateAfterBindStorageTensors; + shaderStorageTensorArrayNonUniformIndexingNative = copy_src.shaderStorageTensorArrayNonUniformIndexingNative; + shaderTensorSupportedStages = copy_src.shaderTensorSupportedStages; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceTensorPropertiesARM& safe_VkPhysicalDeviceTensorPropertiesARM::operator=( + const safe_VkPhysicalDeviceTensorPropertiesARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxTensorDimensionCount = copy_src.maxTensorDimensionCount; + maxTensorElements = copy_src.maxTensorElements; + maxPerDimensionTensorElements = copy_src.maxPerDimensionTensorElements; + maxTensorStride = copy_src.maxTensorStride; + maxTensorSize = copy_src.maxTensorSize; + maxTensorShaderAccessArrayLength = copy_src.maxTensorShaderAccessArrayLength; + maxTensorShaderAccessSize = copy_src.maxTensorShaderAccessSize; + maxDescriptorSetStorageTensors = copy_src.maxDescriptorSetStorageTensors; + maxPerStageDescriptorSetStorageTensors = copy_src.maxPerStageDescriptorSetStorageTensors; + maxDescriptorSetUpdateAfterBindStorageTensors = copy_src.maxDescriptorSetUpdateAfterBindStorageTensors; + maxPerStageDescriptorUpdateAfterBindStorageTensors = copy_src.maxPerStageDescriptorUpdateAfterBindStorageTensors; + shaderStorageTensorArrayNonUniformIndexingNative = copy_src.shaderStorageTensorArrayNonUniformIndexingNative; + shaderTensorSupportedStages = copy_src.shaderTensorSupportedStages; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceTensorPropertiesARM::~safe_VkPhysicalDeviceTensorPropertiesARM() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceTensorPropertiesARM::initialize(const VkPhysicalDeviceTensorPropertiesARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxTensorDimensionCount = in_struct->maxTensorDimensionCount; + maxTensorElements = in_struct->maxTensorElements; + maxPerDimensionTensorElements = in_struct->maxPerDimensionTensorElements; + maxTensorStride = in_struct->maxTensorStride; + maxTensorSize = in_struct->maxTensorSize; + maxTensorShaderAccessArrayLength = in_struct->maxTensorShaderAccessArrayLength; + maxTensorShaderAccessSize = in_struct->maxTensorShaderAccessSize; + maxDescriptorSetStorageTensors = in_struct->maxDescriptorSetStorageTensors; + maxPerStageDescriptorSetStorageTensors = in_struct->maxPerStageDescriptorSetStorageTensors; + maxDescriptorSetUpdateAfterBindStorageTensors = in_struct->maxDescriptorSetUpdateAfterBindStorageTensors; + maxPerStageDescriptorUpdateAfterBindStorageTensors = in_struct->maxPerStageDescriptorUpdateAfterBindStorageTensors; + shaderStorageTensorArrayNonUniformIndexingNative = in_struct->shaderStorageTensorArrayNonUniformIndexingNative; + shaderTensorSupportedStages = in_struct->shaderTensorSupportedStages; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceTensorPropertiesARM::initialize(const safe_VkPhysicalDeviceTensorPropertiesARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxTensorDimensionCount = copy_src->maxTensorDimensionCount; + maxTensorElements = copy_src->maxTensorElements; + maxPerDimensionTensorElements = copy_src->maxPerDimensionTensorElements; + maxTensorStride = copy_src->maxTensorStride; + maxTensorSize = copy_src->maxTensorSize; + maxTensorShaderAccessArrayLength = copy_src->maxTensorShaderAccessArrayLength; + maxTensorShaderAccessSize = copy_src->maxTensorShaderAccessSize; + maxDescriptorSetStorageTensors = copy_src->maxDescriptorSetStorageTensors; + maxPerStageDescriptorSetStorageTensors = copy_src->maxPerStageDescriptorSetStorageTensors; + maxDescriptorSetUpdateAfterBindStorageTensors = copy_src->maxDescriptorSetUpdateAfterBindStorageTensors; + maxPerStageDescriptorUpdateAfterBindStorageTensors = copy_src->maxPerStageDescriptorUpdateAfterBindStorageTensors; + shaderStorageTensorArrayNonUniformIndexingNative = copy_src->shaderStorageTensorArrayNonUniformIndexingNative; + shaderTensorSupportedStages = copy_src->shaderTensorSupportedStages; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkTensorMemoryBarrierARM::safe_VkTensorMemoryBarrierARM(const VkTensorMemoryBarrierARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + srcStageMask(in_struct->srcStageMask), + srcAccessMask(in_struct->srcAccessMask), + dstStageMask(in_struct->dstStageMask), + dstAccessMask(in_struct->dstAccessMask), + srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex), + dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex), + tensor(in_struct->tensor) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkTensorMemoryBarrierARM::safe_VkTensorMemoryBarrierARM() + : sType(VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM), + pNext(nullptr), + srcStageMask(), + srcAccessMask(), + dstStageMask(), + dstAccessMask(), + srcQueueFamilyIndex(), + dstQueueFamilyIndex(), + tensor() {} + +safe_VkTensorMemoryBarrierARM::safe_VkTensorMemoryBarrierARM(const safe_VkTensorMemoryBarrierARM& copy_src) { + sType = copy_src.sType; + srcStageMask = copy_src.srcStageMask; + srcAccessMask = copy_src.srcAccessMask; + dstStageMask = copy_src.dstStageMask; + dstAccessMask = copy_src.dstAccessMask; + srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex; + dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex; + tensor = copy_src.tensor; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkTensorMemoryBarrierARM& safe_VkTensorMemoryBarrierARM::operator=(const safe_VkTensorMemoryBarrierARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + srcStageMask = copy_src.srcStageMask; + srcAccessMask = copy_src.srcAccessMask; + dstStageMask = copy_src.dstStageMask; + dstAccessMask = copy_src.dstAccessMask; + srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex; + dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex; + tensor = copy_src.tensor; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkTensorMemoryBarrierARM::~safe_VkTensorMemoryBarrierARM() { FreePnextChain(pNext); } + +void safe_VkTensorMemoryBarrierARM::initialize(const VkTensorMemoryBarrierARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + srcStageMask = in_struct->srcStageMask; + srcAccessMask = in_struct->srcAccessMask; + dstStageMask = in_struct->dstStageMask; + dstAccessMask = in_struct->dstAccessMask; + srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex; + dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex; + tensor = in_struct->tensor; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkTensorMemoryBarrierARM::initialize(const safe_VkTensorMemoryBarrierARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcStageMask = copy_src->srcStageMask; + srcAccessMask = copy_src->srcAccessMask; + dstStageMask = copy_src->dstStageMask; + dstAccessMask = copy_src->dstAccessMask; + srcQueueFamilyIndex = copy_src->srcQueueFamilyIndex; + dstQueueFamilyIndex = copy_src->dstQueueFamilyIndex; + tensor = copy_src->tensor; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkTensorDependencyInfoARM::safe_VkTensorDependencyInfoARM(const VkTensorDependencyInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), tensorMemoryBarrierCount(in_struct->tensorMemoryBarrierCount), pTensorMemoryBarriers(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pTensorMemoryBarriers) + pTensorMemoryBarriers = new safe_VkTensorMemoryBarrierARM(in_struct->pTensorMemoryBarriers); +} + +safe_VkTensorDependencyInfoARM::safe_VkTensorDependencyInfoARM() + : sType(VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM), + pNext(nullptr), + tensorMemoryBarrierCount(), + pTensorMemoryBarriers(nullptr) {} + +safe_VkTensorDependencyInfoARM::safe_VkTensorDependencyInfoARM(const safe_VkTensorDependencyInfoARM& copy_src) { + sType = copy_src.sType; + tensorMemoryBarrierCount = copy_src.tensorMemoryBarrierCount; + pTensorMemoryBarriers = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pTensorMemoryBarriers) pTensorMemoryBarriers = new safe_VkTensorMemoryBarrierARM(*copy_src.pTensorMemoryBarriers); +} + +safe_VkTensorDependencyInfoARM& safe_VkTensorDependencyInfoARM::operator=(const safe_VkTensorDependencyInfoARM& copy_src) { + if (©_src == this) return *this; + + if (pTensorMemoryBarriers) delete pTensorMemoryBarriers; + FreePnextChain(pNext); + + sType = copy_src.sType; + tensorMemoryBarrierCount = copy_src.tensorMemoryBarrierCount; + pTensorMemoryBarriers = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pTensorMemoryBarriers) pTensorMemoryBarriers = new safe_VkTensorMemoryBarrierARM(*copy_src.pTensorMemoryBarriers); + + return *this; +} + +safe_VkTensorDependencyInfoARM::~safe_VkTensorDependencyInfoARM() { + if (pTensorMemoryBarriers) delete pTensorMemoryBarriers; + FreePnextChain(pNext); +} + +void safe_VkTensorDependencyInfoARM::initialize(const VkTensorDependencyInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pTensorMemoryBarriers) delete pTensorMemoryBarriers; + FreePnextChain(pNext); + sType = in_struct->sType; + tensorMemoryBarrierCount = in_struct->tensorMemoryBarrierCount; + pTensorMemoryBarriers = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (in_struct->pTensorMemoryBarriers) + pTensorMemoryBarriers = new safe_VkTensorMemoryBarrierARM(in_struct->pTensorMemoryBarriers); +} + +void safe_VkTensorDependencyInfoARM::initialize(const safe_VkTensorDependencyInfoARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + tensorMemoryBarrierCount = copy_src->tensorMemoryBarrierCount; + pTensorMemoryBarriers = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (copy_src->pTensorMemoryBarriers) + pTensorMemoryBarriers = new safe_VkTensorMemoryBarrierARM(*copy_src->pTensorMemoryBarriers); +} + +safe_VkPhysicalDeviceTensorFeaturesARM::safe_VkPhysicalDeviceTensorFeaturesARM(const VkPhysicalDeviceTensorFeaturesARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + tensorNonPacked(in_struct->tensorNonPacked), + shaderTensorAccess(in_struct->shaderTensorAccess), + shaderStorageTensorArrayDynamicIndexing(in_struct->shaderStorageTensorArrayDynamicIndexing), + shaderStorageTensorArrayNonUniformIndexing(in_struct->shaderStorageTensorArrayNonUniformIndexing), + descriptorBindingStorageTensorUpdateAfterBind(in_struct->descriptorBindingStorageTensorUpdateAfterBind), + tensors(in_struct->tensors) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceTensorFeaturesARM::safe_VkPhysicalDeviceTensorFeaturesARM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM), + pNext(nullptr), + tensorNonPacked(), + shaderTensorAccess(), + shaderStorageTensorArrayDynamicIndexing(), + shaderStorageTensorArrayNonUniformIndexing(), + descriptorBindingStorageTensorUpdateAfterBind(), + tensors() {} + +safe_VkPhysicalDeviceTensorFeaturesARM::safe_VkPhysicalDeviceTensorFeaturesARM( + const safe_VkPhysicalDeviceTensorFeaturesARM& copy_src) { + sType = copy_src.sType; + tensorNonPacked = copy_src.tensorNonPacked; + shaderTensorAccess = copy_src.shaderTensorAccess; + shaderStorageTensorArrayDynamicIndexing = copy_src.shaderStorageTensorArrayDynamicIndexing; + shaderStorageTensorArrayNonUniformIndexing = copy_src.shaderStorageTensorArrayNonUniformIndexing; + descriptorBindingStorageTensorUpdateAfterBind = copy_src.descriptorBindingStorageTensorUpdateAfterBind; + tensors = copy_src.tensors; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceTensorFeaturesARM& safe_VkPhysicalDeviceTensorFeaturesARM::operator=( + const safe_VkPhysicalDeviceTensorFeaturesARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + tensorNonPacked = copy_src.tensorNonPacked; + shaderTensorAccess = copy_src.shaderTensorAccess; + shaderStorageTensorArrayDynamicIndexing = copy_src.shaderStorageTensorArrayDynamicIndexing; + shaderStorageTensorArrayNonUniformIndexing = copy_src.shaderStorageTensorArrayNonUniformIndexing; + descriptorBindingStorageTensorUpdateAfterBind = copy_src.descriptorBindingStorageTensorUpdateAfterBind; + tensors = copy_src.tensors; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceTensorFeaturesARM::~safe_VkPhysicalDeviceTensorFeaturesARM() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceTensorFeaturesARM::initialize(const VkPhysicalDeviceTensorFeaturesARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + tensorNonPacked = in_struct->tensorNonPacked; + shaderTensorAccess = in_struct->shaderTensorAccess; + shaderStorageTensorArrayDynamicIndexing = in_struct->shaderStorageTensorArrayDynamicIndexing; + shaderStorageTensorArrayNonUniformIndexing = in_struct->shaderStorageTensorArrayNonUniformIndexing; + descriptorBindingStorageTensorUpdateAfterBind = in_struct->descriptorBindingStorageTensorUpdateAfterBind; + tensors = in_struct->tensors; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceTensorFeaturesARM::initialize(const safe_VkPhysicalDeviceTensorFeaturesARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + tensorNonPacked = copy_src->tensorNonPacked; + shaderTensorAccess = copy_src->shaderTensorAccess; + shaderStorageTensorArrayDynamicIndexing = copy_src->shaderStorageTensorArrayDynamicIndexing; + shaderStorageTensorArrayNonUniformIndexing = copy_src->shaderStorageTensorArrayNonUniformIndexing; + descriptorBindingStorageTensorUpdateAfterBind = copy_src->descriptorBindingStorageTensorUpdateAfterBind; + tensors = copy_src->tensors; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDeviceTensorMemoryRequirementsARM::safe_VkDeviceTensorMemoryRequirementsARM( + const VkDeviceTensorMemoryRequirementsARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pCreateInfo(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pCreateInfo) pCreateInfo = new safe_VkTensorCreateInfoARM(in_struct->pCreateInfo); +} + +safe_VkDeviceTensorMemoryRequirementsARM::safe_VkDeviceTensorMemoryRequirementsARM() + : sType(VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM), pNext(nullptr), pCreateInfo(nullptr) {} + +safe_VkDeviceTensorMemoryRequirementsARM::safe_VkDeviceTensorMemoryRequirementsARM( + const safe_VkDeviceTensorMemoryRequirementsARM& copy_src) { + sType = copy_src.sType; + pCreateInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pCreateInfo) pCreateInfo = new safe_VkTensorCreateInfoARM(*copy_src.pCreateInfo); +} + +safe_VkDeviceTensorMemoryRequirementsARM& safe_VkDeviceTensorMemoryRequirementsARM::operator=( + const safe_VkDeviceTensorMemoryRequirementsARM& copy_src) { + if (©_src == this) return *this; + + if (pCreateInfo) delete pCreateInfo; + FreePnextChain(pNext); + + sType = copy_src.sType; + pCreateInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pCreateInfo) pCreateInfo = new safe_VkTensorCreateInfoARM(*copy_src.pCreateInfo); + + return *this; +} + +safe_VkDeviceTensorMemoryRequirementsARM::~safe_VkDeviceTensorMemoryRequirementsARM() { + if (pCreateInfo) delete pCreateInfo; + FreePnextChain(pNext); +} + +void safe_VkDeviceTensorMemoryRequirementsARM::initialize(const VkDeviceTensorMemoryRequirementsARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pCreateInfo) delete pCreateInfo; + FreePnextChain(pNext); + sType = in_struct->sType; + pCreateInfo = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (in_struct->pCreateInfo) pCreateInfo = new safe_VkTensorCreateInfoARM(in_struct->pCreateInfo); +} + +void safe_VkDeviceTensorMemoryRequirementsARM::initialize(const safe_VkDeviceTensorMemoryRequirementsARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pCreateInfo = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (copy_src->pCreateInfo) pCreateInfo = new safe_VkTensorCreateInfoARM(*copy_src->pCreateInfo); +} + +safe_VkTensorCopyARM::safe_VkTensorCopyARM(const VkTensorCopyARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + dimensionCount(in_struct->dimensionCount), + pSrcOffset(nullptr), + pDstOffset(nullptr), + pExtent(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pSrcOffset) { + pSrcOffset = new uint64_t[in_struct->dimensionCount]; + memcpy((void*)pSrcOffset, (void*)in_struct->pSrcOffset, sizeof(uint64_t) * in_struct->dimensionCount); + } + + if (in_struct->pDstOffset) { + pDstOffset = new uint64_t[in_struct->dimensionCount]; + memcpy((void*)pDstOffset, (void*)in_struct->pDstOffset, sizeof(uint64_t) * in_struct->dimensionCount); + } + + if (in_struct->pExtent) { + pExtent = new uint64_t[in_struct->dimensionCount]; + memcpy((void*)pExtent, (void*)in_struct->pExtent, sizeof(uint64_t) * in_struct->dimensionCount); + } +} + +safe_VkTensorCopyARM::safe_VkTensorCopyARM() + : sType(VK_STRUCTURE_TYPE_TENSOR_COPY_ARM), + pNext(nullptr), + dimensionCount(), + pSrcOffset(nullptr), + pDstOffset(nullptr), + pExtent(nullptr) {} + +safe_VkTensorCopyARM::safe_VkTensorCopyARM(const safe_VkTensorCopyARM& copy_src) { + sType = copy_src.sType; + dimensionCount = copy_src.dimensionCount; + pSrcOffset = nullptr; + pDstOffset = nullptr; + pExtent = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pSrcOffset) { + pSrcOffset = new uint64_t[copy_src.dimensionCount]; + memcpy((void*)pSrcOffset, (void*)copy_src.pSrcOffset, sizeof(uint64_t) * copy_src.dimensionCount); + } + + if (copy_src.pDstOffset) { + pDstOffset = new uint64_t[copy_src.dimensionCount]; + memcpy((void*)pDstOffset, (void*)copy_src.pDstOffset, sizeof(uint64_t) * copy_src.dimensionCount); + } + + if (copy_src.pExtent) { + pExtent = new uint64_t[copy_src.dimensionCount]; + memcpy((void*)pExtent, (void*)copy_src.pExtent, sizeof(uint64_t) * copy_src.dimensionCount); + } +} + +safe_VkTensorCopyARM& safe_VkTensorCopyARM::operator=(const safe_VkTensorCopyARM& copy_src) { + if (©_src == this) return *this; + + if (pSrcOffset) delete[] pSrcOffset; + if (pDstOffset) delete[] pDstOffset; + if (pExtent) delete[] pExtent; + FreePnextChain(pNext); + + sType = copy_src.sType; + dimensionCount = copy_src.dimensionCount; + pSrcOffset = nullptr; + pDstOffset = nullptr; + pExtent = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pSrcOffset) { + pSrcOffset = new uint64_t[copy_src.dimensionCount]; + memcpy((void*)pSrcOffset, (void*)copy_src.pSrcOffset, sizeof(uint64_t) * copy_src.dimensionCount); + } + + if (copy_src.pDstOffset) { + pDstOffset = new uint64_t[copy_src.dimensionCount]; + memcpy((void*)pDstOffset, (void*)copy_src.pDstOffset, sizeof(uint64_t) * copy_src.dimensionCount); + } + + if (copy_src.pExtent) { + pExtent = new uint64_t[copy_src.dimensionCount]; + memcpy((void*)pExtent, (void*)copy_src.pExtent, sizeof(uint64_t) * copy_src.dimensionCount); + } + + return *this; +} + +safe_VkTensorCopyARM::~safe_VkTensorCopyARM() { + if (pSrcOffset) delete[] pSrcOffset; + if (pDstOffset) delete[] pDstOffset; + if (pExtent) delete[] pExtent; + FreePnextChain(pNext); +} + +void safe_VkTensorCopyARM::initialize(const VkTensorCopyARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pSrcOffset) delete[] pSrcOffset; + if (pDstOffset) delete[] pDstOffset; + if (pExtent) delete[] pExtent; + FreePnextChain(pNext); + sType = in_struct->sType; + dimensionCount = in_struct->dimensionCount; + pSrcOffset = nullptr; + pDstOffset = nullptr; + pExtent = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pSrcOffset) { + pSrcOffset = new uint64_t[in_struct->dimensionCount]; + memcpy((void*)pSrcOffset, (void*)in_struct->pSrcOffset, sizeof(uint64_t) * in_struct->dimensionCount); + } + + if (in_struct->pDstOffset) { + pDstOffset = new uint64_t[in_struct->dimensionCount]; + memcpy((void*)pDstOffset, (void*)in_struct->pDstOffset, sizeof(uint64_t) * in_struct->dimensionCount); + } + + if (in_struct->pExtent) { + pExtent = new uint64_t[in_struct->dimensionCount]; + memcpy((void*)pExtent, (void*)in_struct->pExtent, sizeof(uint64_t) * in_struct->dimensionCount); + } +} + +void safe_VkTensorCopyARM::initialize(const safe_VkTensorCopyARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + dimensionCount = copy_src->dimensionCount; + pSrcOffset = nullptr; + pDstOffset = nullptr; + pExtent = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pSrcOffset) { + pSrcOffset = new uint64_t[copy_src->dimensionCount]; + memcpy((void*)pSrcOffset, (void*)copy_src->pSrcOffset, sizeof(uint64_t) * copy_src->dimensionCount); + } + + if (copy_src->pDstOffset) { + pDstOffset = new uint64_t[copy_src->dimensionCount]; + memcpy((void*)pDstOffset, (void*)copy_src->pDstOffset, sizeof(uint64_t) * copy_src->dimensionCount); + } + + if (copy_src->pExtent) { + pExtent = new uint64_t[copy_src->dimensionCount]; + memcpy((void*)pExtent, (void*)copy_src->pExtent, sizeof(uint64_t) * copy_src->dimensionCount); + } +} + +safe_VkCopyTensorInfoARM::safe_VkCopyTensorInfoARM(const VkCopyTensorInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + srcTensor(in_struct->srcTensor), + dstTensor(in_struct->dstTensor), + regionCount(in_struct->regionCount), + pRegions(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkTensorCopyARM[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +safe_VkCopyTensorInfoARM::safe_VkCopyTensorInfoARM() + : sType(VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM), pNext(nullptr), srcTensor(), dstTensor(), regionCount(), pRegions(nullptr) {} + +safe_VkCopyTensorInfoARM::safe_VkCopyTensorInfoARM(const safe_VkCopyTensorInfoARM& copy_src) { + sType = copy_src.sType; + srcTensor = copy_src.srcTensor; + dstTensor = copy_src.dstTensor; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkTensorCopyARM[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } +} + +safe_VkCopyTensorInfoARM& safe_VkCopyTensorInfoARM::operator=(const safe_VkCopyTensorInfoARM& copy_src) { + if (©_src == this) return *this; + + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + + sType = copy_src.sType; + srcTensor = copy_src.srcTensor; + dstTensor = copy_src.dstTensor; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkTensorCopyARM[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } + + return *this; +} + +safe_VkCopyTensorInfoARM::~safe_VkCopyTensorInfoARM() { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); +} + +void safe_VkCopyTensorInfoARM::initialize(const VkCopyTensorInfoARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + sType = in_struct->sType; + srcTensor = in_struct->srcTensor; + dstTensor = in_struct->dstTensor; + regionCount = in_struct->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkTensorCopyARM[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +void safe_VkCopyTensorInfoARM::initialize(const safe_VkCopyTensorInfoARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcTensor = copy_src->srcTensor; + dstTensor = copy_src->dstTensor; + regionCount = copy_src->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (regionCount && copy_src->pRegions) { + pRegions = new safe_VkTensorCopyARM[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src->pRegions[i]); + } + } +} + +safe_VkMemoryDedicatedAllocateInfoTensorARM::safe_VkMemoryDedicatedAllocateInfoTensorARM( + const VkMemoryDedicatedAllocateInfoTensorARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), tensor(in_struct->tensor) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMemoryDedicatedAllocateInfoTensorARM::safe_VkMemoryDedicatedAllocateInfoTensorARM() + : sType(VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM), pNext(nullptr), tensor() {} + +safe_VkMemoryDedicatedAllocateInfoTensorARM::safe_VkMemoryDedicatedAllocateInfoTensorARM( + const safe_VkMemoryDedicatedAllocateInfoTensorARM& copy_src) { + sType = copy_src.sType; + tensor = copy_src.tensor; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryDedicatedAllocateInfoTensorARM& safe_VkMemoryDedicatedAllocateInfoTensorARM::operator=( + const safe_VkMemoryDedicatedAllocateInfoTensorARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + tensor = copy_src.tensor; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryDedicatedAllocateInfoTensorARM::~safe_VkMemoryDedicatedAllocateInfoTensorARM() { FreePnextChain(pNext); } + +void safe_VkMemoryDedicatedAllocateInfoTensorARM::initialize(const VkMemoryDedicatedAllocateInfoTensorARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + tensor = in_struct->tensor; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryDedicatedAllocateInfoTensorARM::initialize(const safe_VkMemoryDedicatedAllocateInfoTensorARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + tensor = copy_src->tensor; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceExternalTensorInfoARM::safe_VkPhysicalDeviceExternalTensorInfoARM( + const VkPhysicalDeviceExternalTensorInfoARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), pDescription(nullptr), handleType(in_struct->handleType) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pDescription) pDescription = new safe_VkTensorDescriptionARM(in_struct->pDescription); +} + +safe_VkPhysicalDeviceExternalTensorInfoARM::safe_VkPhysicalDeviceExternalTensorInfoARM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM), + pNext(nullptr), + flags(), + pDescription(nullptr), + handleType() {} + +safe_VkPhysicalDeviceExternalTensorInfoARM::safe_VkPhysicalDeviceExternalTensorInfoARM( + const safe_VkPhysicalDeviceExternalTensorInfoARM& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pDescription = nullptr; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pDescription) pDescription = new safe_VkTensorDescriptionARM(*copy_src.pDescription); +} + +safe_VkPhysicalDeviceExternalTensorInfoARM& safe_VkPhysicalDeviceExternalTensorInfoARM::operator=( + const safe_VkPhysicalDeviceExternalTensorInfoARM& copy_src) { + if (©_src == this) return *this; + + if (pDescription) delete pDescription; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pDescription = nullptr; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pDescription) pDescription = new safe_VkTensorDescriptionARM(*copy_src.pDescription); + + return *this; +} + +safe_VkPhysicalDeviceExternalTensorInfoARM::~safe_VkPhysicalDeviceExternalTensorInfoARM() { + if (pDescription) delete pDescription; + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceExternalTensorInfoARM::initialize(const VkPhysicalDeviceExternalTensorInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDescription) delete pDescription; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pDescription = nullptr; + handleType = in_struct->handleType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (in_struct->pDescription) pDescription = new safe_VkTensorDescriptionARM(in_struct->pDescription); +} + +void safe_VkPhysicalDeviceExternalTensorInfoARM::initialize(const safe_VkPhysicalDeviceExternalTensorInfoARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pDescription = nullptr; + handleType = copy_src->handleType; + pNext = SafePnextCopy(copy_src->pNext); + if (copy_src->pDescription) pDescription = new safe_VkTensorDescriptionARM(*copy_src->pDescription); +} + +safe_VkExternalTensorPropertiesARM::safe_VkExternalTensorPropertiesARM(const VkExternalTensorPropertiesARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), externalMemoryProperties(in_struct->externalMemoryProperties) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExternalTensorPropertiesARM::safe_VkExternalTensorPropertiesARM() + : sType(VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM), pNext(nullptr), externalMemoryProperties() {} + +safe_VkExternalTensorPropertiesARM::safe_VkExternalTensorPropertiesARM(const safe_VkExternalTensorPropertiesARM& copy_src) { + sType = copy_src.sType; + externalMemoryProperties = copy_src.externalMemoryProperties; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExternalTensorPropertiesARM& safe_VkExternalTensorPropertiesARM::operator=( + const safe_VkExternalTensorPropertiesARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + externalMemoryProperties = copy_src.externalMemoryProperties; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExternalTensorPropertiesARM::~safe_VkExternalTensorPropertiesARM() { FreePnextChain(pNext); } + +void safe_VkExternalTensorPropertiesARM::initialize(const VkExternalTensorPropertiesARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + externalMemoryProperties = in_struct->externalMemoryProperties; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExternalTensorPropertiesARM::initialize(const safe_VkExternalTensorPropertiesARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + externalMemoryProperties = copy_src->externalMemoryProperties; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExternalMemoryTensorCreateInfoARM::safe_VkExternalMemoryTensorCreateInfoARM( + const VkExternalMemoryTensorCreateInfoARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), handleTypes(in_struct->handleTypes) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExternalMemoryTensorCreateInfoARM::safe_VkExternalMemoryTensorCreateInfoARM() + : sType(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM), pNext(nullptr), handleTypes() {} + +safe_VkExternalMemoryTensorCreateInfoARM::safe_VkExternalMemoryTensorCreateInfoARM( + const safe_VkExternalMemoryTensorCreateInfoARM& copy_src) { + sType = copy_src.sType; + handleTypes = copy_src.handleTypes; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExternalMemoryTensorCreateInfoARM& safe_VkExternalMemoryTensorCreateInfoARM::operator=( + const safe_VkExternalMemoryTensorCreateInfoARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + handleTypes = copy_src.handleTypes; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExternalMemoryTensorCreateInfoARM::~safe_VkExternalMemoryTensorCreateInfoARM() { FreePnextChain(pNext); } + +void safe_VkExternalMemoryTensorCreateInfoARM::initialize(const VkExternalMemoryTensorCreateInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + handleTypes = in_struct->handleTypes; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExternalMemoryTensorCreateInfoARM::initialize(const safe_VkExternalMemoryTensorCreateInfoARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + handleTypes = copy_src->handleTypes; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM::safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM( + const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), descriptorBufferTensorDescriptors(in_struct->descriptorBufferTensorDescriptors) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM::safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM), + pNext(nullptr), + descriptorBufferTensorDescriptors() {} + +safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM::safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM( + const safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM& copy_src) { + sType = copy_src.sType; + descriptorBufferTensorDescriptors = copy_src.descriptorBufferTensorDescriptors; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM& safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM::operator=( + const safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + descriptorBufferTensorDescriptors = copy_src.descriptorBufferTensorDescriptors; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM::~safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM::initialize( + const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + descriptorBufferTensorDescriptors = in_struct->descriptorBufferTensorDescriptors; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM::initialize( + const safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + descriptorBufferTensorDescriptors = copy_src->descriptorBufferTensorDescriptors; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM::safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM( + const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + tensorCaptureReplayDescriptorDataSize(in_struct->tensorCaptureReplayDescriptorDataSize), + tensorViewCaptureReplayDescriptorDataSize(in_struct->tensorViewCaptureReplayDescriptorDataSize), + tensorDescriptorSize(in_struct->tensorDescriptorSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM::safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM), + pNext(nullptr), + tensorCaptureReplayDescriptorDataSize(), + tensorViewCaptureReplayDescriptorDataSize(), + tensorDescriptorSize() {} + +safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM::safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM( + const safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM& copy_src) { + sType = copy_src.sType; + tensorCaptureReplayDescriptorDataSize = copy_src.tensorCaptureReplayDescriptorDataSize; + tensorViewCaptureReplayDescriptorDataSize = copy_src.tensorViewCaptureReplayDescriptorDataSize; + tensorDescriptorSize = copy_src.tensorDescriptorSize; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM& safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM::operator=( + const safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + tensorCaptureReplayDescriptorDataSize = copy_src.tensorCaptureReplayDescriptorDataSize; + tensorViewCaptureReplayDescriptorDataSize = copy_src.tensorViewCaptureReplayDescriptorDataSize; + tensorDescriptorSize = copy_src.tensorDescriptorSize; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM::~safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM::initialize( + const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + tensorCaptureReplayDescriptorDataSize = in_struct->tensorCaptureReplayDescriptorDataSize; + tensorViewCaptureReplayDescriptorDataSize = in_struct->tensorViewCaptureReplayDescriptorDataSize; + tensorDescriptorSize = in_struct->tensorDescriptorSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM::initialize( + const safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + tensorCaptureReplayDescriptorDataSize = copy_src->tensorCaptureReplayDescriptorDataSize; + tensorViewCaptureReplayDescriptorDataSize = copy_src->tensorViewCaptureReplayDescriptorDataSize; + tensorDescriptorSize = copy_src->tensorDescriptorSize; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDescriptorGetTensorInfoARM::safe_VkDescriptorGetTensorInfoARM(const VkDescriptorGetTensorInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), tensorView(in_struct->tensorView) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDescriptorGetTensorInfoARM::safe_VkDescriptorGetTensorInfoARM() + : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM), pNext(nullptr), tensorView() {} + +safe_VkDescriptorGetTensorInfoARM::safe_VkDescriptorGetTensorInfoARM(const safe_VkDescriptorGetTensorInfoARM& copy_src) { + sType = copy_src.sType; + tensorView = copy_src.tensorView; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDescriptorGetTensorInfoARM& safe_VkDescriptorGetTensorInfoARM::operator=(const safe_VkDescriptorGetTensorInfoARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + tensorView = copy_src.tensorView; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDescriptorGetTensorInfoARM::~safe_VkDescriptorGetTensorInfoARM() { FreePnextChain(pNext); } + +void safe_VkDescriptorGetTensorInfoARM::initialize(const VkDescriptorGetTensorInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + tensorView = in_struct->tensorView; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDescriptorGetTensorInfoARM::initialize(const safe_VkDescriptorGetTensorInfoARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + tensorView = copy_src->tensorView; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkTensorCaptureDescriptorDataInfoARM::safe_VkTensorCaptureDescriptorDataInfoARM( + const VkTensorCaptureDescriptorDataInfoARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), tensor(in_struct->tensor) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkTensorCaptureDescriptorDataInfoARM::safe_VkTensorCaptureDescriptorDataInfoARM() + : sType(VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM), pNext(nullptr), tensor() {} + +safe_VkTensorCaptureDescriptorDataInfoARM::safe_VkTensorCaptureDescriptorDataInfoARM( + const safe_VkTensorCaptureDescriptorDataInfoARM& copy_src) { + sType = copy_src.sType; + tensor = copy_src.tensor; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkTensorCaptureDescriptorDataInfoARM& safe_VkTensorCaptureDescriptorDataInfoARM::operator=( + const safe_VkTensorCaptureDescriptorDataInfoARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + tensor = copy_src.tensor; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkTensorCaptureDescriptorDataInfoARM::~safe_VkTensorCaptureDescriptorDataInfoARM() { FreePnextChain(pNext); } + +void safe_VkTensorCaptureDescriptorDataInfoARM::initialize(const VkTensorCaptureDescriptorDataInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + tensor = in_struct->tensor; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkTensorCaptureDescriptorDataInfoARM::initialize(const safe_VkTensorCaptureDescriptorDataInfoARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + tensor = copy_src->tensor; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkTensorViewCaptureDescriptorDataInfoARM::safe_VkTensorViewCaptureDescriptorDataInfoARM( + const VkTensorViewCaptureDescriptorDataInfoARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), tensorView(in_struct->tensorView) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkTensorViewCaptureDescriptorDataInfoARM::safe_VkTensorViewCaptureDescriptorDataInfoARM() + : sType(VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM), pNext(nullptr), tensorView() {} + +safe_VkTensorViewCaptureDescriptorDataInfoARM::safe_VkTensorViewCaptureDescriptorDataInfoARM( + const safe_VkTensorViewCaptureDescriptorDataInfoARM& copy_src) { + sType = copy_src.sType; + tensorView = copy_src.tensorView; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkTensorViewCaptureDescriptorDataInfoARM& safe_VkTensorViewCaptureDescriptorDataInfoARM::operator=( + const safe_VkTensorViewCaptureDescriptorDataInfoARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + tensorView = copy_src.tensorView; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkTensorViewCaptureDescriptorDataInfoARM::~safe_VkTensorViewCaptureDescriptorDataInfoARM() { FreePnextChain(pNext); } + +void safe_VkTensorViewCaptureDescriptorDataInfoARM::initialize(const VkTensorViewCaptureDescriptorDataInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + tensorView = in_struct->tensorView; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkTensorViewCaptureDescriptorDataInfoARM::initialize(const safe_VkTensorViewCaptureDescriptorDataInfoARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + tensorView = copy_src->tensorView; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkFrameBoundaryTensorsARM::safe_VkFrameBoundaryTensorsARM(const VkFrameBoundaryTensorsARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), tensorCount(in_struct->tensorCount), pTensors(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (tensorCount && in_struct->pTensors) { + pTensors = new VkTensorARM[tensorCount]; + for (uint32_t i = 0; i < tensorCount; ++i) { + pTensors[i] = in_struct->pTensors[i]; + } + } +} + +safe_VkFrameBoundaryTensorsARM::safe_VkFrameBoundaryTensorsARM() + : sType(VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM), pNext(nullptr), tensorCount(), pTensors(nullptr) {} + +safe_VkFrameBoundaryTensorsARM::safe_VkFrameBoundaryTensorsARM(const safe_VkFrameBoundaryTensorsARM& copy_src) { + sType = copy_src.sType; + tensorCount = copy_src.tensorCount; + pTensors = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (tensorCount && copy_src.pTensors) { + pTensors = new VkTensorARM[tensorCount]; + for (uint32_t i = 0; i < tensorCount; ++i) { + pTensors[i] = copy_src.pTensors[i]; + } + } +} + +safe_VkFrameBoundaryTensorsARM& safe_VkFrameBoundaryTensorsARM::operator=(const safe_VkFrameBoundaryTensorsARM& copy_src) { + if (©_src == this) return *this; + + if (pTensors) delete[] pTensors; + FreePnextChain(pNext); + + sType = copy_src.sType; + tensorCount = copy_src.tensorCount; + pTensors = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (tensorCount && copy_src.pTensors) { + pTensors = new VkTensorARM[tensorCount]; + for (uint32_t i = 0; i < tensorCount; ++i) { + pTensors[i] = copy_src.pTensors[i]; + } + } + + return *this; +} + +safe_VkFrameBoundaryTensorsARM::~safe_VkFrameBoundaryTensorsARM() { + if (pTensors) delete[] pTensors; + FreePnextChain(pNext); +} + +void safe_VkFrameBoundaryTensorsARM::initialize(const VkFrameBoundaryTensorsARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pTensors) delete[] pTensors; + FreePnextChain(pNext); + sType = in_struct->sType; + tensorCount = in_struct->tensorCount; + pTensors = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (tensorCount && in_struct->pTensors) { + pTensors = new VkTensorARM[tensorCount]; + for (uint32_t i = 0; i < tensorCount; ++i) { + pTensors[i] = in_struct->pTensors[i]; + } + } +} + +void safe_VkFrameBoundaryTensorsARM::initialize(const safe_VkFrameBoundaryTensorsARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + tensorCount = copy_src->tensorCount; + pTensors = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (tensorCount && copy_src->pTensors) { + pTensors = new VkTensorARM[tensorCount]; + for (uint32_t i = 0; i < tensorCount; ++i) { + pTensors[i] = copy_src->pTensors[i]; + } + } +} + safe_VkPhysicalDeviceOpticalFlowFeaturesNV::safe_VkPhysicalDeviceOpticalFlowFeaturesNV( const VkPhysicalDeviceOpticalFlowFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), opticalFlow(in_struct->opticalFlow) {