eden-emu/Vulkan-Utility-Libraries
19
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

build: Update to header 1.4.317
Some checks failed
format / clang-format (push) Has been cancelled
Details
ci / reuse (push) Has been cancelled
Details
ci / generate_source (push) Has been cancelled
Details
ci / windows-arm64 (push) Has been cancelled
Details
ci / build_and_test (Debug, macos-latest) (push) Has been cancelled
Details
ci / build_and_test (Debug, ubuntu-22.04) (push) Has been cancelled
Details
ci / android (armeabi-v7a) (push) Has been cancelled
Details
ci / chromium (push) Has been cancelled
Details
ci / build_and_test (Debug, ubuntu-24.04) (push) Has been cancelled
Details
ci / build_and_test (Debug, windows-latest) (push) Has been cancelled
Details
ci / build_and_test (Release, macos-latest) (push) Has been cancelled
Details
ci / build_and_test (Release, ubuntu-22.04) (push) Has been cancelled
Details
ci / build_and_test (Release, ubuntu-24.04) (push) Has been cancelled
Details
ci / build_and_test (Release, windows-latest) (push) Has been cancelled
Details
ci / android (arm64-v8a) (push) Has been cancelled
Details

Browse source
This commit is contained in:
Mike Schuchardt 2025-06-06 08:37:59 -07:00
parent 03e1445cc7
commit e48ae20a79
10 changed files with 3984 additions and 23 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -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");

26
include/vulkan/utility/vk_format_utils.h
View file

