From ff5c7b748df27562d523ecb39807edeae690d17b Mon Sep 17 00:00:00 2001 From: Mike Schuchardt Date: Thu, 26 Sep 2024 08:03:24 -0700 Subject: [PATCH] build: Update to header 1.3.296 --- include/vulkan/utility/vk_dispatch_table.h | 20 + include/vulkan/utility/vk_safe_struct.hpp | 370 +++++ include/vulkan/utility/vk_struct_helper.hpp | 18 + include/vulkan/vk_enum_string_helper.h | 152 ++ scripts/known_good.json | 2 +- src/vulkan/vk_safe_struct_ext.cpp | 1443 +++++++++++++++++++ src/vulkan/vk_safe_struct_utils.cpp | 36 + 7 files changed, 2040 insertions(+), 1 deletion(-) diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h index 75d7b01..443591e 100644 --- a/include/vulkan/utility/vk_dispatch_table.h +++ b/include/vulkan/utility/vk_dispatch_table.h @@ -726,6 +726,7 @@ typedef struct VkuDeviceDispatchTable_ { PFN_vkDestroyShaderEXT DestroyShaderEXT; PFN_vkGetShaderBinaryDataEXT GetShaderBinaryDataEXT; PFN_vkCmdBindShadersEXT CmdBindShadersEXT; + PFN_vkCmdSetDepthClampRangeEXT CmdSetDepthClampRangeEXT; PFN_vkGetFramebufferTilePropertiesQCOM GetFramebufferTilePropertiesQCOM; PFN_vkGetDynamicRenderingTilePropertiesQCOM GetDynamicRenderingTilePropertiesQCOM; PFN_vkSetLatencySleepModeNV SetLatencySleepModeNV; @@ -737,6 +738,15 @@ typedef struct VkuDeviceDispatchTable_ { #ifdef VK_USE_PLATFORM_SCREEN_QNX PFN_vkGetScreenBufferPropertiesQNX GetScreenBufferPropertiesQNX; #endif // VK_USE_PLATFORM_SCREEN_QNX + PFN_vkGetGeneratedCommandsMemoryRequirementsEXT GetGeneratedCommandsMemoryRequirementsEXT; + PFN_vkCmdPreprocessGeneratedCommandsEXT CmdPreprocessGeneratedCommandsEXT; + PFN_vkCmdExecuteGeneratedCommandsEXT CmdExecuteGeneratedCommandsEXT; + PFN_vkCreateIndirectCommandsLayoutEXT CreateIndirectCommandsLayoutEXT; + PFN_vkDestroyIndirectCommandsLayoutEXT DestroyIndirectCommandsLayoutEXT; + PFN_vkCreateIndirectExecutionSetEXT CreateIndirectExecutionSetEXT; + PFN_vkDestroyIndirectExecutionSetEXT DestroyIndirectExecutionSetEXT; + PFN_vkUpdateIndirectExecutionSetPipelineEXT UpdateIndirectExecutionSetPipelineEXT; + PFN_vkUpdateIndirectExecutionSetShaderEXT UpdateIndirectExecutionSetShaderEXT; PFN_vkCreateAccelerationStructureKHR CreateAccelerationStructureKHR; PFN_vkDestroyAccelerationStructureKHR DestroyAccelerationStructureKHR; PFN_vkCmdBuildAccelerationStructuresKHR CmdBuildAccelerationStructuresKHR; @@ -1328,6 +1338,7 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch table->DestroyShaderEXT = (PFN_vkDestroyShaderEXT)gdpa(device, "vkDestroyShaderEXT"); table->GetShaderBinaryDataEXT = (PFN_vkGetShaderBinaryDataEXT)gdpa(device, "vkGetShaderBinaryDataEXT"); table->CmdBindShadersEXT = (PFN_vkCmdBindShadersEXT)gdpa(device, "vkCmdBindShadersEXT"); + table->CmdSetDepthClampRangeEXT = (PFN_vkCmdSetDepthClampRangeEXT)gdpa(device, "vkCmdSetDepthClampRangeEXT"); table->GetFramebufferTilePropertiesQCOM = (PFN_vkGetFramebufferTilePropertiesQCOM)gdpa(device, "vkGetFramebufferTilePropertiesQCOM"); table->GetDynamicRenderingTilePropertiesQCOM = (PFN_vkGetDynamicRenderingTilePropertiesQCOM)gdpa(device, "vkGetDynamicRenderingTilePropertiesQCOM"); table->SetLatencySleepModeNV = (PFN_vkSetLatencySleepModeNV)gdpa(device, "vkSetLatencySleepModeNV"); @@ -1339,6 +1350,15 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch #ifdef VK_USE_PLATFORM_SCREEN_QNX table->GetScreenBufferPropertiesQNX = (PFN_vkGetScreenBufferPropertiesQNX)gdpa(device, "vkGetScreenBufferPropertiesQNX"); #endif // VK_USE_PLATFORM_SCREEN_QNX + table->GetGeneratedCommandsMemoryRequirementsEXT = (PFN_vkGetGeneratedCommandsMemoryRequirementsEXT)gdpa(device, "vkGetGeneratedCommandsMemoryRequirementsEXT"); + table->CmdPreprocessGeneratedCommandsEXT = (PFN_vkCmdPreprocessGeneratedCommandsEXT)gdpa(device, "vkCmdPreprocessGeneratedCommandsEXT"); + table->CmdExecuteGeneratedCommandsEXT = (PFN_vkCmdExecuteGeneratedCommandsEXT)gdpa(device, "vkCmdExecuteGeneratedCommandsEXT"); + table->CreateIndirectCommandsLayoutEXT = (PFN_vkCreateIndirectCommandsLayoutEXT)gdpa(device, "vkCreateIndirectCommandsLayoutEXT"); + table->DestroyIndirectCommandsLayoutEXT = (PFN_vkDestroyIndirectCommandsLayoutEXT)gdpa(device, "vkDestroyIndirectCommandsLayoutEXT"); + table->CreateIndirectExecutionSetEXT = (PFN_vkCreateIndirectExecutionSetEXT)gdpa(device, "vkCreateIndirectExecutionSetEXT"); + table->DestroyIndirectExecutionSetEXT = (PFN_vkDestroyIndirectExecutionSetEXT)gdpa(device, "vkDestroyIndirectExecutionSetEXT"); + table->UpdateIndirectExecutionSetPipelineEXT = (PFN_vkUpdateIndirectExecutionSetPipelineEXT)gdpa(device, "vkUpdateIndirectExecutionSetPipelineEXT"); + table->UpdateIndirectExecutionSetShaderEXT = (PFN_vkUpdateIndirectExecutionSetShaderEXT)gdpa(device, "vkUpdateIndirectExecutionSetShaderEXT"); table->CreateAccelerationStructureKHR = (PFN_vkCreateAccelerationStructureKHR)gdpa(device, "vkCreateAccelerationStructureKHR"); table->DestroyAccelerationStructureKHR = (PFN_vkDestroyAccelerationStructureKHR)gdpa(device, "vkDestroyAccelerationStructureKHR"); table->CmdBuildAccelerationStructuresKHR = (PFN_vkCmdBuildAccelerationStructuresKHR)gdpa(device, "vkCmdBuildAccelerationStructuresKHR"); diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp index 487c50d..eaa87a0 100644 --- a/include/vulkan/utility/vk_safe_struct.hpp +++ b/include/vulkan/utility/vk_safe_struct.hpp @@ -18404,6 +18404,334 @@ struct safe_VkPhysicalDeviceRayTracingValidationFeaturesNV { return reinterpret_cast(this); } }; +struct safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 deviceGeneratedCommands; + VkBool32 dynamicGeneratedPipelineLayout; + + safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& copy_src); + safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& operator=( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& copy_src); + safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(); + ~safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(); + void initialize(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT { + VkStructureType sType; + void* pNext{}; + uint32_t maxIndirectPipelineCount; + uint32_t maxIndirectShaderObjectCount; + uint32_t maxIndirectSequenceCount; + uint32_t maxIndirectCommandsTokenCount; + uint32_t maxIndirectCommandsTokenOffset; + uint32_t maxIndirectCommandsIndirectStride; + VkIndirectCommandsInputModeFlagsEXT supportedIndirectCommandsInputModes; + VkShaderStageFlags supportedIndirectCommandsShaderStages; + VkShaderStageFlags supportedIndirectCommandsShaderStagesPipelineBinding; + VkShaderStageFlags supportedIndirectCommandsShaderStagesShaderBinding; + VkBool32 deviceGeneratedCommandsTransformFeedback; + VkBool32 deviceGeneratedCommandsMultiDrawIndirectCount; + + safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& copy_src); + safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& operator=( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& copy_src); + safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(); + ~safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(); + void initialize(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkGeneratedCommandsMemoryRequirementsInfoEXT { + VkStructureType sType; + void* pNext{}; + VkIndirectExecutionSetEXT indirectExecutionSet; + VkIndirectCommandsLayoutEXT indirectCommandsLayout; + uint32_t maxSequenceCount; + uint32_t maxDrawCount; + + safe_VkGeneratedCommandsMemoryRequirementsInfoEXT(const VkGeneratedCommandsMemoryRequirementsInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkGeneratedCommandsMemoryRequirementsInfoEXT(const safe_VkGeneratedCommandsMemoryRequirementsInfoEXT& copy_src); + safe_VkGeneratedCommandsMemoryRequirementsInfoEXT& operator=(const safe_VkGeneratedCommandsMemoryRequirementsInfoEXT& copy_src); + safe_VkGeneratedCommandsMemoryRequirementsInfoEXT(); + ~safe_VkGeneratedCommandsMemoryRequirementsInfoEXT(); + void initialize(const VkGeneratedCommandsMemoryRequirementsInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkGeneratedCommandsMemoryRequirementsInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkGeneratedCommandsMemoryRequirementsInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkGeneratedCommandsMemoryRequirementsInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkIndirectExecutionSetPipelineInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkPipeline initialPipeline; + uint32_t maxPipelineCount; + + safe_VkIndirectExecutionSetPipelineInfoEXT(const VkIndirectExecutionSetPipelineInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkIndirectExecutionSetPipelineInfoEXT(const safe_VkIndirectExecutionSetPipelineInfoEXT& copy_src); + safe_VkIndirectExecutionSetPipelineInfoEXT& operator=(const safe_VkIndirectExecutionSetPipelineInfoEXT& copy_src); + safe_VkIndirectExecutionSetPipelineInfoEXT(); + ~safe_VkIndirectExecutionSetPipelineInfoEXT(); + void initialize(const VkIndirectExecutionSetPipelineInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkIndirectExecutionSetPipelineInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkIndirectExecutionSetPipelineInfoEXT* ptr() { return reinterpret_cast(this); } + VkIndirectExecutionSetPipelineInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkIndirectExecutionSetShaderLayoutInfoEXT { + VkStructureType sType; + const void* pNext{}; + uint32_t setLayoutCount; + VkDescriptorSetLayout* pSetLayouts{}; + + safe_VkIndirectExecutionSetShaderLayoutInfoEXT(const VkIndirectExecutionSetShaderLayoutInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkIndirectExecutionSetShaderLayoutInfoEXT(const safe_VkIndirectExecutionSetShaderLayoutInfoEXT& copy_src); + safe_VkIndirectExecutionSetShaderLayoutInfoEXT& operator=(const safe_VkIndirectExecutionSetShaderLayoutInfoEXT& copy_src); + safe_VkIndirectExecutionSetShaderLayoutInfoEXT(); + ~safe_VkIndirectExecutionSetShaderLayoutInfoEXT(); + void initialize(const VkIndirectExecutionSetShaderLayoutInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkIndirectExecutionSetShaderLayoutInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkIndirectExecutionSetShaderLayoutInfoEXT* ptr() { return reinterpret_cast(this); } + VkIndirectExecutionSetShaderLayoutInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkIndirectExecutionSetShaderInfoEXT { + VkStructureType sType; + const void* pNext{}; + uint32_t shaderCount; + VkShaderEXT* pInitialShaders{}; + safe_VkIndirectExecutionSetShaderLayoutInfoEXT* pSetLayoutInfos{}; + uint32_t maxShaderCount; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges{}; + + safe_VkIndirectExecutionSetShaderInfoEXT(const VkIndirectExecutionSetShaderInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkIndirectExecutionSetShaderInfoEXT(const safe_VkIndirectExecutionSetShaderInfoEXT& copy_src); + safe_VkIndirectExecutionSetShaderInfoEXT& operator=(const safe_VkIndirectExecutionSetShaderInfoEXT& copy_src); + safe_VkIndirectExecutionSetShaderInfoEXT(); + ~safe_VkIndirectExecutionSetShaderInfoEXT(); + void initialize(const VkIndirectExecutionSetShaderInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkIndirectExecutionSetShaderInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkIndirectExecutionSetShaderInfoEXT* ptr() { return reinterpret_cast(this); } + VkIndirectExecutionSetShaderInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +union safe_VkIndirectExecutionSetInfoEXT { + safe_VkIndirectExecutionSetPipelineInfoEXT* pPipelineInfo; + safe_VkIndirectExecutionSetShaderInfoEXT* pShaderInfo; + + safe_VkIndirectExecutionSetInfoEXT(const VkIndirectExecutionSetInfoEXT* in_struct, PNextCopyState* copy_state = {}); + safe_VkIndirectExecutionSetInfoEXT(const safe_VkIndirectExecutionSetInfoEXT& copy_src); + safe_VkIndirectExecutionSetInfoEXT& operator=(const safe_VkIndirectExecutionSetInfoEXT& copy_src); + safe_VkIndirectExecutionSetInfoEXT(); + ~safe_VkIndirectExecutionSetInfoEXT(); + void initialize(const VkIndirectExecutionSetInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkIndirectExecutionSetInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkIndirectExecutionSetInfoEXT* ptr() { return reinterpret_cast(this); } + VkIndirectExecutionSetInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkIndirectExecutionSetCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkIndirectExecutionSetInfoTypeEXT type; + safe_VkIndirectExecutionSetInfoEXT info; + + safe_VkIndirectExecutionSetCreateInfoEXT(const VkIndirectExecutionSetCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkIndirectExecutionSetCreateInfoEXT(const safe_VkIndirectExecutionSetCreateInfoEXT& copy_src); + safe_VkIndirectExecutionSetCreateInfoEXT& operator=(const safe_VkIndirectExecutionSetCreateInfoEXT& copy_src); + safe_VkIndirectExecutionSetCreateInfoEXT(); + ~safe_VkIndirectExecutionSetCreateInfoEXT(); + void initialize(const VkIndirectExecutionSetCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkIndirectExecutionSetCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkIndirectExecutionSetCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkIndirectExecutionSetCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkGeneratedCommandsInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkShaderStageFlags shaderStages; + VkIndirectExecutionSetEXT indirectExecutionSet; + VkIndirectCommandsLayoutEXT indirectCommandsLayout; + VkDeviceAddress indirectAddress; + VkDeviceSize indirectAddressSize; + VkDeviceAddress preprocessAddress; + VkDeviceSize preprocessSize; + uint32_t maxSequenceCount; + VkDeviceAddress sequenceCountAddress; + uint32_t maxDrawCount; + + safe_VkGeneratedCommandsInfoEXT(const VkGeneratedCommandsInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkGeneratedCommandsInfoEXT(const safe_VkGeneratedCommandsInfoEXT& copy_src); + safe_VkGeneratedCommandsInfoEXT& operator=(const safe_VkGeneratedCommandsInfoEXT& copy_src); + safe_VkGeneratedCommandsInfoEXT(); + ~safe_VkGeneratedCommandsInfoEXT(); + void initialize(const VkGeneratedCommandsInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkGeneratedCommandsInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkGeneratedCommandsInfoEXT* ptr() { return reinterpret_cast(this); } + VkGeneratedCommandsInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkWriteIndirectExecutionSetPipelineEXT { + VkStructureType sType; + const void* pNext{}; + uint32_t index; + VkPipeline pipeline; + + safe_VkWriteIndirectExecutionSetPipelineEXT(const VkWriteIndirectExecutionSetPipelineEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkWriteIndirectExecutionSetPipelineEXT(const safe_VkWriteIndirectExecutionSetPipelineEXT& copy_src); + safe_VkWriteIndirectExecutionSetPipelineEXT& operator=(const safe_VkWriteIndirectExecutionSetPipelineEXT& copy_src); + safe_VkWriteIndirectExecutionSetPipelineEXT(); + ~safe_VkWriteIndirectExecutionSetPipelineEXT(); + void initialize(const VkWriteIndirectExecutionSetPipelineEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkWriteIndirectExecutionSetPipelineEXT* copy_src, PNextCopyState* copy_state = {}); + VkWriteIndirectExecutionSetPipelineEXT* ptr() { return reinterpret_cast(this); } + VkWriteIndirectExecutionSetPipelineEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +union safe_VkIndirectCommandsTokenDataEXT { + const VkIndirectCommandsPushConstantTokenEXT* pPushConstant{}; + const VkIndirectCommandsVertexBufferTokenEXT* pVertexBuffer; + const VkIndirectCommandsIndexBufferTokenEXT* pIndexBuffer; + const VkIndirectCommandsExecutionSetTokenEXT* pExecutionSet; + + safe_VkIndirectCommandsTokenDataEXT(const VkIndirectCommandsTokenDataEXT* in_struct, PNextCopyState* copy_state = {}); + safe_VkIndirectCommandsTokenDataEXT(const safe_VkIndirectCommandsTokenDataEXT& copy_src); + safe_VkIndirectCommandsTokenDataEXT& operator=(const safe_VkIndirectCommandsTokenDataEXT& copy_src); + safe_VkIndirectCommandsTokenDataEXT(); + ~safe_VkIndirectCommandsTokenDataEXT(); + void initialize(const VkIndirectCommandsTokenDataEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkIndirectCommandsTokenDataEXT* copy_src, PNextCopyState* copy_state = {}); + VkIndirectCommandsTokenDataEXT* ptr() { return reinterpret_cast(this); } + VkIndirectCommandsTokenDataEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkIndirectCommandsLayoutTokenEXT { + VkStructureType sType; + const void* pNext{}; + VkIndirectCommandsTokenTypeEXT type; + safe_VkIndirectCommandsTokenDataEXT data; + uint32_t offset; + + safe_VkIndirectCommandsLayoutTokenEXT(const VkIndirectCommandsLayoutTokenEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkIndirectCommandsLayoutTokenEXT(const safe_VkIndirectCommandsLayoutTokenEXT& copy_src); + safe_VkIndirectCommandsLayoutTokenEXT& operator=(const safe_VkIndirectCommandsLayoutTokenEXT& copy_src); + safe_VkIndirectCommandsLayoutTokenEXT(); + ~safe_VkIndirectCommandsLayoutTokenEXT(); + void initialize(const VkIndirectCommandsLayoutTokenEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkIndirectCommandsLayoutTokenEXT* copy_src, PNextCopyState* copy_state = {}); + VkIndirectCommandsLayoutTokenEXT* ptr() { return reinterpret_cast(this); } + VkIndirectCommandsLayoutTokenEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkIndirectCommandsLayoutCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkIndirectCommandsLayoutUsageFlagsEXT flags; + VkShaderStageFlags shaderStages; + uint32_t indirectStride; + VkPipelineLayout pipelineLayout; + uint32_t tokenCount; + safe_VkIndirectCommandsLayoutTokenEXT* pTokens{}; + + safe_VkIndirectCommandsLayoutCreateInfoEXT(const VkIndirectCommandsLayoutCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkIndirectCommandsLayoutCreateInfoEXT(const safe_VkIndirectCommandsLayoutCreateInfoEXT& copy_src); + safe_VkIndirectCommandsLayoutCreateInfoEXT& operator=(const safe_VkIndirectCommandsLayoutCreateInfoEXT& copy_src); + safe_VkIndirectCommandsLayoutCreateInfoEXT(); + ~safe_VkIndirectCommandsLayoutCreateInfoEXT(); + void initialize(const VkIndirectCommandsLayoutCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkIndirectCommandsLayoutCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkIndirectCommandsLayoutCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkIndirectCommandsLayoutCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkGeneratedCommandsPipelineInfoEXT { + VkStructureType sType; + void* pNext{}; + VkPipeline pipeline; + + safe_VkGeneratedCommandsPipelineInfoEXT(const VkGeneratedCommandsPipelineInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkGeneratedCommandsPipelineInfoEXT(const safe_VkGeneratedCommandsPipelineInfoEXT& copy_src); + safe_VkGeneratedCommandsPipelineInfoEXT& operator=(const safe_VkGeneratedCommandsPipelineInfoEXT& copy_src); + safe_VkGeneratedCommandsPipelineInfoEXT(); + ~safe_VkGeneratedCommandsPipelineInfoEXT(); + void initialize(const VkGeneratedCommandsPipelineInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkGeneratedCommandsPipelineInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkGeneratedCommandsPipelineInfoEXT* ptr() { return reinterpret_cast(this); } + VkGeneratedCommandsPipelineInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkGeneratedCommandsShaderInfoEXT { + VkStructureType sType; + void* pNext{}; + uint32_t shaderCount; + VkShaderEXT* pShaders{}; + + safe_VkGeneratedCommandsShaderInfoEXT(const VkGeneratedCommandsShaderInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkGeneratedCommandsShaderInfoEXT(const safe_VkGeneratedCommandsShaderInfoEXT& copy_src); + safe_VkGeneratedCommandsShaderInfoEXT& operator=(const safe_VkGeneratedCommandsShaderInfoEXT& copy_src); + safe_VkGeneratedCommandsShaderInfoEXT(); + ~safe_VkGeneratedCommandsShaderInfoEXT(); + void initialize(const VkGeneratedCommandsShaderInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkGeneratedCommandsShaderInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkGeneratedCommandsShaderInfoEXT* ptr() { return reinterpret_cast(this); } + VkGeneratedCommandsShaderInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkWriteIndirectExecutionSetShaderEXT { + VkStructureType sType; + const void* pNext{}; + uint32_t index; + VkShaderEXT shader; + + safe_VkWriteIndirectExecutionSetShaderEXT(const VkWriteIndirectExecutionSetShaderEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkWriteIndirectExecutionSetShaderEXT(const safe_VkWriteIndirectExecutionSetShaderEXT& copy_src); + safe_VkWriteIndirectExecutionSetShaderEXT& operator=(const safe_VkWriteIndirectExecutionSetShaderEXT& copy_src); + safe_VkWriteIndirectExecutionSetShaderEXT(); + ~safe_VkWriteIndirectExecutionSetShaderEXT(); + void initialize(const VkWriteIndirectExecutionSetShaderEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkWriteIndirectExecutionSetShaderEXT* copy_src, PNextCopyState* copy_state = {}); + VkWriteIndirectExecutionSetShaderEXT* ptr() { return reinterpret_cast(this); } + VkWriteIndirectExecutionSetShaderEXT const* ptr() const { + return reinterpret_cast(this); + } +}; struct safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA { VkStructureType sType; void* pNext{}; @@ -18465,6 +18793,48 @@ struct safe_VkImageAlignmentControlCreateInfoMESA { return reinterpret_cast(this); } }; +struct safe_VkPhysicalDeviceDepthClampControlFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 depthClampControl; + + safe_VkPhysicalDeviceDepthClampControlFeaturesEXT(const VkPhysicalDeviceDepthClampControlFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDepthClampControlFeaturesEXT(const safe_VkPhysicalDeviceDepthClampControlFeaturesEXT& copy_src); + safe_VkPhysicalDeviceDepthClampControlFeaturesEXT& operator=(const safe_VkPhysicalDeviceDepthClampControlFeaturesEXT& copy_src); + safe_VkPhysicalDeviceDepthClampControlFeaturesEXT(); + ~safe_VkPhysicalDeviceDepthClampControlFeaturesEXT(); + void initialize(const VkPhysicalDeviceDepthClampControlFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDepthClampControlFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDepthClampControlFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDepthClampControlFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineViewportDepthClampControlCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkDepthClampModeEXT depthClampMode; + const VkDepthClampRangeEXT* pDepthClampRange{}; + + safe_VkPipelineViewportDepthClampControlCreateInfoEXT(const VkPipelineViewportDepthClampControlCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineViewportDepthClampControlCreateInfoEXT(const safe_VkPipelineViewportDepthClampControlCreateInfoEXT& copy_src); + safe_VkPipelineViewportDepthClampControlCreateInfoEXT& operator=( + const safe_VkPipelineViewportDepthClampControlCreateInfoEXT& copy_src); + safe_VkPipelineViewportDepthClampControlCreateInfoEXT(); + ~safe_VkPipelineViewportDepthClampControlCreateInfoEXT(); + void initialize(const VkPipelineViewportDepthClampControlCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineViewportDepthClampControlCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkPipelineViewportDepthClampControlCreateInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkPipelineViewportDepthClampControlCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; struct safe_VkAccelerationStructureGeometryTrianglesDataKHR { VkStructureType sType; const void* pNext{}; diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp index 1523516..c6395f7 100644 --- a/include/vulkan/utility/vk_struct_helper.hpp +++ b/include/vulkan/utility/vk_struct_helper.hpp @@ -965,9 +965,25 @@ template <> inline VkStructureType GetSType inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; } @@ -1117,6 +1133,8 @@ template<> inline VkObjectType GetObjectType() { retu template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_MICROMAP_EXT; } template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV; } template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_SHADER_EXT; } +template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT; } +template<> inline VkObjectType GetObjectType() { return VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT; } # else // 32 bit template VkObjectType GetObjectType() { diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h index ff68ccb..6cd51f6 100644 --- a/include/vulkan/vk_enum_string_helper.h +++ b/include/vulkan/vk_enum_string_helper.h @@ -1962,12 +1962,44 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_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_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT"; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT: + return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT"; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT: + return "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT"; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT: + return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT"; + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT: + return "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT"; + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT: + return "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT"; + case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT: + return "VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT"; + case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT: + return "VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT"; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT: + return "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT"; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT: + return "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT"; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT: + return "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT"; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: + return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT"; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: + return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA"; case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: return "VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + 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"; default: return "Unhandled VkStructureType"; } @@ -2150,6 +2182,10 @@ static inline const char* string_VkObjectType(VkObjectType input_value) { return "VK_OBJECT_TYPE_SHADER_EXT"; case VK_OBJECT_TYPE_PIPELINE_BINARY_KHR: return "VK_OBJECT_TYPE_PIPELINE_BINARY_KHR"; + case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT: + return "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT"; + case VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT: + return "VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT"; default: return "Unhandled VkObjectType"; } @@ -3156,6 +3192,8 @@ static inline const char* string_VkDynamicState(VkDynamicState input_value) { return "VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT"; case VK_DYNAMIC_STATE_LINE_STIPPLE_KHR: return "VK_DYNAMIC_STATE_LINE_STIPPLE_KHR"; + case VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT: + return "VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT"; default: return "Unhandled VkDynamicState"; } @@ -4750,6 +4788,16 @@ static inline const char* string_VkShaderCodeTypeEXT(VkShaderCodeTypeEXT input_v return "Unhandled VkShaderCodeTypeEXT"; } } +static inline const char* string_VkDepthClampModeEXT(VkDepthClampModeEXT input_value) { + switch (input_value) { + case VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT: + return "VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT"; + case VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT: + return "VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT"; + default: + return "Unhandled VkDepthClampModeEXT"; + } +} static inline const char* string_VkRayTracingInvocationReorderModeNV(VkRayTracingInvocationReorderModeNV input_value) { switch (input_value) { case VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV: @@ -4856,6 +4904,52 @@ static inline const char* string_VkLayeredDriverUnderlyingApiMSFT(VkLayeredDrive return "Unhandled VkLayeredDriverUnderlyingApiMSFT"; } } +static inline const char* string_VkIndirectExecutionSetInfoTypeEXT(VkIndirectExecutionSetInfoTypeEXT input_value) { + switch (input_value) { + case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT: + return "VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT"; + case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT: + return "VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT"; + default: + return "Unhandled VkIndirectExecutionSetInfoTypeEXT"; + } +} +static inline const char* string_VkIndirectCommandsTokenTypeEXT(VkIndirectCommandsTokenTypeEXT input_value) { + switch (input_value) { + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT: + return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT: + return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT: + return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT: + return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT: + return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT: + return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT: + return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT: + return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT: + return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT: + return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT: + return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT: + return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT: + return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT: + return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT: + return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT"; + default: + return "Unhandled VkIndirectCommandsTokenTypeEXT"; + } +} static inline const char* string_VkBuildAccelerationStructureModeKHR(VkBuildAccelerationStructureModeKHR input_value) { switch (input_value) { case VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR: @@ -8361,6 +8455,7 @@ static inline const char* string_VkPipelineCreateFlagBits2KHR(uint64_t input_val if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV) return "VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV"; if (input_value == VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT"; if (input_value == VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR) return "VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR"; + if (input_value == VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT) return "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT"; return "Unhandled VkPipelineCreateFlagBits2KHR"; } @@ -8407,6 +8502,7 @@ static inline const char* string_VkBufferUsageFlagBits2KHR(uint64_t input_value) if (input_value == VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT"; if (input_value == VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT"; if (input_value == VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT"; + if (input_value == VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT"; return "Unhandled VkBufferUsageFlagBits2KHR"; } @@ -9403,6 +9499,8 @@ static inline const char* string_VkShaderCreateFlagBitsEXT(VkShaderCreateFlagBit return "VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT"; case VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: return "VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"; + case VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT: + return "VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT"; default: return "Unhandled VkShaderCreateFlagBitsEXT"; } @@ -9424,6 +9522,60 @@ static inline std::string string_VkShaderCreateFlagsEXT(VkShaderCreateFlagsEXT i return ret; } #endif // __cplusplus +static inline const char* string_VkIndirectCommandsInputModeFlagBitsEXT(VkIndirectCommandsInputModeFlagBitsEXT input_value) { + switch (input_value) { + case VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT: + return "VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT"; + case VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT: + return "VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT"; + default: + return "Unhandled VkIndirectCommandsInputModeFlagBitsEXT"; + } +} + +#ifdef __cplusplus +static inline std::string string_VkIndirectCommandsInputModeFlagsEXT(VkIndirectCommandsInputModeFlagsEXT input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkIndirectCommandsInputModeFlagBitsEXT(static_cast(1U << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkIndirectCommandsInputModeFlagsEXT(0)"); + return ret; +} +#endif // __cplusplus +static inline const char* string_VkIndirectCommandsLayoutUsageFlagBitsEXT(VkIndirectCommandsLayoutUsageFlagBitsEXT input_value) { + switch (input_value) { + case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT: + return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT"; + case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT: + return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT"; + default: + return "Unhandled VkIndirectCommandsLayoutUsageFlagBitsEXT"; + } +} + +#ifdef __cplusplus +static inline std::string string_VkIndirectCommandsLayoutUsageFlagsEXT(VkIndirectCommandsLayoutUsageFlagsEXT input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkIndirectCommandsLayoutUsageFlagBitsEXT(static_cast(1U << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkIndirectCommandsLayoutUsageFlagsEXT(0)"); + return ret; +} +#endif // __cplusplus static inline const char* string_VkAccelerationStructureCreateFlagBitsKHR(VkAccelerationStructureCreateFlagBitsKHR input_value) { switch (input_value) { case VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR: diff --git a/scripts/known_good.json b/scripts/known_good.json index 73d7ede..4cf8298 100644 --- a/scripts/known_good.json +++ b/scripts/known_good.json @@ -7,7 +7,7 @@ "sub_dir": "Vulkan-Headers", "build_dir": "Vulkan-Headers/build", "install_dir": "Vulkan-Headers/build/install", - "commit": "v1.3.295" + "commit": "v1.3.296" }, { "name": "googletest", diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp index 739ad53..4f529d9 100644 --- a/src/vulkan/vk_safe_struct_ext.cpp +++ b/src/vulkan/vk_safe_struct_ext.cpp @@ -15326,6 +15326,1449 @@ void safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT::initialize( pNext = SafePnextCopy(copy_src->pNext); } +safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT::safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT( + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + deviceGeneratedCommands(in_struct->deviceGeneratedCommands), + dynamicGeneratedPipelineLayout(in_struct->dynamicGeneratedPipelineLayout) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT::safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT), + pNext(nullptr), + deviceGeneratedCommands(), + dynamicGeneratedPipelineLayout() {} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT::safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& copy_src) { + sType = copy_src.sType; + deviceGeneratedCommands = copy_src.deviceGeneratedCommands; + dynamicGeneratedPipelineLayout = copy_src.dynamicGeneratedPipelineLayout; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT::operator=( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + deviceGeneratedCommands = copy_src.deviceGeneratedCommands; + dynamicGeneratedPipelineLayout = copy_src.dynamicGeneratedPipelineLayout; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT::~safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT::initialize( + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + deviceGeneratedCommands = in_struct->deviceGeneratedCommands; + dynamicGeneratedPipelineLayout = in_struct->dynamicGeneratedPipelineLayout; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT::initialize( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + deviceGeneratedCommands = copy_src->deviceGeneratedCommands; + dynamicGeneratedPipelineLayout = copy_src->dynamicGeneratedPipelineLayout; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT::safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT( + const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + maxIndirectPipelineCount(in_struct->maxIndirectPipelineCount), + maxIndirectShaderObjectCount(in_struct->maxIndirectShaderObjectCount), + maxIndirectSequenceCount(in_struct->maxIndirectSequenceCount), + maxIndirectCommandsTokenCount(in_struct->maxIndirectCommandsTokenCount), + maxIndirectCommandsTokenOffset(in_struct->maxIndirectCommandsTokenOffset), + maxIndirectCommandsIndirectStride(in_struct->maxIndirectCommandsIndirectStride), + supportedIndirectCommandsInputModes(in_struct->supportedIndirectCommandsInputModes), + supportedIndirectCommandsShaderStages(in_struct->supportedIndirectCommandsShaderStages), + supportedIndirectCommandsShaderStagesPipelineBinding(in_struct->supportedIndirectCommandsShaderStagesPipelineBinding), + supportedIndirectCommandsShaderStagesShaderBinding(in_struct->supportedIndirectCommandsShaderStagesShaderBinding), + deviceGeneratedCommandsTransformFeedback(in_struct->deviceGeneratedCommandsTransformFeedback), + deviceGeneratedCommandsMultiDrawIndirectCount(in_struct->deviceGeneratedCommandsMultiDrawIndirectCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT::safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT), + pNext(nullptr), + maxIndirectPipelineCount(), + maxIndirectShaderObjectCount(), + maxIndirectSequenceCount(), + maxIndirectCommandsTokenCount(), + maxIndirectCommandsTokenOffset(), + maxIndirectCommandsIndirectStride(), + supportedIndirectCommandsInputModes(), + supportedIndirectCommandsShaderStages(), + supportedIndirectCommandsShaderStagesPipelineBinding(), + supportedIndirectCommandsShaderStagesShaderBinding(), + deviceGeneratedCommandsTransformFeedback(), + deviceGeneratedCommandsMultiDrawIndirectCount() {} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT::safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& copy_src) { + sType = copy_src.sType; + maxIndirectPipelineCount = copy_src.maxIndirectPipelineCount; + maxIndirectShaderObjectCount = copy_src.maxIndirectShaderObjectCount; + maxIndirectSequenceCount = copy_src.maxIndirectSequenceCount; + maxIndirectCommandsTokenCount = copy_src.maxIndirectCommandsTokenCount; + maxIndirectCommandsTokenOffset = copy_src.maxIndirectCommandsTokenOffset; + maxIndirectCommandsIndirectStride = copy_src.maxIndirectCommandsIndirectStride; + supportedIndirectCommandsInputModes = copy_src.supportedIndirectCommandsInputModes; + supportedIndirectCommandsShaderStages = copy_src.supportedIndirectCommandsShaderStages; + supportedIndirectCommandsShaderStagesPipelineBinding = copy_src.supportedIndirectCommandsShaderStagesPipelineBinding; + supportedIndirectCommandsShaderStagesShaderBinding = copy_src.supportedIndirectCommandsShaderStagesShaderBinding; + deviceGeneratedCommandsTransformFeedback = copy_src.deviceGeneratedCommandsTransformFeedback; + deviceGeneratedCommandsMultiDrawIndirectCount = copy_src.deviceGeneratedCommandsMultiDrawIndirectCount; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT::operator=( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxIndirectPipelineCount = copy_src.maxIndirectPipelineCount; + maxIndirectShaderObjectCount = copy_src.maxIndirectShaderObjectCount; + maxIndirectSequenceCount = copy_src.maxIndirectSequenceCount; + maxIndirectCommandsTokenCount = copy_src.maxIndirectCommandsTokenCount; + maxIndirectCommandsTokenOffset = copy_src.maxIndirectCommandsTokenOffset; + maxIndirectCommandsIndirectStride = copy_src.maxIndirectCommandsIndirectStride; + supportedIndirectCommandsInputModes = copy_src.supportedIndirectCommandsInputModes; + supportedIndirectCommandsShaderStages = copy_src.supportedIndirectCommandsShaderStages; + supportedIndirectCommandsShaderStagesPipelineBinding = copy_src.supportedIndirectCommandsShaderStagesPipelineBinding; + supportedIndirectCommandsShaderStagesShaderBinding = copy_src.supportedIndirectCommandsShaderStagesShaderBinding; + deviceGeneratedCommandsTransformFeedback = copy_src.deviceGeneratedCommandsTransformFeedback; + deviceGeneratedCommandsMultiDrawIndirectCount = copy_src.deviceGeneratedCommandsMultiDrawIndirectCount; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT::~safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT::initialize( + const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxIndirectPipelineCount = in_struct->maxIndirectPipelineCount; + maxIndirectShaderObjectCount = in_struct->maxIndirectShaderObjectCount; + maxIndirectSequenceCount = in_struct->maxIndirectSequenceCount; + maxIndirectCommandsTokenCount = in_struct->maxIndirectCommandsTokenCount; + maxIndirectCommandsTokenOffset = in_struct->maxIndirectCommandsTokenOffset; + maxIndirectCommandsIndirectStride = in_struct->maxIndirectCommandsIndirectStride; + supportedIndirectCommandsInputModes = in_struct->supportedIndirectCommandsInputModes; + supportedIndirectCommandsShaderStages = in_struct->supportedIndirectCommandsShaderStages; + supportedIndirectCommandsShaderStagesPipelineBinding = in_struct->supportedIndirectCommandsShaderStagesPipelineBinding; + supportedIndirectCommandsShaderStagesShaderBinding = in_struct->supportedIndirectCommandsShaderStagesShaderBinding; + deviceGeneratedCommandsTransformFeedback = in_struct->deviceGeneratedCommandsTransformFeedback; + deviceGeneratedCommandsMultiDrawIndirectCount = in_struct->deviceGeneratedCommandsMultiDrawIndirectCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT::initialize( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxIndirectPipelineCount = copy_src->maxIndirectPipelineCount; + maxIndirectShaderObjectCount = copy_src->maxIndirectShaderObjectCount; + maxIndirectSequenceCount = copy_src->maxIndirectSequenceCount; + maxIndirectCommandsTokenCount = copy_src->maxIndirectCommandsTokenCount; + maxIndirectCommandsTokenOffset = copy_src->maxIndirectCommandsTokenOffset; + maxIndirectCommandsIndirectStride = copy_src->maxIndirectCommandsIndirectStride; + supportedIndirectCommandsInputModes = copy_src->supportedIndirectCommandsInputModes; + supportedIndirectCommandsShaderStages = copy_src->supportedIndirectCommandsShaderStages; + supportedIndirectCommandsShaderStagesPipelineBinding = copy_src->supportedIndirectCommandsShaderStagesPipelineBinding; + supportedIndirectCommandsShaderStagesShaderBinding = copy_src->supportedIndirectCommandsShaderStagesShaderBinding; + deviceGeneratedCommandsTransformFeedback = copy_src->deviceGeneratedCommandsTransformFeedback; + deviceGeneratedCommandsMultiDrawIndirectCount = copy_src->deviceGeneratedCommandsMultiDrawIndirectCount; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkGeneratedCommandsMemoryRequirementsInfoEXT::safe_VkGeneratedCommandsMemoryRequirementsInfoEXT( + const VkGeneratedCommandsMemoryRequirementsInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + indirectExecutionSet(in_struct->indirectExecutionSet), + indirectCommandsLayout(in_struct->indirectCommandsLayout), + maxSequenceCount(in_struct->maxSequenceCount), + maxDrawCount(in_struct->maxDrawCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkGeneratedCommandsMemoryRequirementsInfoEXT::safe_VkGeneratedCommandsMemoryRequirementsInfoEXT() + : sType(VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT), + pNext(nullptr), + indirectExecutionSet(), + indirectCommandsLayout(), + maxSequenceCount(), + maxDrawCount() {} + +safe_VkGeneratedCommandsMemoryRequirementsInfoEXT::safe_VkGeneratedCommandsMemoryRequirementsInfoEXT( + const safe_VkGeneratedCommandsMemoryRequirementsInfoEXT& copy_src) { + sType = copy_src.sType; + indirectExecutionSet = copy_src.indirectExecutionSet; + indirectCommandsLayout = copy_src.indirectCommandsLayout; + maxSequenceCount = copy_src.maxSequenceCount; + maxDrawCount = copy_src.maxDrawCount; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkGeneratedCommandsMemoryRequirementsInfoEXT& safe_VkGeneratedCommandsMemoryRequirementsInfoEXT::operator=( + const safe_VkGeneratedCommandsMemoryRequirementsInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + indirectExecutionSet = copy_src.indirectExecutionSet; + indirectCommandsLayout = copy_src.indirectCommandsLayout; + maxSequenceCount = copy_src.maxSequenceCount; + maxDrawCount = copy_src.maxDrawCount; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkGeneratedCommandsMemoryRequirementsInfoEXT::~safe_VkGeneratedCommandsMemoryRequirementsInfoEXT() { FreePnextChain(pNext); } + +void safe_VkGeneratedCommandsMemoryRequirementsInfoEXT::initialize(const VkGeneratedCommandsMemoryRequirementsInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + indirectExecutionSet = in_struct->indirectExecutionSet; + indirectCommandsLayout = in_struct->indirectCommandsLayout; + maxSequenceCount = in_struct->maxSequenceCount; + maxDrawCount = in_struct->maxDrawCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkGeneratedCommandsMemoryRequirementsInfoEXT::initialize( + const safe_VkGeneratedCommandsMemoryRequirementsInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + indirectExecutionSet = copy_src->indirectExecutionSet; + indirectCommandsLayout = copy_src->indirectCommandsLayout; + maxSequenceCount = copy_src->maxSequenceCount; + maxDrawCount = copy_src->maxDrawCount; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkIndirectExecutionSetPipelineInfoEXT::safe_VkIndirectExecutionSetPipelineInfoEXT( + const VkIndirectExecutionSetPipelineInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), initialPipeline(in_struct->initialPipeline), maxPipelineCount(in_struct->maxPipelineCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkIndirectExecutionSetPipelineInfoEXT::safe_VkIndirectExecutionSetPipelineInfoEXT() + : sType(VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT), pNext(nullptr), initialPipeline(), maxPipelineCount() {} + +safe_VkIndirectExecutionSetPipelineInfoEXT::safe_VkIndirectExecutionSetPipelineInfoEXT( + const safe_VkIndirectExecutionSetPipelineInfoEXT& copy_src) { + sType = copy_src.sType; + initialPipeline = copy_src.initialPipeline; + maxPipelineCount = copy_src.maxPipelineCount; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkIndirectExecutionSetPipelineInfoEXT& safe_VkIndirectExecutionSetPipelineInfoEXT::operator=( + const safe_VkIndirectExecutionSetPipelineInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + initialPipeline = copy_src.initialPipeline; + maxPipelineCount = copy_src.maxPipelineCount; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkIndirectExecutionSetPipelineInfoEXT::~safe_VkIndirectExecutionSetPipelineInfoEXT() { FreePnextChain(pNext); } + +void safe_VkIndirectExecutionSetPipelineInfoEXT::initialize(const VkIndirectExecutionSetPipelineInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + initialPipeline = in_struct->initialPipeline; + maxPipelineCount = in_struct->maxPipelineCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkIndirectExecutionSetPipelineInfoEXT::initialize(const safe_VkIndirectExecutionSetPipelineInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + initialPipeline = copy_src->initialPipeline; + maxPipelineCount = copy_src->maxPipelineCount; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkIndirectExecutionSetShaderLayoutInfoEXT::safe_VkIndirectExecutionSetShaderLayoutInfoEXT( + const VkIndirectExecutionSetShaderLayoutInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), setLayoutCount(in_struct->setLayoutCount), pSetLayouts(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (setLayoutCount && in_struct->pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[setLayoutCount]; + for (uint32_t i = 0; i < setLayoutCount; ++i) { + pSetLayouts[i] = in_struct->pSetLayouts[i]; + } + } +} + +safe_VkIndirectExecutionSetShaderLayoutInfoEXT::safe_VkIndirectExecutionSetShaderLayoutInfoEXT() + : sType(VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT), + pNext(nullptr), + setLayoutCount(), + pSetLayouts(nullptr) {} + +safe_VkIndirectExecutionSetShaderLayoutInfoEXT::safe_VkIndirectExecutionSetShaderLayoutInfoEXT( + const safe_VkIndirectExecutionSetShaderLayoutInfoEXT& copy_src) { + sType = copy_src.sType; + setLayoutCount = copy_src.setLayoutCount; + pSetLayouts = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (setLayoutCount && copy_src.pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[setLayoutCount]; + for (uint32_t i = 0; i < setLayoutCount; ++i) { + pSetLayouts[i] = copy_src.pSetLayouts[i]; + } + } +} + +safe_VkIndirectExecutionSetShaderLayoutInfoEXT& safe_VkIndirectExecutionSetShaderLayoutInfoEXT::operator=( + const safe_VkIndirectExecutionSetShaderLayoutInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pSetLayouts) delete[] pSetLayouts; + FreePnextChain(pNext); + + sType = copy_src.sType; + setLayoutCount = copy_src.setLayoutCount; + pSetLayouts = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (setLayoutCount && copy_src.pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[setLayoutCount]; + for (uint32_t i = 0; i < setLayoutCount; ++i) { + pSetLayouts[i] = copy_src.pSetLayouts[i]; + } + } + + return *this; +} + +safe_VkIndirectExecutionSetShaderLayoutInfoEXT::~safe_VkIndirectExecutionSetShaderLayoutInfoEXT() { + if (pSetLayouts) delete[] pSetLayouts; + FreePnextChain(pNext); +} + +void safe_VkIndirectExecutionSetShaderLayoutInfoEXT::initialize(const VkIndirectExecutionSetShaderLayoutInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pSetLayouts) delete[] pSetLayouts; + FreePnextChain(pNext); + sType = in_struct->sType; + setLayoutCount = in_struct->setLayoutCount; + pSetLayouts = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (setLayoutCount && in_struct->pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[setLayoutCount]; + for (uint32_t i = 0; i < setLayoutCount; ++i) { + pSetLayouts[i] = in_struct->pSetLayouts[i]; + } + } +} + +void safe_VkIndirectExecutionSetShaderLayoutInfoEXT::initialize(const safe_VkIndirectExecutionSetShaderLayoutInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + setLayoutCount = copy_src->setLayoutCount; + pSetLayouts = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (setLayoutCount && copy_src->pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[setLayoutCount]; + for (uint32_t i = 0; i < setLayoutCount; ++i) { + pSetLayouts[i] = copy_src->pSetLayouts[i]; + } + } +} + +safe_VkIndirectExecutionSetShaderInfoEXT::safe_VkIndirectExecutionSetShaderInfoEXT( + const VkIndirectExecutionSetShaderInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shaderCount(in_struct->shaderCount), + pInitialShaders(nullptr), + pSetLayoutInfos(nullptr), + maxShaderCount(in_struct->maxShaderCount), + pushConstantRangeCount(in_struct->pushConstantRangeCount), + pPushConstantRanges(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (shaderCount && in_struct->pInitialShaders) { + pInitialShaders = new VkShaderEXT[shaderCount]; + for (uint32_t i = 0; i < shaderCount; ++i) { + pInitialShaders[i] = in_struct->pInitialShaders[i]; + } + } + if (shaderCount && in_struct->pSetLayoutInfos) { + pSetLayoutInfos = new safe_VkIndirectExecutionSetShaderLayoutInfoEXT[shaderCount]; + for (uint32_t i = 0; i < shaderCount; ++i) { + pSetLayoutInfos[i].initialize(&in_struct->pSetLayoutInfos[i]); + } + } + + if (in_struct->pPushConstantRanges) { + pPushConstantRanges = new VkPushConstantRange[in_struct->pushConstantRangeCount]; + memcpy((void*)pPushConstantRanges, (void*)in_struct->pPushConstantRanges, + sizeof(VkPushConstantRange) * in_struct->pushConstantRangeCount); + } +} + +safe_VkIndirectExecutionSetShaderInfoEXT::safe_VkIndirectExecutionSetShaderInfoEXT() + : sType(VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT), + pNext(nullptr), + shaderCount(), + pInitialShaders(nullptr), + pSetLayoutInfos(nullptr), + maxShaderCount(), + pushConstantRangeCount(), + pPushConstantRanges(nullptr) {} + +safe_VkIndirectExecutionSetShaderInfoEXT::safe_VkIndirectExecutionSetShaderInfoEXT( + const safe_VkIndirectExecutionSetShaderInfoEXT& copy_src) { + sType = copy_src.sType; + shaderCount = copy_src.shaderCount; + pInitialShaders = nullptr; + pSetLayoutInfos = nullptr; + maxShaderCount = copy_src.maxShaderCount; + pushConstantRangeCount = copy_src.pushConstantRangeCount; + pPushConstantRanges = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (shaderCount && copy_src.pInitialShaders) { + pInitialShaders = new VkShaderEXT[shaderCount]; + for (uint32_t i = 0; i < shaderCount; ++i) { + pInitialShaders[i] = copy_src.pInitialShaders[i]; + } + } + if (shaderCount && copy_src.pSetLayoutInfos) { + pSetLayoutInfos = new safe_VkIndirectExecutionSetShaderLayoutInfoEXT[shaderCount]; + for (uint32_t i = 0; i < shaderCount; ++i) { + pSetLayoutInfos[i].initialize(©_src.pSetLayoutInfos[i]); + } + } + + if (copy_src.pPushConstantRanges) { + pPushConstantRanges = new VkPushConstantRange[copy_src.pushConstantRangeCount]; + memcpy((void*)pPushConstantRanges, (void*)copy_src.pPushConstantRanges, + sizeof(VkPushConstantRange) * copy_src.pushConstantRangeCount); + } +} + +safe_VkIndirectExecutionSetShaderInfoEXT& safe_VkIndirectExecutionSetShaderInfoEXT::operator=( + const safe_VkIndirectExecutionSetShaderInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pInitialShaders) delete[] pInitialShaders; + if (pSetLayoutInfos) delete[] pSetLayoutInfos; + if (pPushConstantRanges) delete[] pPushConstantRanges; + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderCount = copy_src.shaderCount; + pInitialShaders = nullptr; + pSetLayoutInfos = nullptr; + maxShaderCount = copy_src.maxShaderCount; + pushConstantRangeCount = copy_src.pushConstantRangeCount; + pPushConstantRanges = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (shaderCount && copy_src.pInitialShaders) { + pInitialShaders = new VkShaderEXT[shaderCount]; + for (uint32_t i = 0; i < shaderCount; ++i) { + pInitialShaders[i] = copy_src.pInitialShaders[i]; + } + } + if (shaderCount && copy_src.pSetLayoutInfos) { + pSetLayoutInfos = new safe_VkIndirectExecutionSetShaderLayoutInfoEXT[shaderCount]; + for (uint32_t i = 0; i < shaderCount; ++i) { + pSetLayoutInfos[i].initialize(©_src.pSetLayoutInfos[i]); + } + } + + if (copy_src.pPushConstantRanges) { + pPushConstantRanges = new VkPushConstantRange[copy_src.pushConstantRangeCount]; + memcpy((void*)pPushConstantRanges, (void*)copy_src.pPushConstantRanges, + sizeof(VkPushConstantRange) * copy_src.pushConstantRangeCount); + } + + return *this; +} + +safe_VkIndirectExecutionSetShaderInfoEXT::~safe_VkIndirectExecutionSetShaderInfoEXT() { + if (pInitialShaders) delete[] pInitialShaders; + if (pSetLayoutInfos) delete[] pSetLayoutInfos; + if (pPushConstantRanges) delete[] pPushConstantRanges; + FreePnextChain(pNext); +} + +void safe_VkIndirectExecutionSetShaderInfoEXT::initialize(const VkIndirectExecutionSetShaderInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pInitialShaders) delete[] pInitialShaders; + if (pSetLayoutInfos) delete[] pSetLayoutInfos; + if (pPushConstantRanges) delete[] pPushConstantRanges; + FreePnextChain(pNext); + sType = in_struct->sType; + shaderCount = in_struct->shaderCount; + pInitialShaders = nullptr; + pSetLayoutInfos = nullptr; + maxShaderCount = in_struct->maxShaderCount; + pushConstantRangeCount = in_struct->pushConstantRangeCount; + pPushConstantRanges = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (shaderCount && in_struct->pInitialShaders) { + pInitialShaders = new VkShaderEXT[shaderCount]; + for (uint32_t i = 0; i < shaderCount; ++i) { + pInitialShaders[i] = in_struct->pInitialShaders[i]; + } + } + if (shaderCount && in_struct->pSetLayoutInfos) { + pSetLayoutInfos = new safe_VkIndirectExecutionSetShaderLayoutInfoEXT[shaderCount]; + for (uint32_t i = 0; i < shaderCount; ++i) { + pSetLayoutInfos[i].initialize(&in_struct->pSetLayoutInfos[i]); + } + } + + if (in_struct->pPushConstantRanges) { + pPushConstantRanges = new VkPushConstantRange[in_struct->pushConstantRangeCount]; + memcpy((void*)pPushConstantRanges, (void*)in_struct->pPushConstantRanges, + sizeof(VkPushConstantRange) * in_struct->pushConstantRangeCount); + } +} + +void safe_VkIndirectExecutionSetShaderInfoEXT::initialize(const safe_VkIndirectExecutionSetShaderInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderCount = copy_src->shaderCount; + pInitialShaders = nullptr; + pSetLayoutInfos = nullptr; + maxShaderCount = copy_src->maxShaderCount; + pushConstantRangeCount = copy_src->pushConstantRangeCount; + pPushConstantRanges = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (shaderCount && copy_src->pInitialShaders) { + pInitialShaders = new VkShaderEXT[shaderCount]; + for (uint32_t i = 0; i < shaderCount; ++i) { + pInitialShaders[i] = copy_src->pInitialShaders[i]; + } + } + if (shaderCount && copy_src->pSetLayoutInfos) { + pSetLayoutInfos = new safe_VkIndirectExecutionSetShaderLayoutInfoEXT[shaderCount]; + for (uint32_t i = 0; i < shaderCount; ++i) { + pSetLayoutInfos[i].initialize(©_src->pSetLayoutInfos[i]); + } + } + + if (copy_src->pPushConstantRanges) { + pPushConstantRanges = new VkPushConstantRange[copy_src->pushConstantRangeCount]; + memcpy((void*)pPushConstantRanges, (void*)copy_src->pPushConstantRanges, + sizeof(VkPushConstantRange) * copy_src->pushConstantRangeCount); + } +} + +safe_VkIndirectExecutionSetInfoEXT::safe_VkIndirectExecutionSetInfoEXT(const VkIndirectExecutionSetInfoEXT* in_struct, + PNextCopyState*) { + initialize(in_struct); +} + +safe_VkIndirectExecutionSetInfoEXT::safe_VkIndirectExecutionSetInfoEXT() : pPipelineInfo(nullptr), pShaderInfo(nullptr) {} + +safe_VkIndirectExecutionSetInfoEXT::safe_VkIndirectExecutionSetInfoEXT(const safe_VkIndirectExecutionSetInfoEXT& copy_src) { + pPipelineInfo = nullptr; + pShaderInfo = nullptr; + if (copy_src.pPipelineInfo) pPipelineInfo = new safe_VkIndirectExecutionSetPipelineInfoEXT(*copy_src.pPipelineInfo); + if (copy_src.pShaderInfo) pShaderInfo = new safe_VkIndirectExecutionSetShaderInfoEXT(*copy_src.pShaderInfo); +} + +safe_VkIndirectExecutionSetInfoEXT& safe_VkIndirectExecutionSetInfoEXT::operator=( + const safe_VkIndirectExecutionSetInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pPipelineInfo) delete pPipelineInfo; + if (pShaderInfo) delete pShaderInfo; + + pPipelineInfo = nullptr; + pShaderInfo = nullptr; + if (copy_src.pPipelineInfo) pPipelineInfo = new safe_VkIndirectExecutionSetPipelineInfoEXT(*copy_src.pPipelineInfo); + if (copy_src.pShaderInfo) pShaderInfo = new safe_VkIndirectExecutionSetShaderInfoEXT(*copy_src.pShaderInfo); + + return *this; +} + +safe_VkIndirectExecutionSetInfoEXT::~safe_VkIndirectExecutionSetInfoEXT() { + if (pPipelineInfo) delete pPipelineInfo; + if (pShaderInfo) delete pShaderInfo; +} + +void safe_VkIndirectExecutionSetInfoEXT::initialize(const VkIndirectExecutionSetInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPipelineInfo) delete pPipelineInfo; + if (pShaderInfo) delete pShaderInfo; + pPipelineInfo = nullptr; + pShaderInfo = nullptr; + if (in_struct->pPipelineInfo) pPipelineInfo = new safe_VkIndirectExecutionSetPipelineInfoEXT(in_struct->pPipelineInfo); + if (in_struct->pShaderInfo) pShaderInfo = new safe_VkIndirectExecutionSetShaderInfoEXT(in_struct->pShaderInfo); +} + +void safe_VkIndirectExecutionSetInfoEXT::initialize(const safe_VkIndirectExecutionSetInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + pPipelineInfo = nullptr; + pShaderInfo = nullptr; + if (copy_src->pPipelineInfo) pPipelineInfo = new safe_VkIndirectExecutionSetPipelineInfoEXT(*copy_src->pPipelineInfo); + if (copy_src->pShaderInfo) pShaderInfo = new safe_VkIndirectExecutionSetShaderInfoEXT(*copy_src->pShaderInfo); +} + +safe_VkIndirectExecutionSetCreateInfoEXT::safe_VkIndirectExecutionSetCreateInfoEXT( + const VkIndirectExecutionSetCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), type(in_struct->type), info(&in_struct->info) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkIndirectExecutionSetCreateInfoEXT::safe_VkIndirectExecutionSetCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT), pNext(nullptr), type() {} + +safe_VkIndirectExecutionSetCreateInfoEXT::safe_VkIndirectExecutionSetCreateInfoEXT( + const safe_VkIndirectExecutionSetCreateInfoEXT& copy_src) { + sType = copy_src.sType; + type = copy_src.type; + info.initialize(©_src.info); + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkIndirectExecutionSetCreateInfoEXT& safe_VkIndirectExecutionSetCreateInfoEXT::operator=( + const safe_VkIndirectExecutionSetCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + type = copy_src.type; + info.initialize(©_src.info); + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkIndirectExecutionSetCreateInfoEXT::~safe_VkIndirectExecutionSetCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkIndirectExecutionSetCreateInfoEXT::initialize(const VkIndirectExecutionSetCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + type = in_struct->type; + info.initialize(&in_struct->info); + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkIndirectExecutionSetCreateInfoEXT::initialize(const safe_VkIndirectExecutionSetCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + type = copy_src->type; + info.initialize(©_src->info); + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkGeneratedCommandsInfoEXT::safe_VkGeneratedCommandsInfoEXT(const VkGeneratedCommandsInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shaderStages(in_struct->shaderStages), + indirectExecutionSet(in_struct->indirectExecutionSet), + indirectCommandsLayout(in_struct->indirectCommandsLayout), + indirectAddress(in_struct->indirectAddress), + indirectAddressSize(in_struct->indirectAddressSize), + preprocessAddress(in_struct->preprocessAddress), + preprocessSize(in_struct->preprocessSize), + maxSequenceCount(in_struct->maxSequenceCount), + sequenceCountAddress(in_struct->sequenceCountAddress), + maxDrawCount(in_struct->maxDrawCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkGeneratedCommandsInfoEXT::safe_VkGeneratedCommandsInfoEXT() + : sType(VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT), + pNext(nullptr), + shaderStages(), + indirectExecutionSet(), + indirectCommandsLayout(), + indirectAddress(), + indirectAddressSize(), + preprocessAddress(), + preprocessSize(), + maxSequenceCount(), + sequenceCountAddress(), + maxDrawCount() {} + +safe_VkGeneratedCommandsInfoEXT::safe_VkGeneratedCommandsInfoEXT(const safe_VkGeneratedCommandsInfoEXT& copy_src) { + sType = copy_src.sType; + shaderStages = copy_src.shaderStages; + indirectExecutionSet = copy_src.indirectExecutionSet; + indirectCommandsLayout = copy_src.indirectCommandsLayout; + indirectAddress = copy_src.indirectAddress; + indirectAddressSize = copy_src.indirectAddressSize; + preprocessAddress = copy_src.preprocessAddress; + preprocessSize = copy_src.preprocessSize; + maxSequenceCount = copy_src.maxSequenceCount; + sequenceCountAddress = copy_src.sequenceCountAddress; + maxDrawCount = copy_src.maxDrawCount; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkGeneratedCommandsInfoEXT& safe_VkGeneratedCommandsInfoEXT::operator=(const safe_VkGeneratedCommandsInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderStages = copy_src.shaderStages; + indirectExecutionSet = copy_src.indirectExecutionSet; + indirectCommandsLayout = copy_src.indirectCommandsLayout; + indirectAddress = copy_src.indirectAddress; + indirectAddressSize = copy_src.indirectAddressSize; + preprocessAddress = copy_src.preprocessAddress; + preprocessSize = copy_src.preprocessSize; + maxSequenceCount = copy_src.maxSequenceCount; + sequenceCountAddress = copy_src.sequenceCountAddress; + maxDrawCount = copy_src.maxDrawCount; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkGeneratedCommandsInfoEXT::~safe_VkGeneratedCommandsInfoEXT() { FreePnextChain(pNext); } + +void safe_VkGeneratedCommandsInfoEXT::initialize(const VkGeneratedCommandsInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderStages = in_struct->shaderStages; + indirectExecutionSet = in_struct->indirectExecutionSet; + indirectCommandsLayout = in_struct->indirectCommandsLayout; + indirectAddress = in_struct->indirectAddress; + indirectAddressSize = in_struct->indirectAddressSize; + preprocessAddress = in_struct->preprocessAddress; + preprocessSize = in_struct->preprocessSize; + maxSequenceCount = in_struct->maxSequenceCount; + sequenceCountAddress = in_struct->sequenceCountAddress; + maxDrawCount = in_struct->maxDrawCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkGeneratedCommandsInfoEXT::initialize(const safe_VkGeneratedCommandsInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderStages = copy_src->shaderStages; + indirectExecutionSet = copy_src->indirectExecutionSet; + indirectCommandsLayout = copy_src->indirectCommandsLayout; + indirectAddress = copy_src->indirectAddress; + indirectAddressSize = copy_src->indirectAddressSize; + preprocessAddress = copy_src->preprocessAddress; + preprocessSize = copy_src->preprocessSize; + maxSequenceCount = copy_src->maxSequenceCount; + sequenceCountAddress = copy_src->sequenceCountAddress; + maxDrawCount = copy_src->maxDrawCount; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkWriteIndirectExecutionSetPipelineEXT::safe_VkWriteIndirectExecutionSetPipelineEXT( + const VkWriteIndirectExecutionSetPipelineEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), index(in_struct->index), pipeline(in_struct->pipeline) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkWriteIndirectExecutionSetPipelineEXT::safe_VkWriteIndirectExecutionSetPipelineEXT() + : sType(VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT), pNext(nullptr), index(), pipeline() {} + +safe_VkWriteIndirectExecutionSetPipelineEXT::safe_VkWriteIndirectExecutionSetPipelineEXT( + const safe_VkWriteIndirectExecutionSetPipelineEXT& copy_src) { + sType = copy_src.sType; + index = copy_src.index; + pipeline = copy_src.pipeline; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkWriteIndirectExecutionSetPipelineEXT& safe_VkWriteIndirectExecutionSetPipelineEXT::operator=( + const safe_VkWriteIndirectExecutionSetPipelineEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + index = copy_src.index; + pipeline = copy_src.pipeline; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkWriteIndirectExecutionSetPipelineEXT::~safe_VkWriteIndirectExecutionSetPipelineEXT() { FreePnextChain(pNext); } + +void safe_VkWriteIndirectExecutionSetPipelineEXT::initialize(const VkWriteIndirectExecutionSetPipelineEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + index = in_struct->index; + pipeline = in_struct->pipeline; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkWriteIndirectExecutionSetPipelineEXT::initialize(const safe_VkWriteIndirectExecutionSetPipelineEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + index = copy_src->index; + pipeline = copy_src->pipeline; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkIndirectCommandsTokenDataEXT::safe_VkIndirectCommandsTokenDataEXT(const VkIndirectCommandsTokenDataEXT* in_struct, + PNextCopyState*) { + initialize(in_struct); +} + +safe_VkIndirectCommandsTokenDataEXT::safe_VkIndirectCommandsTokenDataEXT() + : pPushConstant(nullptr), pVertexBuffer(nullptr), pIndexBuffer(nullptr), pExecutionSet(nullptr) {} + +safe_VkIndirectCommandsTokenDataEXT::safe_VkIndirectCommandsTokenDataEXT(const safe_VkIndirectCommandsTokenDataEXT& copy_src) { + pPushConstant = nullptr; + pVertexBuffer = nullptr; + pIndexBuffer = nullptr; + pExecutionSet = nullptr; + + if (copy_src.pPushConstant) { + pPushConstant = new VkIndirectCommandsPushConstantTokenEXT(*copy_src.pPushConstant); + } + + if (copy_src.pVertexBuffer) { + pVertexBuffer = new VkIndirectCommandsVertexBufferTokenEXT(*copy_src.pVertexBuffer); + } + + if (copy_src.pIndexBuffer) { + pIndexBuffer = new VkIndirectCommandsIndexBufferTokenEXT(*copy_src.pIndexBuffer); + } + + if (copy_src.pExecutionSet) { + pExecutionSet = new VkIndirectCommandsExecutionSetTokenEXT(*copy_src.pExecutionSet); + } +} + +safe_VkIndirectCommandsTokenDataEXT& safe_VkIndirectCommandsTokenDataEXT::operator=( + const safe_VkIndirectCommandsTokenDataEXT& copy_src) { + if (©_src == this) return *this; + + if (pPushConstant) delete pPushConstant; + if (pVertexBuffer) delete pVertexBuffer; + if (pIndexBuffer) delete pIndexBuffer; + if (pExecutionSet) delete pExecutionSet; + + pPushConstant = nullptr; + pVertexBuffer = nullptr; + pIndexBuffer = nullptr; + pExecutionSet = nullptr; + + if (copy_src.pPushConstant) { + pPushConstant = new VkIndirectCommandsPushConstantTokenEXT(*copy_src.pPushConstant); + } + + if (copy_src.pVertexBuffer) { + pVertexBuffer = new VkIndirectCommandsVertexBufferTokenEXT(*copy_src.pVertexBuffer); + } + + if (copy_src.pIndexBuffer) { + pIndexBuffer = new VkIndirectCommandsIndexBufferTokenEXT(*copy_src.pIndexBuffer); + } + + if (copy_src.pExecutionSet) { + pExecutionSet = new VkIndirectCommandsExecutionSetTokenEXT(*copy_src.pExecutionSet); + } + + return *this; +} + +safe_VkIndirectCommandsTokenDataEXT::~safe_VkIndirectCommandsTokenDataEXT() { + if (pPushConstant) delete pPushConstant; + if (pVertexBuffer) delete pVertexBuffer; + if (pIndexBuffer) delete pIndexBuffer; + if (pExecutionSet) delete pExecutionSet; +} + +void safe_VkIndirectCommandsTokenDataEXT::initialize(const VkIndirectCommandsTokenDataEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPushConstant) delete pPushConstant; + if (pVertexBuffer) delete pVertexBuffer; + if (pIndexBuffer) delete pIndexBuffer; + if (pExecutionSet) delete pExecutionSet; + pPushConstant = nullptr; + pVertexBuffer = nullptr; + pIndexBuffer = nullptr; + pExecutionSet = nullptr; + + if (in_struct->pPushConstant) { + pPushConstant = new VkIndirectCommandsPushConstantTokenEXT(*in_struct->pPushConstant); + } + + if (in_struct->pVertexBuffer) { + pVertexBuffer = new VkIndirectCommandsVertexBufferTokenEXT(*in_struct->pVertexBuffer); + } + + if (in_struct->pIndexBuffer) { + pIndexBuffer = new VkIndirectCommandsIndexBufferTokenEXT(*in_struct->pIndexBuffer); + } + + if (in_struct->pExecutionSet) { + pExecutionSet = new VkIndirectCommandsExecutionSetTokenEXT(*in_struct->pExecutionSet); + } +} + +void safe_VkIndirectCommandsTokenDataEXT::initialize(const safe_VkIndirectCommandsTokenDataEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + pPushConstant = nullptr; + pVertexBuffer = nullptr; + pIndexBuffer = nullptr; + pExecutionSet = nullptr; + + if (copy_src->pPushConstant) { + pPushConstant = new VkIndirectCommandsPushConstantTokenEXT(*copy_src->pPushConstant); + } + + if (copy_src->pVertexBuffer) { + pVertexBuffer = new VkIndirectCommandsVertexBufferTokenEXT(*copy_src->pVertexBuffer); + } + + if (copy_src->pIndexBuffer) { + pIndexBuffer = new VkIndirectCommandsIndexBufferTokenEXT(*copy_src->pIndexBuffer); + } + + if (copy_src->pExecutionSet) { + pExecutionSet = new VkIndirectCommandsExecutionSetTokenEXT(*copy_src->pExecutionSet); + } +} + +safe_VkIndirectCommandsLayoutTokenEXT::safe_VkIndirectCommandsLayoutTokenEXT(const VkIndirectCommandsLayoutTokenEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), type(in_struct->type), data(&in_struct->data), offset(in_struct->offset) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkIndirectCommandsLayoutTokenEXT::safe_VkIndirectCommandsLayoutTokenEXT() + : sType(VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT), pNext(nullptr), type(), offset() {} + +safe_VkIndirectCommandsLayoutTokenEXT::safe_VkIndirectCommandsLayoutTokenEXT( + const safe_VkIndirectCommandsLayoutTokenEXT& copy_src) { + sType = copy_src.sType; + type = copy_src.type; + data.initialize(©_src.data); + offset = copy_src.offset; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkIndirectCommandsLayoutTokenEXT& safe_VkIndirectCommandsLayoutTokenEXT::operator=( + const safe_VkIndirectCommandsLayoutTokenEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + type = copy_src.type; + data.initialize(©_src.data); + offset = copy_src.offset; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkIndirectCommandsLayoutTokenEXT::~safe_VkIndirectCommandsLayoutTokenEXT() { FreePnextChain(pNext); } + +void safe_VkIndirectCommandsLayoutTokenEXT::initialize(const VkIndirectCommandsLayoutTokenEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + type = in_struct->type; + data.initialize(&in_struct->data); + offset = in_struct->offset; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkIndirectCommandsLayoutTokenEXT::initialize(const safe_VkIndirectCommandsLayoutTokenEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + type = copy_src->type; + data.initialize(©_src->data); + offset = copy_src->offset; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkIndirectCommandsLayoutCreateInfoEXT::safe_VkIndirectCommandsLayoutCreateInfoEXT( + const VkIndirectCommandsLayoutCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + shaderStages(in_struct->shaderStages), + indirectStride(in_struct->indirectStride), + pipelineLayout(in_struct->pipelineLayout), + tokenCount(in_struct->tokenCount), + pTokens(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (tokenCount && in_struct->pTokens) { + pTokens = new safe_VkIndirectCommandsLayoutTokenEXT[tokenCount]; + for (uint32_t i = 0; i < tokenCount; ++i) { + pTokens[i].initialize(&in_struct->pTokens[i]); + } + } +} + +safe_VkIndirectCommandsLayoutCreateInfoEXT::safe_VkIndirectCommandsLayoutCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT), + pNext(nullptr), + flags(), + shaderStages(), + indirectStride(), + pipelineLayout(), + tokenCount(), + pTokens(nullptr) {} + +safe_VkIndirectCommandsLayoutCreateInfoEXT::safe_VkIndirectCommandsLayoutCreateInfoEXT( + const safe_VkIndirectCommandsLayoutCreateInfoEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + shaderStages = copy_src.shaderStages; + indirectStride = copy_src.indirectStride; + pipelineLayout = copy_src.pipelineLayout; + tokenCount = copy_src.tokenCount; + pTokens = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (tokenCount && copy_src.pTokens) { + pTokens = new safe_VkIndirectCommandsLayoutTokenEXT[tokenCount]; + for (uint32_t i = 0; i < tokenCount; ++i) { + pTokens[i].initialize(©_src.pTokens[i]); + } + } +} + +safe_VkIndirectCommandsLayoutCreateInfoEXT& safe_VkIndirectCommandsLayoutCreateInfoEXT::operator=( + const safe_VkIndirectCommandsLayoutCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pTokens) delete[] pTokens; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + shaderStages = copy_src.shaderStages; + indirectStride = copy_src.indirectStride; + pipelineLayout = copy_src.pipelineLayout; + tokenCount = copy_src.tokenCount; + pTokens = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (tokenCount && copy_src.pTokens) { + pTokens = new safe_VkIndirectCommandsLayoutTokenEXT[tokenCount]; + for (uint32_t i = 0; i < tokenCount; ++i) { + pTokens[i].initialize(©_src.pTokens[i]); + } + } + + return *this; +} + +safe_VkIndirectCommandsLayoutCreateInfoEXT::~safe_VkIndirectCommandsLayoutCreateInfoEXT() { + if (pTokens) delete[] pTokens; + FreePnextChain(pNext); +} + +void safe_VkIndirectCommandsLayoutCreateInfoEXT::initialize(const VkIndirectCommandsLayoutCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pTokens) delete[] pTokens; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + shaderStages = in_struct->shaderStages; + indirectStride = in_struct->indirectStride; + pipelineLayout = in_struct->pipelineLayout; + tokenCount = in_struct->tokenCount; + pTokens = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (tokenCount && in_struct->pTokens) { + pTokens = new safe_VkIndirectCommandsLayoutTokenEXT[tokenCount]; + for (uint32_t i = 0; i < tokenCount; ++i) { + pTokens[i].initialize(&in_struct->pTokens[i]); + } + } +} + +void safe_VkIndirectCommandsLayoutCreateInfoEXT::initialize(const safe_VkIndirectCommandsLayoutCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + shaderStages = copy_src->shaderStages; + indirectStride = copy_src->indirectStride; + pipelineLayout = copy_src->pipelineLayout; + tokenCount = copy_src->tokenCount; + pTokens = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (tokenCount && copy_src->pTokens) { + pTokens = new safe_VkIndirectCommandsLayoutTokenEXT[tokenCount]; + for (uint32_t i = 0; i < tokenCount; ++i) { + pTokens[i].initialize(©_src->pTokens[i]); + } + } +} + +safe_VkGeneratedCommandsPipelineInfoEXT::safe_VkGeneratedCommandsPipelineInfoEXT( + const VkGeneratedCommandsPipelineInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pipeline(in_struct->pipeline) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkGeneratedCommandsPipelineInfoEXT::safe_VkGeneratedCommandsPipelineInfoEXT() + : sType(VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT), pNext(nullptr), pipeline() {} + +safe_VkGeneratedCommandsPipelineInfoEXT::safe_VkGeneratedCommandsPipelineInfoEXT( + const safe_VkGeneratedCommandsPipelineInfoEXT& copy_src) { + sType = copy_src.sType; + pipeline = copy_src.pipeline; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkGeneratedCommandsPipelineInfoEXT& safe_VkGeneratedCommandsPipelineInfoEXT::operator=( + const safe_VkGeneratedCommandsPipelineInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pipeline = copy_src.pipeline; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkGeneratedCommandsPipelineInfoEXT::~safe_VkGeneratedCommandsPipelineInfoEXT() { FreePnextChain(pNext); } + +void safe_VkGeneratedCommandsPipelineInfoEXT::initialize(const VkGeneratedCommandsPipelineInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pipeline = in_struct->pipeline; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkGeneratedCommandsPipelineInfoEXT::initialize(const safe_VkGeneratedCommandsPipelineInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipeline = copy_src->pipeline; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkGeneratedCommandsShaderInfoEXT::safe_VkGeneratedCommandsShaderInfoEXT(const VkGeneratedCommandsShaderInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), shaderCount(in_struct->shaderCount), pShaders(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (shaderCount && in_struct->pShaders) { + pShaders = new VkShaderEXT[shaderCount]; + for (uint32_t i = 0; i < shaderCount; ++i) { + pShaders[i] = in_struct->pShaders[i]; + } + } +} + +safe_VkGeneratedCommandsShaderInfoEXT::safe_VkGeneratedCommandsShaderInfoEXT() + : sType(VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT), pNext(nullptr), shaderCount(), pShaders(nullptr) {} + +safe_VkGeneratedCommandsShaderInfoEXT::safe_VkGeneratedCommandsShaderInfoEXT( + const safe_VkGeneratedCommandsShaderInfoEXT& copy_src) { + sType = copy_src.sType; + shaderCount = copy_src.shaderCount; + pShaders = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (shaderCount && copy_src.pShaders) { + pShaders = new VkShaderEXT[shaderCount]; + for (uint32_t i = 0; i < shaderCount; ++i) { + pShaders[i] = copy_src.pShaders[i]; + } + } +} + +safe_VkGeneratedCommandsShaderInfoEXT& safe_VkGeneratedCommandsShaderInfoEXT::operator=( + const safe_VkGeneratedCommandsShaderInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pShaders) delete[] pShaders; + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderCount = copy_src.shaderCount; + pShaders = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (shaderCount && copy_src.pShaders) { + pShaders = new VkShaderEXT[shaderCount]; + for (uint32_t i = 0; i < shaderCount; ++i) { + pShaders[i] = copy_src.pShaders[i]; + } + } + + return *this; +} + +safe_VkGeneratedCommandsShaderInfoEXT::~safe_VkGeneratedCommandsShaderInfoEXT() { + if (pShaders) delete[] pShaders; + FreePnextChain(pNext); +} + +void safe_VkGeneratedCommandsShaderInfoEXT::initialize(const VkGeneratedCommandsShaderInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pShaders) delete[] pShaders; + FreePnextChain(pNext); + sType = in_struct->sType; + shaderCount = in_struct->shaderCount; + pShaders = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (shaderCount && in_struct->pShaders) { + pShaders = new VkShaderEXT[shaderCount]; + for (uint32_t i = 0; i < shaderCount; ++i) { + pShaders[i] = in_struct->pShaders[i]; + } + } +} + +void safe_VkGeneratedCommandsShaderInfoEXT::initialize(const safe_VkGeneratedCommandsShaderInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderCount = copy_src->shaderCount; + pShaders = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (shaderCount && copy_src->pShaders) { + pShaders = new VkShaderEXT[shaderCount]; + for (uint32_t i = 0; i < shaderCount; ++i) { + pShaders[i] = copy_src->pShaders[i]; + } + } +} + +safe_VkWriteIndirectExecutionSetShaderEXT::safe_VkWriteIndirectExecutionSetShaderEXT( + const VkWriteIndirectExecutionSetShaderEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), index(in_struct->index), shader(in_struct->shader) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkWriteIndirectExecutionSetShaderEXT::safe_VkWriteIndirectExecutionSetShaderEXT() + : sType(VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT), pNext(nullptr), index(), shader() {} + +safe_VkWriteIndirectExecutionSetShaderEXT::safe_VkWriteIndirectExecutionSetShaderEXT( + const safe_VkWriteIndirectExecutionSetShaderEXT& copy_src) { + sType = copy_src.sType; + index = copy_src.index; + shader = copy_src.shader; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkWriteIndirectExecutionSetShaderEXT& safe_VkWriteIndirectExecutionSetShaderEXT::operator=( + const safe_VkWriteIndirectExecutionSetShaderEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + index = copy_src.index; + shader = copy_src.shader; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkWriteIndirectExecutionSetShaderEXT::~safe_VkWriteIndirectExecutionSetShaderEXT() { FreePnextChain(pNext); } + +void safe_VkWriteIndirectExecutionSetShaderEXT::initialize(const VkWriteIndirectExecutionSetShaderEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + index = in_struct->index; + shader = in_struct->shader; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkWriteIndirectExecutionSetShaderEXT::initialize(const safe_VkWriteIndirectExecutionSetShaderEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + index = copy_src->index; + shader = copy_src->shader; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDepthClampControlFeaturesEXT::safe_VkPhysicalDeviceDepthClampControlFeaturesEXT( + const VkPhysicalDeviceDepthClampControlFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), depthClampControl(in_struct->depthClampControl) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDepthClampControlFeaturesEXT::safe_VkPhysicalDeviceDepthClampControlFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT), pNext(nullptr), depthClampControl() {} + +safe_VkPhysicalDeviceDepthClampControlFeaturesEXT::safe_VkPhysicalDeviceDepthClampControlFeaturesEXT( + const safe_VkPhysicalDeviceDepthClampControlFeaturesEXT& copy_src) { + sType = copy_src.sType; + depthClampControl = copy_src.depthClampControl; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDepthClampControlFeaturesEXT& safe_VkPhysicalDeviceDepthClampControlFeaturesEXT::operator=( + const safe_VkPhysicalDeviceDepthClampControlFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + depthClampControl = copy_src.depthClampControl; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDepthClampControlFeaturesEXT::~safe_VkPhysicalDeviceDepthClampControlFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceDepthClampControlFeaturesEXT::initialize(const VkPhysicalDeviceDepthClampControlFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + depthClampControl = in_struct->depthClampControl; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDepthClampControlFeaturesEXT::initialize( + const safe_VkPhysicalDeviceDepthClampControlFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + depthClampControl = copy_src->depthClampControl; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineViewportDepthClampControlCreateInfoEXT::safe_VkPipelineViewportDepthClampControlCreateInfoEXT( + const VkPipelineViewportDepthClampControlCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), depthClampMode(in_struct->depthClampMode), pDepthClampRange(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pDepthClampRange) { + pDepthClampRange = new VkDepthClampRangeEXT(*in_struct->pDepthClampRange); + } +} + +safe_VkPipelineViewportDepthClampControlCreateInfoEXT::safe_VkPipelineViewportDepthClampControlCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT), + pNext(nullptr), + depthClampMode(), + pDepthClampRange(nullptr) {} + +safe_VkPipelineViewportDepthClampControlCreateInfoEXT::safe_VkPipelineViewportDepthClampControlCreateInfoEXT( + const safe_VkPipelineViewportDepthClampControlCreateInfoEXT& copy_src) { + sType = copy_src.sType; + depthClampMode = copy_src.depthClampMode; + pDepthClampRange = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDepthClampRange) { + pDepthClampRange = new VkDepthClampRangeEXT(*copy_src.pDepthClampRange); + } +} + +safe_VkPipelineViewportDepthClampControlCreateInfoEXT& safe_VkPipelineViewportDepthClampControlCreateInfoEXT::operator=( + const safe_VkPipelineViewportDepthClampControlCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pDepthClampRange) delete pDepthClampRange; + FreePnextChain(pNext); + + sType = copy_src.sType; + depthClampMode = copy_src.depthClampMode; + pDepthClampRange = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDepthClampRange) { + pDepthClampRange = new VkDepthClampRangeEXT(*copy_src.pDepthClampRange); + } + + return *this; +} + +safe_VkPipelineViewportDepthClampControlCreateInfoEXT::~safe_VkPipelineViewportDepthClampControlCreateInfoEXT() { + if (pDepthClampRange) delete pDepthClampRange; + FreePnextChain(pNext); +} + +void safe_VkPipelineViewportDepthClampControlCreateInfoEXT::initialize( + const VkPipelineViewportDepthClampControlCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pDepthClampRange) delete pDepthClampRange; + FreePnextChain(pNext); + sType = in_struct->sType; + depthClampMode = in_struct->depthClampMode; + pDepthClampRange = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pDepthClampRange) { + pDepthClampRange = new VkDepthClampRangeEXT(*in_struct->pDepthClampRange); + } +} + +void safe_VkPipelineViewportDepthClampControlCreateInfoEXT::initialize( + const safe_VkPipelineViewportDepthClampControlCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + depthClampMode = copy_src->depthClampMode; + pDepthClampRange = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pDepthClampRange) { + pDepthClampRange = new VkDepthClampRangeEXT(*copy_src->pDepthClampRange); + } +} + safe_VkPhysicalDeviceMeshShaderFeaturesEXT::safe_VkPhysicalDeviceMeshShaderFeaturesEXT( const VkPhysicalDeviceMeshShaderFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp index 3550dba..36e5749 100644 --- a/src/vulkan/vk_safe_struct_utils.cpp +++ b/src/vulkan/vk_safe_struct_utils.cpp @@ -1840,6 +1840,18 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: safe_pNext = new safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: + safe_pNext = new safe_VkGeneratedCommandsPipelineInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: + safe_pNext = new safe_VkGeneratedCommandsShaderInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: safe_pNext = new safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(reinterpret_cast(pNext), copy_state, false); break; @@ -1849,6 +1861,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: safe_pNext = new safe_VkImageAlignmentControlCreateInfoMESA(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceDepthClampControlFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: + safe_pNext = new safe_VkPipelineViewportDepthClampControlCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -3705,6 +3723,18 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: delete reinterpret_cast(header); break; @@ -3714,6 +3744,12 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: delete reinterpret_cast(header); break;