@ -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 {
// <any other value> -> 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;

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

@ -8488,6 +8488,110 @@ struct safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {
return reinterpret_cast<VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const*>(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<VkSurfaceCapabilitiesPresentId2KHR*>(this); }
VkSurfaceCapabilitiesPresentId2KHR const* ptr() const {
return reinterpret_cast<VkSurfaceCapabilitiesPresentId2KHR const*>(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<VkPresentId2KHR*>(this); }
VkPresentId2KHR const* ptr() const { return reinterpret_cast<VkPresentId2KHR const*>(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<VkPhysicalDevicePresentId2FeaturesKHR*>(this); }
VkPhysicalDevicePresentId2FeaturesKHR const* ptr() const {
return reinterpret_cast<VkPhysicalDevicePresentId2FeaturesKHR const*>(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<VkSurfaceCapabilitiesPresentWait2KHR*>(this); }
VkSurfaceCapabilitiesPresentWait2KHR const* ptr() const {
return reinterpret_cast<VkSurfaceCapabilitiesPresentWait2KHR const*>(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<VkPhysicalDevicePresentWait2FeaturesKHR*>(this); }
VkPhysicalDevicePresentWait2FeaturesKHR const* ptr() const {
return reinterpret_cast<VkPhysicalDevicePresentWait2FeaturesKHR const*>(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<VkPresentWait2InfoKHR*>(this); }
VkPresentWait2InfoKHR const* ptr() const { return reinterpret_cast<VkPresentWait2InfoKHR const*>(this); }
};
struct safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR {
VkStructureType sType;
void* pNext{};
@ -9172,6 +9276,76 @@ struct safe_VkVideoEncodeAV1RateControlLayerInfoKHR {
return reinterpret_cast<VkVideoEncodeAV1RateControlLayerInfoKHR const*>(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<VkPhysicalDeviceVideoDecodeVP9FeaturesKHR*>(this); }
VkPhysicalDeviceVideoDecodeVP9FeaturesKHR const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceVideoDecodeVP9FeaturesKHR const*>(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<VkVideoDecodeVP9ProfileInfoKHR*>(this); }
VkVideoDecodeVP9ProfileInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeVP9ProfileInfoKHR const*>(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<VkVideoDecodeVP9CapabilitiesKHR*>(this); }
VkVideoDecodeVP9CapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeVP9CapabilitiesKHR const*>(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<VkVideoDecodeVP9PictureInfoKHR*>(this); }
VkVideoDecodeVP9PictureInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeVP9PictureInfoKHR const*>(this); }
};
struct safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR {
VkStructureType sType;
void* pNext{};
@ -9210,6 +9384,44 @@ struct safe_VkVideoInlineQueryInfoKHR {
VkVideoInlineQueryInfoKHR* ptr() { return reinterpret_cast<VkVideoInlineQueryInfoKHR*>(this); }
VkVideoInlineQueryInfoKHR const* ptr() const { return reinterpret_cast<VkVideoInlineQueryInfoKHR const*>(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<VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR*>(this);
}
VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR const*>(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<VkAttachmentFeedbackLoopInfoEXT*>(this); }
VkAttachmentFeedbackLoopInfoEXT const* ptr() const { return reinterpret_cast<VkAttachmentFeedbackLoopInfoEXT const*>(this); }
};
struct safe_VkCalibratedTimestampInfoKHR {
VkStructureType sType;
const void* pNext{};
@ -9648,6 +9860,63 @@ struct safe_VkMemoryBarrierAccessFlags3KHR {
VkMemoryBarrierAccessFlags3KHR* ptr() { return reinterpret_cast<VkMemoryBarrierAccessFlags3KHR*>(this); }
VkMemoryBarrierAccessFlags3KHR const* ptr() const { return reinterpret_cast<VkMemoryBarrierAccessFlags3KHR const*>(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<VkPhysicalDeviceMaintenance9FeaturesKHR*>(this); }
VkPhysicalDeviceMaintenance9FeaturesKHR const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceMaintenance9FeaturesKHR const*>(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<VkPhysicalDeviceMaintenance9PropertiesKHR*>(this); }
VkPhysicalDeviceMaintenance9PropertiesKHR const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceMaintenance9PropertiesKHR const*>(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<VkQueueFamilyOwnershipTransferPropertiesKHR*>(this);
}
VkQueueFamilyOwnershipTransferPropertiesKHR const* ptr() const {
return reinterpret_cast<VkQueueFamilyOwnershipTransferPropertiesKHR const*>(this);
}
};
struct safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR {
VkStructureType sType;
void* pNext{};
@ -17841,6 +18110,465 @@ struct safe_VkDirectDriverLoadingListLUNARG {
VkDirectDriverLoadingListLUNARG* ptr() { return reinterpret_cast<VkDirectDriverLoadingListLUNARG*>(this); }
VkDirectDriverLoadingListLUNARG const* ptr() const { return reinterpret_cast<VkDirectDriverLoadingListLUNARG const*>(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<VkTensorDescriptionARM*>(this); }
VkTensorDescriptionARM const* ptr() const { return reinterpret_cast<VkTensorDescriptionARM const*>(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<VkTensorCreateInfoARM*>(this); }
VkTensorCreateInfoARM const* ptr() const { return reinterpret_cast<VkTensorCreateInfoARM const*>(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<VkTensorViewCreateInfoARM*>(this); }
VkTensorViewCreateInfoARM const* ptr() const { return reinterpret_cast<VkTensorViewCreateInfoARM const*>(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<VkTensorMemoryRequirementsInfoARM*>(this); }
VkTensorMemoryRequirementsInfoARM const* ptr() const {
return reinterpret_cast<VkTensorMemoryRequirementsInfoARM const*>(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<VkBindTensorMemoryInfoARM*>(this); }
VkBindTensorMemoryInfoARM const* ptr() const { return reinterpret_cast<VkBindTensorMemoryInfoARM const*>(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<VkWriteDescriptorSetTensorARM*>(this); }
VkWriteDescriptorSetTensorARM const* ptr() const { return reinterpret_cast<VkWriteDescriptorSetTensorARM const*>(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<VkTensorFormatPropertiesARM*>(this); }
VkTensorFormatPropertiesARM const* ptr() const { return reinterpret_cast<VkTensorFormatPropertiesARM const*>(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<VkPhysicalDeviceTensorPropertiesARM*>(this); }
VkPhysicalDeviceTensorPropertiesARM const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceTensorPropertiesARM const*>(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<VkTensorMemoryBarrierARM*>(this); }
VkTensorMemoryBarrierARM const* ptr() const { return reinterpret_cast<VkTensorMemoryBarrierARM const*>(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<VkTensorDependencyInfoARM*>(this); }
VkTensorDependencyInfoARM const* ptr() const { return reinterpret_cast<VkTensorDependencyInfoARM const*>(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<VkPhysicalDeviceTensorFeaturesARM*>(this); }
VkPhysicalDeviceTensorFeaturesARM const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceTensorFeaturesARM const*>(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<VkDeviceTensorMemoryRequirementsARM*>(this); }
VkDeviceTensorMemoryRequirementsARM const* ptr() const {
return reinterpret_cast<VkDeviceTensorMemoryRequirementsARM const*>(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<VkTensorCopyARM*>(this); }
VkTensorCopyARM const* ptr() const { return reinterpret_cast<VkTensorCopyARM const*>(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<VkCopyTensorInfoARM*>(this); }
VkCopyTensorInfoARM const* ptr() const { return reinterpret_cast<VkCopyTensorInfoARM const*>(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<VkMemoryDedicatedAllocateInfoTensorARM*>(this); }
VkMemoryDedicatedAllocateInfoTensorARM const* ptr() const {
return reinterpret_cast<VkMemoryDedicatedAllocateInfoTensorARM const*>(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<VkPhysicalDeviceExternalTensorInfoARM*>(this); }
VkPhysicalDeviceExternalTensorInfoARM const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceExternalTensorInfoARM const*>(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<VkExternalTensorPropertiesARM*>(this); }
VkExternalTensorPropertiesARM const* ptr() const { return reinterpret_cast<VkExternalTensorPropertiesARM const*>(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<VkExternalMemoryTensorCreateInfoARM*>(this); }
VkExternalMemoryTensorCreateInfoARM const* ptr() const {
return reinterpret_cast<VkExternalMemoryTensorCreateInfoARM const*>(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<VkPhysicalDeviceDescriptorBufferTensorFeaturesARM*>(this);
}
VkPhysicalDeviceDescriptorBufferTensorFeaturesARM const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceDescriptorBufferTensorFeaturesARM const*>(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<VkPhysicalDeviceDescriptorBufferTensorPropertiesARM*>(this);
}
VkPhysicalDeviceDescriptorBufferTensorPropertiesARM const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceDescriptorBufferTensorPropertiesARM const*>(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<VkDescriptorGetTensorInfoARM*>(this); }
VkDescriptorGetTensorInfoARM const* ptr() const { return reinterpret_cast<VkDescriptorGetTensorInfoARM const*>(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<VkTensorCaptureDescriptorDataInfoARM*>(this); }
VkTensorCaptureDescriptorDataInfoARM const* ptr() const {
return reinterpret_cast<VkTensorCaptureDescriptorDataInfoARM const*>(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<VkTensorViewCaptureDescriptorDataInfoARM*>(this); }
VkTensorViewCaptureDescriptorDataInfoARM const* ptr() const {
return reinterpret_cast<VkTensorViewCaptureDescriptorDataInfoARM const*>(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<VkFrameBoundaryTensorsARM*>(this); }
VkFrameBoundaryTensorsARM const* ptr() const { return reinterpret_cast<VkFrameBoundaryTensorsARM const*>(this); }
};
struct safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT {
VkStructureType sType;
void* pNext{};
@ -19579,6 +20307,25 @@ struct safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT {
return reinterpret_cast<VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT const*>(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<VkPhysicalDeviceShaderFloat8FeaturesEXT*>(this); }
VkPhysicalDeviceShaderFloat8FeaturesEXT const* ptr() const {
return reinterpret_cast<VkPhysicalDeviceShaderFloat8FeaturesEXT const*>(this);
}
};
struct safe_VkPhysicalDeviceRayTracingValidationFeaturesNV {
VkStructureType sType;
void* pNext{};

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

@ -451,6 +451,12 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderSubgroupUnifor
template <> inline VkStructureType GetSType<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkSurfaceCapabilitiesPresentId2KHR>() { return VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR; }
template <> inline VkStructureType GetSType<VkPresentId2KHR>() { return VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDevicePresentId2FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkSurfaceCapabilitiesPresentWait2KHR>() { return VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDevicePresentWait2FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkPresentWait2InfoKHR>() { return VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineBinaryFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineBinaryPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR; }
@ -483,8 +489,14 @@ template <> inline VkStructureType GetSType<VkVideoEncodeAV1ProfileInfoKHR>() {
template <> inline VkStructureType GetSType<VkVideoEncodeAV1GopRemainingFrameInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR; }
template <> inline VkStructureType GetSType<VkVideoEncodeAV1RateControlInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR; }
template <> inline VkStructureType GetSType<VkVideoEncodeAV1RateControlLayerInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoDecodeVP9FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkVideoDecodeVP9ProfileInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR; }
template <> inline VkStructureType GetSType<VkVideoDecodeVP9CapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR; }
template <> inline VkStructureType GetSType<VkVideoDecodeVP9PictureInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoMaintenance1FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkVideoInlineQueryInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkAttachmentFeedbackLoopInfoEXT>() { return VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT; }
template <> inline VkStructureType GetSType<VkCalibratedTimestampInfoKHR>() { return VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR; }
template <> inline VkStructureType GetSType<VkSetDescriptorBufferOffsetsInfoEXT>() { return VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT; }
template <> inline VkStructureType GetSType<VkBindDescriptorBufferEmbeddedSamplersInfoEXT>() { return VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT; }
@ -506,6 +518,9 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredApiProperties
template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredApiVulkanPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance8FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkMemoryBarrierAccessFlags3KHR>() { return VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance9FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance9PropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR; }
template <> inline VkStructureType GetSType<VkQueueFamilyOwnershipTransferPropertiesKHR>() { return VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoMaintenance2FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR; }
template <> inline VkStructureType GetSType<VkVideoDecodeH264InlineSessionParametersInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR; }
template <> inline VkStructureType GetSType<VkVideoDecodeH265InlineSessionParametersInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR; }
@ -933,6 +948,30 @@ template <> inline VkStructureType GetSType<VkRenderPassCreationFeedbackCreateIn
template <> inline VkStructureType GetSType<VkRenderPassSubpassFeedbackCreateInfoEXT>() { return VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT; }
template <> inline VkStructureType GetSType<VkDirectDriverLoadingInfoLUNARG>() { return VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG; }
template <> inline VkStructureType GetSType<VkDirectDriverLoadingListLUNARG>() { return VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG; }
template <> inline VkStructureType GetSType<VkTensorDescriptionARM>() { return VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM; }
template <> inline VkStructureType GetSType<VkTensorCreateInfoARM>() { return VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM; }
template <> inline VkStructureType GetSType<VkTensorViewCreateInfoARM>() { return VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM; }
template <> inline VkStructureType GetSType<VkTensorMemoryRequirementsInfoARM>() { return VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM; }
template <> inline VkStructureType GetSType<VkBindTensorMemoryInfoARM>() { return VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM; }
template <> inline VkStructureType GetSType<VkWriteDescriptorSetTensorARM>() { return VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM; }
template <> inline VkStructureType GetSType<VkTensorFormatPropertiesARM>() { return VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceTensorPropertiesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM; }
template <> inline VkStructureType GetSType<VkTensorMemoryBarrierARM>() { return VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM; }
template <> inline VkStructureType GetSType<VkTensorDependencyInfoARM>() { return VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceTensorFeaturesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; }
template <> inline VkStructureType GetSType<VkDeviceTensorMemoryRequirementsARM>() { return VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM; }
template <> inline VkStructureType GetSType<VkTensorCopyARM>() { return VK_STRUCTURE_TYPE_TENSOR_COPY_ARM; }
template <> inline VkStructureType GetSType<VkCopyTensorInfoARM>() { return VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM; }
template <> inline VkStructureType GetSType<VkMemoryDedicatedAllocateInfoTensorARM>() { return VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalTensorInfoARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM; }
template <> inline VkStructureType GetSType<VkExternalTensorPropertiesARM>() { return VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM; }
template <> inline VkStructureType GetSType<VkExternalMemoryTensorCreateInfoARM>() { return VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorBufferTensorFeaturesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorBufferTensorPropertiesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM; }
template <> inline VkStructureType GetSType<VkDescriptorGetTensorInfoARM>() { return VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM; }
template <> inline VkStructureType GetSType<VkTensorCaptureDescriptorDataInfoARM>() { return VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM; }
template <> inline VkStructureType GetSType<VkTensorViewCaptureDescriptorDataInfoARM>() { return VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM; }
template <> inline VkStructureType GetSType<VkFrameBoundaryTensorsARM>() { return VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT; }
template <> inline VkStructureType GetSType<VkPipelineShaderStageModuleIdentifierCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT; }
@ -1022,6 +1061,7 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalComputeQueue
template <> inline VkStructureType GetSType<VkPhysicalDeviceCommandBufferInheritanceFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderFloat8FeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingValidationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceClusterAccelerationStructureFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV; }
template <> inline VkStructureType GetSType<VkPhysicalDeviceClusterAccelerationStructurePropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV; }
@ -1224,6 +1264,8 @@ template<> inline VkObjectType GetObjectType<VkAccelerationStructureKHR>() { ret
template<> inline VkObjectType GetObjectType<VkBufferCollectionFUCHSIA>() { return VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA; }
#endif // VK_USE_PLATFORM_FUCHSIA
template<> inline VkObjectType GetObjectType<VkMicromapEXT>() { return VK_OBJECT_TYPE_MICROMAP_EXT; }
template<> inline VkObjectType GetObjectType<VkTensorARM>() { return VK_OBJECT_TYPE_TENSOR_ARM; }
template<> inline VkObjectType GetObjectType<VkTensorViewARM>() { return VK_OBJECT_TYPE_TENSOR_VIEW_ARM; }
template<> inline VkObjectType GetObjectType<VkOpticalFlowSessionNV>() { return VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV; }
template<> inline VkObjectType GetObjectType<VkShaderEXT>() { return VK_OBJECT_TYPE_SHADER_EXT; }
template<> inline VkObjectType GetObjectType<VkExternalComputeQueueNV>() { return VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV; }

335
include/vulkan/vk_enum_string_helper.h
View file

@ -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<VkQueryPoolCreateFlagBits>(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<uint64_t>(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<uint64_t>(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<uint64_t>(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:

2
scripts/known_good.json
View file

@ -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",

105
src/vulkan/vk_safe_struct_ext.cpp
View file

@ -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 (&copy_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 (&copy_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)

789
src/vulkan/vk_safe_struct_khr.cpp
View file

@ -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 (&copy_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 (&copy_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 (&copy_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 (&copy_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 (&copy_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 (&copy_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 (&copy_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 (&copy_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 (&copy_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 (&copy_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 (&copy_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 (&copy_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 (&copy_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 (&copy_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) {

162
src/vulkan/vk_safe_struct_utils.cpp
View file

@ -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<const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR:
safe_pNext = new safe_VkSurfaceCapabilitiesPresentId2KHR(reinterpret_cast<const VkSurfaceCapabilitiesPresentId2KHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR:
safe_pNext = new safe_VkPresentId2KHR(reinterpret_cast<const VkPresentId2KHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDevicePresentId2FeaturesKHR(reinterpret_cast<const VkPhysicalDevicePresentId2FeaturesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR:
safe_pNext = new safe_VkSurfaceCapabilitiesPresentWait2KHR(reinterpret_cast<const VkSurfaceCapabilitiesPresentWait2KHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDevicePresentWait2FeaturesKHR(reinterpret_cast<const VkPhysicalDevicePresentWait2FeaturesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(pNext), copy_state, false);
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<const VkVideoEncodeAV1RateControlLayerInfoKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR:
safe_pNext = new safe_VkVideoDecodeVP9ProfileInfoKHR(reinterpret_cast<const VkVideoDecodeVP9ProfileInfoKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR:
safe_pNext = new safe_VkVideoDecodeVP9CapabilitiesKHR(reinterpret_cast<const VkVideoDecodeVP9CapabilitiesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR:
safe_pNext = new safe_VkVideoDecodeVP9PictureInfoKHR(reinterpret_cast<const VkVideoDecodeVP9PictureInfoKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
safe_pNext = new safe_VkVideoInlineQueryInfoKHR(reinterpret_cast<const VkVideoInlineQueryInfoKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT:
safe_pNext = new safe_VkAttachmentFeedbackLoopInfoEXT(reinterpret_cast<const VkAttachmentFeedbackLoopInfoEXT *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
safe_pNext = new safe_VkVideoEncodeQuantizationMapCapabilitiesKHR(reinterpret_cast<const VkVideoEncodeQuantizationMapCapabilitiesKHR *>(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<const VkMemoryBarrierAccessFlags3KHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceMaintenance9FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceMaintenance9FeaturesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR:
safe_pNext = new safe_VkPhysicalDeviceMaintenance9PropertiesKHR(reinterpret_cast<const VkPhysicalDeviceMaintenance9PropertiesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR:
safe_pNext = new safe_VkQueueFamilyOwnershipTransferPropertiesKHR(reinterpret_cast<const VkQueueFamilyOwnershipTransferPropertiesKHR *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR:
safe_pNext = new safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVideoMaintenance2FeaturesKHR *>(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<const VkDirectDriverLoadingListLUNARG *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM:
safe_pNext = new safe_VkWriteDescriptorSetTensorARM(reinterpret_cast<const VkWriteDescriptorSetTensorARM *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM:
safe_pNext = new safe_VkTensorFormatPropertiesARM(reinterpret_cast<const VkTensorFormatPropertiesARM *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM:
safe_pNext = new safe_VkPhysicalDeviceTensorPropertiesARM(reinterpret_cast<const VkPhysicalDeviceTensorPropertiesARM *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM:
safe_pNext = new safe_VkTensorMemoryBarrierARM(reinterpret_cast<const VkTensorMemoryBarrierARM *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM:
safe_pNext = new safe_VkTensorDependencyInfoARM(reinterpret_cast<const VkTensorDependencyInfoARM *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM:
safe_pNext = new safe_VkPhysicalDeviceTensorFeaturesARM(reinterpret_cast<const VkPhysicalDeviceTensorFeaturesARM *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM:
safe_pNext = new safe_VkMemoryDedicatedAllocateInfoTensorARM(reinterpret_cast<const VkMemoryDedicatedAllocateInfoTensorARM *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM:
safe_pNext = new safe_VkExternalMemoryTensorCreateInfoARM(reinterpret_cast<const VkExternalMemoryTensorCreateInfoARM *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM:
safe_pNext = new safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM(reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM:
safe_pNext = new safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM(reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM:
safe_pNext = new safe_VkDescriptorGetTensorInfoARM(reinterpret_cast<const VkDescriptorGetTensorInfoARM *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM:
safe_pNext = new safe_VkFrameBoundaryTensorsARM(reinterpret_cast<const VkFrameBoundaryTensorsARM *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *>(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<const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT:
safe_pNext = new safe_VkPhysicalDeviceShaderFloat8FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderFloat8FeaturesEXT *>(pNext), copy_state, false);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
safe_pNext = new safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV *>(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<safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR:
delete reinterpret_cast<safe_VkSurfaceCapabilitiesPresentId2KHR *>(header);
break;
case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR:
delete reinterpret_cast<safe_VkPresentId2KHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR:
delete reinterpret_cast<safe_VkPhysicalDevicePresentId2FeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR:
delete reinterpret_cast<safe_VkSurfaceCapabilitiesPresentWait2KHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR:
delete reinterpret_cast<safe_VkPhysicalDevicePresentWait2FeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(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<safe_VkVideoEncodeAV1RateControlLayerInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR:
delete reinterpret_cast<safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR:
delete reinterpret_cast<safe_VkVideoDecodeVP9ProfileInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR:
delete reinterpret_cast<safe_VkVideoDecodeVP9CapabilitiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR:
delete reinterpret_cast<safe_VkVideoDecodeVP9PictureInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
delete reinterpret_cast<safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
delete reinterpret_cast<safe_VkVideoInlineQueryInfoKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR:
delete reinterpret_cast<safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT:
delete reinterpret_cast<safe_VkAttachmentFeedbackLoopInfoEXT *>(header);
break;
case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
delete reinterpret_cast<safe_VkVideoEncodeQuantizationMapCapabilitiesKHR *>(header);
break;
@ -2986,6 +3100,15 @@ void FreePnextChain(const void *pNext) {
case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR:
delete reinterpret_cast<safe_VkMemoryBarrierAccessFlags3KHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR:
delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance9FeaturesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR:
delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance9PropertiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR:
delete reinterpret_cast<safe_VkQueueFamilyOwnershipTransferPropertiesKHR *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR:
delete reinterpret_cast<safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR *>(header);
break;
@ -3874,6 +3997,42 @@ void FreePnextChain(const void *pNext) {
case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG:
delete reinterpret_cast<safe_VkDirectDriverLoadingListLUNARG *>(header);
break;
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM:
delete reinterpret_cast<safe_VkWriteDescriptorSetTensorARM *>(header);
break;
case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM:
delete reinterpret_cast<safe_VkTensorFormatPropertiesARM *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM:
delete reinterpret_cast<safe_VkPhysicalDeviceTensorPropertiesARM *>(header);
break;
case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM:
delete reinterpret_cast<safe_VkTensorMemoryBarrierARM *>(header);
break;
case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM:
delete reinterpret_cast<safe_VkTensorDependencyInfoARM *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM:
delete reinterpret_cast<safe_VkPhysicalDeviceTensorFeaturesARM *>(header);
break;
case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM:
delete reinterpret_cast<safe_VkMemoryDedicatedAllocateInfoTensorARM *>(header);
break;
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM:
delete reinterpret_cast<safe_VkExternalMemoryTensorCreateInfoARM *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM:
delete reinterpret_cast<safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM:
delete reinterpret_cast<safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *>(header);
break;
case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM:
delete reinterpret_cast<safe_VkDescriptorGetTensorInfoARM *>(header);
break;
case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM:
delete reinterpret_cast<safe_VkFrameBoundaryTensorsARM *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
delete reinterpret_cast<safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *>(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<safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT:
delete reinterpret_cast<safe_VkPhysicalDeviceShaderFloat8FeaturesEXT *>(header);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingValidationFeaturesNV *>(header);
break;

1775
src/vulkan/vk_safe_struct_vendor.cpp
View file

File diff suppressed because it is too large Load diff