From 70a77836691da6276b73c8380655ef57fcfb06bd Mon Sep 17 00:00:00 2001 From: Mike Schuchardt Date: Mon, 2 Dec 2024 08:31:27 -0800 Subject: [PATCH] build: Update to header 1.4.303 --- include/vulkan/utility/vk_dispatch_table.h | 38 + include/vulkan/utility/vk_format_utils.h | 12 +- include/vulkan/utility/vk_safe_struct.hpp | 2066 +++---- include/vulkan/utility/vk_struct_helper.hpp | 98 +- include/vulkan/vk_enum_string_helper.h | 680 +-- scripts/generators/safe_struct_generator.py | 6 +- scripts/known_good.json | 2 +- src/vulkan/vk_safe_struct_core.cpp | 3814 ++++++++++++ src/vulkan/vk_safe_struct_ext.cpp | 1430 +---- src/vulkan/vk_safe_struct_khr.cpp | 5814 ++++++------------- src/vulkan/vk_safe_struct_utils.cpp | 396 +- 11 files changed, 7432 insertions(+), 6924 deletions(-) diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h index dcd4f4b..d8f80c4 100644 --- a/include/vulkan/utility/vk_dispatch_table.h +++ b/include/vulkan/utility/vk_dispatch_table.h @@ -352,6 +352,25 @@ typedef struct VkuDeviceDispatchTable_ { PFN_vkGetDeviceBufferMemoryRequirements GetDeviceBufferMemoryRequirements; PFN_vkGetDeviceImageMemoryRequirements GetDeviceImageMemoryRequirements; PFN_vkGetDeviceImageSparseMemoryRequirements GetDeviceImageSparseMemoryRequirements; + PFN_vkCmdSetLineStipple CmdSetLineStipple; + PFN_vkMapMemory2 MapMemory2; + PFN_vkUnmapMemory2 UnmapMemory2; + PFN_vkCmdBindIndexBuffer2 CmdBindIndexBuffer2; + PFN_vkGetRenderingAreaGranularity GetRenderingAreaGranularity; + PFN_vkGetDeviceImageSubresourceLayout GetDeviceImageSubresourceLayout; + PFN_vkGetImageSubresourceLayout2 GetImageSubresourceLayout2; + PFN_vkCmdPushDescriptorSet CmdPushDescriptorSet; + PFN_vkCmdPushDescriptorSetWithTemplate CmdPushDescriptorSetWithTemplate; + PFN_vkCmdSetRenderingAttachmentLocations CmdSetRenderingAttachmentLocations; + PFN_vkCmdSetRenderingInputAttachmentIndices CmdSetRenderingInputAttachmentIndices; + PFN_vkCmdBindDescriptorSets2 CmdBindDescriptorSets2; + PFN_vkCmdPushConstants2 CmdPushConstants2; + PFN_vkCmdPushDescriptorSet2 CmdPushDescriptorSet2; + PFN_vkCmdPushDescriptorSetWithTemplate2 CmdPushDescriptorSetWithTemplate2; + PFN_vkCopyMemoryToImage CopyMemoryToImage; + PFN_vkCopyImageToMemory CopyImageToMemory; + PFN_vkCopyImageToImage CopyImageToImage; + PFN_vkTransitionImageLayout TransitionImageLayout; PFN_vkCreateSwapchainKHR CreateSwapchainKHR; PFN_vkDestroySwapchainKHR DestroySwapchainKHR; PFN_vkGetSwapchainImagesKHR GetSwapchainImagesKHR; @@ -965,6 +984,25 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch table->GetDeviceBufferMemoryRequirements = (PFN_vkGetDeviceBufferMemoryRequirements)gdpa(device, "vkGetDeviceBufferMemoryRequirements"); table->GetDeviceImageMemoryRequirements = (PFN_vkGetDeviceImageMemoryRequirements)gdpa(device, "vkGetDeviceImageMemoryRequirements"); table->GetDeviceImageSparseMemoryRequirements = (PFN_vkGetDeviceImageSparseMemoryRequirements)gdpa(device, "vkGetDeviceImageSparseMemoryRequirements"); + table->CmdSetLineStipple = (PFN_vkCmdSetLineStipple)gdpa(device, "vkCmdSetLineStipple"); + table->MapMemory2 = (PFN_vkMapMemory2)gdpa(device, "vkMapMemory2"); + table->UnmapMemory2 = (PFN_vkUnmapMemory2)gdpa(device, "vkUnmapMemory2"); + table->CmdBindIndexBuffer2 = (PFN_vkCmdBindIndexBuffer2)gdpa(device, "vkCmdBindIndexBuffer2"); + table->GetRenderingAreaGranularity = (PFN_vkGetRenderingAreaGranularity)gdpa(device, "vkGetRenderingAreaGranularity"); + table->GetDeviceImageSubresourceLayout = (PFN_vkGetDeviceImageSubresourceLayout)gdpa(device, "vkGetDeviceImageSubresourceLayout"); + table->GetImageSubresourceLayout2 = (PFN_vkGetImageSubresourceLayout2)gdpa(device, "vkGetImageSubresourceLayout2"); + table->CmdPushDescriptorSet = (PFN_vkCmdPushDescriptorSet)gdpa(device, "vkCmdPushDescriptorSet"); + table->CmdPushDescriptorSetWithTemplate = (PFN_vkCmdPushDescriptorSetWithTemplate)gdpa(device, "vkCmdPushDescriptorSetWithTemplate"); + table->CmdSetRenderingAttachmentLocations = (PFN_vkCmdSetRenderingAttachmentLocations)gdpa(device, "vkCmdSetRenderingAttachmentLocations"); + table->CmdSetRenderingInputAttachmentIndices = (PFN_vkCmdSetRenderingInputAttachmentIndices)gdpa(device, "vkCmdSetRenderingInputAttachmentIndices"); + table->CmdBindDescriptorSets2 = (PFN_vkCmdBindDescriptorSets2)gdpa(device, "vkCmdBindDescriptorSets2"); + table->CmdPushConstants2 = (PFN_vkCmdPushConstants2)gdpa(device, "vkCmdPushConstants2"); + table->CmdPushDescriptorSet2 = (PFN_vkCmdPushDescriptorSet2)gdpa(device, "vkCmdPushDescriptorSet2"); + table->CmdPushDescriptorSetWithTemplate2 = (PFN_vkCmdPushDescriptorSetWithTemplate2)gdpa(device, "vkCmdPushDescriptorSetWithTemplate2"); + table->CopyMemoryToImage = (PFN_vkCopyMemoryToImage)gdpa(device, "vkCopyMemoryToImage"); + table->CopyImageToMemory = (PFN_vkCopyImageToMemory)gdpa(device, "vkCopyImageToMemory"); + table->CopyImageToImage = (PFN_vkCopyImageToImage)gdpa(device, "vkCopyImageToImage"); + table->TransitionImageLayout = (PFN_vkTransitionImageLayout)gdpa(device, "vkTransitionImageLayout"); table->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR)gdpa(device, "vkCreateSwapchainKHR"); table->DestroySwapchainKHR = (PFN_vkDestroySwapchainKHR)gdpa(device, "vkDestroySwapchainKHR"); table->GetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR)gdpa(device, "vkGetSwapchainImagesKHR"); diff --git a/include/vulkan/utility/vk_format_utils.h b/include/vulkan/utility/vk_format_utils.h index 1b0ea3f..862f8e1 100644 --- a/include/vulkan/utility/vk_format_utils.h +++ b/include/vulkan/utility/vk_format_utils.h @@ -381,10 +381,10 @@ inline const struct VKU_FORMAT_INFO vkuGetFormatInfo(VkFormat format) { case VK_FORMAT_A1R5G5B5_UNORM_PACK16: { struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 1}, {VKU_FORMAT_COMPONENT_TYPE_R, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 5}, {VKU_FORMAT_COMPONENT_TYPE_B, 5}}}; return out; } - case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR: { + case VK_FORMAT_A1B5G5R5_UNORM_PACK16: { struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 1}, {VKU_FORMAT_COMPONENT_TYPE_B, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 5}, {VKU_FORMAT_COMPONENT_TYPE_R, 5}}}; return out; } - case VK_FORMAT_A8_UNORM_KHR: { + case VK_FORMAT_A8_UNORM: { struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_ALPHA, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}}}; return out; } case VK_FORMAT_R8_UNORM: { @@ -1426,8 +1426,8 @@ bool vkuFormatIsUNORM(VkFormat format) { case VK_FORMAT_R5G5B5A1_UNORM_PACK16: case VK_FORMAT_B5G5R5A1_UNORM_PACK16: case VK_FORMAT_A1R5G5B5_UNORM_PACK16: - case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR: - case VK_FORMAT_A8_UNORM_KHR: + case VK_FORMAT_A1B5G5R5_UNORM_PACK16: + case VK_FORMAT_A8_UNORM: case VK_FORMAT_R8_UNORM: case VK_FORMAT_R8G8_UNORM: case VK_FORMAT_R8G8B8_UNORM: @@ -1811,7 +1811,7 @@ bool vkuFormatIsPacked(VkFormat format) { case VK_FORMAT_R5G5B5A1_UNORM_PACK16: case VK_FORMAT_B5G5R5A1_UNORM_PACK16: case VK_FORMAT_A1R5G5B5_UNORM_PACK16: - case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR: + case VK_FORMAT_A1B5G5R5_UNORM_PACK16: case VK_FORMAT_A8B8G8R8_UNORM_PACK32: case VK_FORMAT_A8B8G8R8_SNORM_PACK32: case VK_FORMAT_A8B8G8R8_USCALED_PACK32: @@ -2080,7 +2080,7 @@ inline double vkuFormatTexelSizeWithAspect(VkFormat format, VkImageAspectFlagBit inline bool vkuFormatIs8bit(VkFormat format) { switch (format) { - case VK_FORMAT_A8_UNORM_KHR: + case VK_FORMAT_A8_UNORM: case VK_FORMAT_R8_UNORM: case VK_FORMAT_R8_SNORM: case VK_FORMAT_R8_USCALED: diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp index 39f4ff4..69bc5c4 100644 --- a/include/vulkan/utility/vk_safe_struct.hpp +++ b/include/vulkan/utility/vk_safe_struct.hpp @@ -4546,6 +4546,1014 @@ struct safe_VkDeviceImageMemoryRequirements { VkDeviceImageMemoryRequirements* ptr() { return reinterpret_cast(this); } VkDeviceImageMemoryRequirements const* ptr() const { return reinterpret_cast(this); } }; +struct safe_VkPhysicalDeviceVulkan14Features { + VkStructureType sType; + void* pNext{}; + VkBool32 globalPriorityQuery; + VkBool32 shaderSubgroupRotate; + VkBool32 shaderSubgroupRotateClustered; + VkBool32 shaderFloatControls2; + VkBool32 shaderExpectAssume; + VkBool32 rectangularLines; + VkBool32 bresenhamLines; + VkBool32 smoothLines; + VkBool32 stippledRectangularLines; + VkBool32 stippledBresenhamLines; + VkBool32 stippledSmoothLines; + VkBool32 vertexAttributeInstanceRateDivisor; + VkBool32 vertexAttributeInstanceRateZeroDivisor; + VkBool32 indexTypeUint8; + VkBool32 dynamicRenderingLocalRead; + VkBool32 maintenance5; + VkBool32 maintenance6; + VkBool32 pipelineProtectedAccess; + VkBool32 pipelineRobustness; + VkBool32 hostImageCopy; + VkBool32 pushDescriptor; + + safe_VkPhysicalDeviceVulkan14Features(const VkPhysicalDeviceVulkan14Features* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceVulkan14Features(const safe_VkPhysicalDeviceVulkan14Features& copy_src); + safe_VkPhysicalDeviceVulkan14Features& operator=(const safe_VkPhysicalDeviceVulkan14Features& copy_src); + safe_VkPhysicalDeviceVulkan14Features(); + ~safe_VkPhysicalDeviceVulkan14Features(); + void initialize(const VkPhysicalDeviceVulkan14Features* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVulkan14Features* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVulkan14Features* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceVulkan14Features const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceVulkan14Properties { + VkStructureType sType; + void* pNext{}; + uint32_t lineSubPixelPrecisionBits; + uint32_t maxVertexAttribDivisor; + VkBool32 supportsNonZeroFirstInstance; + uint32_t maxPushDescriptors; + VkBool32 dynamicRenderingLocalReadDepthStencilAttachments; + VkBool32 dynamicRenderingLocalReadMultisampledAttachments; + VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting; + VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting; + VkBool32 depthStencilSwizzleOneSupport; + VkBool32 polygonModePointSize; + VkBool32 nonStrictSinglePixelWideLinesUseParallelogram; + VkBool32 nonStrictWideLinesUseParallelogram; + VkBool32 blockTexelViewCompatibleMultipleLayers; + uint32_t maxCombinedImageSamplerDescriptorCount; + VkBool32 fragmentShadingRateClampCombinerInputs; + VkPipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers; + VkPipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers; + VkPipelineRobustnessBufferBehavior defaultRobustnessVertexInputs; + VkPipelineRobustnessImageBehavior defaultRobustnessImages; + uint32_t copySrcLayoutCount; + VkImageLayout* pCopySrcLayouts{}; + uint32_t copyDstLayoutCount; + VkImageLayout* pCopyDstLayouts{}; + uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE]; + VkBool32 identicalMemoryTypeRequirements; + + safe_VkPhysicalDeviceVulkan14Properties(const VkPhysicalDeviceVulkan14Properties* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceVulkan14Properties(const safe_VkPhysicalDeviceVulkan14Properties& copy_src); + safe_VkPhysicalDeviceVulkan14Properties& operator=(const safe_VkPhysicalDeviceVulkan14Properties& copy_src); + safe_VkPhysicalDeviceVulkan14Properties(); + ~safe_VkPhysicalDeviceVulkan14Properties(); + void initialize(const VkPhysicalDeviceVulkan14Properties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVulkan14Properties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVulkan14Properties* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceVulkan14Properties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDeviceQueueGlobalPriorityCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkQueueGlobalPriority globalPriority; + + safe_VkDeviceQueueGlobalPriorityCreateInfo(const VkDeviceQueueGlobalPriorityCreateInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDeviceQueueGlobalPriorityCreateInfo(const safe_VkDeviceQueueGlobalPriorityCreateInfo& copy_src); + safe_VkDeviceQueueGlobalPriorityCreateInfo& operator=(const safe_VkDeviceQueueGlobalPriorityCreateInfo& copy_src); + safe_VkDeviceQueueGlobalPriorityCreateInfo(); + ~safe_VkDeviceQueueGlobalPriorityCreateInfo(); + void initialize(const VkDeviceQueueGlobalPriorityCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceQueueGlobalPriorityCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkDeviceQueueGlobalPriorityCreateInfo* ptr() { return reinterpret_cast(this); } + VkDeviceQueueGlobalPriorityCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceGlobalPriorityQueryFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 globalPriorityQuery; + + safe_VkPhysicalDeviceGlobalPriorityQueryFeatures(const VkPhysicalDeviceGlobalPriorityQueryFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceGlobalPriorityQueryFeatures(const safe_VkPhysicalDeviceGlobalPriorityQueryFeatures& copy_src); + safe_VkPhysicalDeviceGlobalPriorityQueryFeatures& operator=(const safe_VkPhysicalDeviceGlobalPriorityQueryFeatures& copy_src); + safe_VkPhysicalDeviceGlobalPriorityQueryFeatures(); + ~safe_VkPhysicalDeviceGlobalPriorityQueryFeatures(); + void initialize(const VkPhysicalDeviceGlobalPriorityQueryFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceGlobalPriorityQueryFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceGlobalPriorityQueryFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceGlobalPriorityQueryFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkQueueFamilyGlobalPriorityProperties { + VkStructureType sType; + void* pNext{}; + uint32_t priorityCount; + VkQueueGlobalPriority priorities[VK_MAX_GLOBAL_PRIORITY_SIZE]; + + safe_VkQueueFamilyGlobalPriorityProperties(const VkQueueFamilyGlobalPriorityProperties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkQueueFamilyGlobalPriorityProperties(const safe_VkQueueFamilyGlobalPriorityProperties& copy_src); + safe_VkQueueFamilyGlobalPriorityProperties& operator=(const safe_VkQueueFamilyGlobalPriorityProperties& copy_src); + safe_VkQueueFamilyGlobalPriorityProperties(); + ~safe_VkQueueFamilyGlobalPriorityProperties(); + void initialize(const VkQueueFamilyGlobalPriorityProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkQueueFamilyGlobalPriorityProperties* copy_src, PNextCopyState* copy_state = {}); + VkQueueFamilyGlobalPriorityProperties* ptr() { return reinterpret_cast(this); } + VkQueueFamilyGlobalPriorityProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderSubgroupRotateFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderSubgroupRotate; + VkBool32 shaderSubgroupRotateClustered; + + safe_VkPhysicalDeviceShaderSubgroupRotateFeatures(const VkPhysicalDeviceShaderSubgroupRotateFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderSubgroupRotateFeatures(const safe_VkPhysicalDeviceShaderSubgroupRotateFeatures& copy_src); + safe_VkPhysicalDeviceShaderSubgroupRotateFeatures& operator=(const safe_VkPhysicalDeviceShaderSubgroupRotateFeatures& copy_src); + safe_VkPhysicalDeviceShaderSubgroupRotateFeatures(); + ~safe_VkPhysicalDeviceShaderSubgroupRotateFeatures(); + void initialize(const VkPhysicalDeviceShaderSubgroupRotateFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderSubgroupRotateFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderSubgroupRotateFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderSubgroupRotateFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderFloatControls2Features { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderFloatControls2; + + safe_VkPhysicalDeviceShaderFloatControls2Features(const VkPhysicalDeviceShaderFloatControls2Features* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderFloatControls2Features(const safe_VkPhysicalDeviceShaderFloatControls2Features& copy_src); + safe_VkPhysicalDeviceShaderFloatControls2Features& operator=(const safe_VkPhysicalDeviceShaderFloatControls2Features& copy_src); + safe_VkPhysicalDeviceShaderFloatControls2Features(); + ~safe_VkPhysicalDeviceShaderFloatControls2Features(); + void initialize(const VkPhysicalDeviceShaderFloatControls2Features* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderFloatControls2Features* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderFloatControls2Features* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderFloatControls2Features const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderExpectAssumeFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderExpectAssume; + + safe_VkPhysicalDeviceShaderExpectAssumeFeatures(const VkPhysicalDeviceShaderExpectAssumeFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderExpectAssumeFeatures(const safe_VkPhysicalDeviceShaderExpectAssumeFeatures& copy_src); + safe_VkPhysicalDeviceShaderExpectAssumeFeatures& operator=(const safe_VkPhysicalDeviceShaderExpectAssumeFeatures& copy_src); + safe_VkPhysicalDeviceShaderExpectAssumeFeatures(); + ~safe_VkPhysicalDeviceShaderExpectAssumeFeatures(); + void initialize(const VkPhysicalDeviceShaderExpectAssumeFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderExpectAssumeFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderExpectAssumeFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderExpectAssumeFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceLineRasterizationFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 rectangularLines; + VkBool32 bresenhamLines; + VkBool32 smoothLines; + VkBool32 stippledRectangularLines; + VkBool32 stippledBresenhamLines; + VkBool32 stippledSmoothLines; + + safe_VkPhysicalDeviceLineRasterizationFeatures(const VkPhysicalDeviceLineRasterizationFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceLineRasterizationFeatures(const safe_VkPhysicalDeviceLineRasterizationFeatures& copy_src); + safe_VkPhysicalDeviceLineRasterizationFeatures& operator=(const safe_VkPhysicalDeviceLineRasterizationFeatures& copy_src); + safe_VkPhysicalDeviceLineRasterizationFeatures(); + ~safe_VkPhysicalDeviceLineRasterizationFeatures(); + void initialize(const VkPhysicalDeviceLineRasterizationFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceLineRasterizationFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceLineRasterizationFeatures* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceLineRasterizationFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceLineRasterizationProperties { + VkStructureType sType; + void* pNext{}; + uint32_t lineSubPixelPrecisionBits; + + safe_VkPhysicalDeviceLineRasterizationProperties(const VkPhysicalDeviceLineRasterizationProperties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceLineRasterizationProperties(const safe_VkPhysicalDeviceLineRasterizationProperties& copy_src); + safe_VkPhysicalDeviceLineRasterizationProperties& operator=(const safe_VkPhysicalDeviceLineRasterizationProperties& copy_src); + safe_VkPhysicalDeviceLineRasterizationProperties(); + ~safe_VkPhysicalDeviceLineRasterizationProperties(); + void initialize(const VkPhysicalDeviceLineRasterizationProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceLineRasterizationProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceLineRasterizationProperties* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceLineRasterizationProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineRasterizationLineStateCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkLineRasterizationMode lineRasterizationMode; + VkBool32 stippledLineEnable; + uint32_t lineStippleFactor; + uint16_t lineStipplePattern; + + safe_VkPipelineRasterizationLineStateCreateInfo(const VkPipelineRasterizationLineStateCreateInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineRasterizationLineStateCreateInfo(const safe_VkPipelineRasterizationLineStateCreateInfo& copy_src); + safe_VkPipelineRasterizationLineStateCreateInfo& operator=(const safe_VkPipelineRasterizationLineStateCreateInfo& copy_src); + safe_VkPipelineRasterizationLineStateCreateInfo(); + ~safe_VkPipelineRasterizationLineStateCreateInfo(); + void initialize(const VkPipelineRasterizationLineStateCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineRasterizationLineStateCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineRasterizationLineStateCreateInfo* ptr() { + return reinterpret_cast(this); + } + VkPipelineRasterizationLineStateCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceVertexAttributeDivisorProperties { + VkStructureType sType; + void* pNext{}; + uint32_t maxVertexAttribDivisor; + VkBool32 supportsNonZeroFirstInstance; + + safe_VkPhysicalDeviceVertexAttributeDivisorProperties(const VkPhysicalDeviceVertexAttributeDivisorProperties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceVertexAttributeDivisorProperties(const safe_VkPhysicalDeviceVertexAttributeDivisorProperties& copy_src); + safe_VkPhysicalDeviceVertexAttributeDivisorProperties& operator=( + const safe_VkPhysicalDeviceVertexAttributeDivisorProperties& copy_src); + safe_VkPhysicalDeviceVertexAttributeDivisorProperties(); + ~safe_VkPhysicalDeviceVertexAttributeDivisorProperties(); + void initialize(const VkPhysicalDeviceVertexAttributeDivisorProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVertexAttributeDivisorProperties* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceVertexAttributeDivisorProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineVertexInputDivisorStateCreateInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t vertexBindingDivisorCount; + const VkVertexInputBindingDivisorDescription* pVertexBindingDivisors{}; + + safe_VkPipelineVertexInputDivisorStateCreateInfo(const VkPipelineVertexInputDivisorStateCreateInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineVertexInputDivisorStateCreateInfo(const safe_VkPipelineVertexInputDivisorStateCreateInfo& copy_src); + safe_VkPipelineVertexInputDivisorStateCreateInfo& operator=(const safe_VkPipelineVertexInputDivisorStateCreateInfo& copy_src); + safe_VkPipelineVertexInputDivisorStateCreateInfo(); + ~safe_VkPipelineVertexInputDivisorStateCreateInfo(); + void initialize(const VkPipelineVertexInputDivisorStateCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineVertexInputDivisorStateCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineVertexInputDivisorStateCreateInfo* ptr() { + return reinterpret_cast(this); + } + VkPipelineVertexInputDivisorStateCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceVertexAttributeDivisorFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 vertexAttributeInstanceRateDivisor; + VkBool32 vertexAttributeInstanceRateZeroDivisor; + + safe_VkPhysicalDeviceVertexAttributeDivisorFeatures(const VkPhysicalDeviceVertexAttributeDivisorFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceVertexAttributeDivisorFeatures(const safe_VkPhysicalDeviceVertexAttributeDivisorFeatures& copy_src); + safe_VkPhysicalDeviceVertexAttributeDivisorFeatures& operator=( + const safe_VkPhysicalDeviceVertexAttributeDivisorFeatures& copy_src); + safe_VkPhysicalDeviceVertexAttributeDivisorFeatures(); + ~safe_VkPhysicalDeviceVertexAttributeDivisorFeatures(); + void initialize(const VkPhysicalDeviceVertexAttributeDivisorFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVertexAttributeDivisorFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceVertexAttributeDivisorFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceIndexTypeUint8Features { + VkStructureType sType; + void* pNext{}; + VkBool32 indexTypeUint8; + + safe_VkPhysicalDeviceIndexTypeUint8Features(const VkPhysicalDeviceIndexTypeUint8Features* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceIndexTypeUint8Features(const safe_VkPhysicalDeviceIndexTypeUint8Features& copy_src); + safe_VkPhysicalDeviceIndexTypeUint8Features& operator=(const safe_VkPhysicalDeviceIndexTypeUint8Features& copy_src); + safe_VkPhysicalDeviceIndexTypeUint8Features(); + ~safe_VkPhysicalDeviceIndexTypeUint8Features(); + void initialize(const VkPhysicalDeviceIndexTypeUint8Features* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceIndexTypeUint8Features* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceIndexTypeUint8Features* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceIndexTypeUint8Features const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkMemoryMapInfo { + VkStructureType sType; + const void* pNext{}; + VkMemoryMapFlags flags; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; + + safe_VkMemoryMapInfo(const VkMemoryMapInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMemoryMapInfo(const safe_VkMemoryMapInfo& copy_src); + safe_VkMemoryMapInfo& operator=(const safe_VkMemoryMapInfo& copy_src); + safe_VkMemoryMapInfo(); + ~safe_VkMemoryMapInfo(); + void initialize(const VkMemoryMapInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryMapInfo* copy_src, PNextCopyState* copy_state = {}); + VkMemoryMapInfo* ptr() { return reinterpret_cast(this); } + VkMemoryMapInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkMemoryUnmapInfo { + VkStructureType sType; + const void* pNext{}; + VkMemoryUnmapFlags flags; + VkDeviceMemory memory; + + safe_VkMemoryUnmapInfo(const VkMemoryUnmapInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMemoryUnmapInfo(const safe_VkMemoryUnmapInfo& copy_src); + safe_VkMemoryUnmapInfo& operator=(const safe_VkMemoryUnmapInfo& copy_src); + safe_VkMemoryUnmapInfo(); + ~safe_VkMemoryUnmapInfo(); + void initialize(const VkMemoryUnmapInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryUnmapInfo* copy_src, PNextCopyState* copy_state = {}); + VkMemoryUnmapInfo* ptr() { return reinterpret_cast(this); } + VkMemoryUnmapInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceMaintenance5Features { + VkStructureType sType; + void* pNext{}; + VkBool32 maintenance5; + + safe_VkPhysicalDeviceMaintenance5Features(const VkPhysicalDeviceMaintenance5Features* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMaintenance5Features(const safe_VkPhysicalDeviceMaintenance5Features& copy_src); + safe_VkPhysicalDeviceMaintenance5Features& operator=(const safe_VkPhysicalDeviceMaintenance5Features& copy_src); + safe_VkPhysicalDeviceMaintenance5Features(); + ~safe_VkPhysicalDeviceMaintenance5Features(); + void initialize(const VkPhysicalDeviceMaintenance5Features* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMaintenance5Features* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMaintenance5Features* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMaintenance5Features const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMaintenance5Properties { + VkStructureType sType; + void* pNext{}; + VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting; + VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting; + VkBool32 depthStencilSwizzleOneSupport; + VkBool32 polygonModePointSize; + VkBool32 nonStrictSinglePixelWideLinesUseParallelogram; + VkBool32 nonStrictWideLinesUseParallelogram; + + safe_VkPhysicalDeviceMaintenance5Properties(const VkPhysicalDeviceMaintenance5Properties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMaintenance5Properties(const safe_VkPhysicalDeviceMaintenance5Properties& copy_src); + safe_VkPhysicalDeviceMaintenance5Properties& operator=(const safe_VkPhysicalDeviceMaintenance5Properties& copy_src); + safe_VkPhysicalDeviceMaintenance5Properties(); + ~safe_VkPhysicalDeviceMaintenance5Properties(); + void initialize(const VkPhysicalDeviceMaintenance5Properties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMaintenance5Properties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMaintenance5Properties* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMaintenance5Properties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRenderingAreaInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t viewMask; + uint32_t colorAttachmentCount; + const VkFormat* pColorAttachmentFormats{}; + VkFormat depthAttachmentFormat; + VkFormat stencilAttachmentFormat; + + safe_VkRenderingAreaInfo(const VkRenderingAreaInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkRenderingAreaInfo(const safe_VkRenderingAreaInfo& copy_src); + safe_VkRenderingAreaInfo& operator=(const safe_VkRenderingAreaInfo& copy_src); + safe_VkRenderingAreaInfo(); + ~safe_VkRenderingAreaInfo(); + void initialize(const VkRenderingAreaInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderingAreaInfo* copy_src, PNextCopyState* copy_state = {}); + VkRenderingAreaInfo* ptr() { return reinterpret_cast(this); } + VkRenderingAreaInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImageSubresource2 { + VkStructureType sType; + void* pNext{}; + VkImageSubresource imageSubresource; + + safe_VkImageSubresource2(const VkImageSubresource2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImageSubresource2(const safe_VkImageSubresource2& copy_src); + safe_VkImageSubresource2& operator=(const safe_VkImageSubresource2& copy_src); + safe_VkImageSubresource2(); + ~safe_VkImageSubresource2(); + void initialize(const VkImageSubresource2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageSubresource2* copy_src, PNextCopyState* copy_state = {}); + VkImageSubresource2* ptr() { return reinterpret_cast(this); } + VkImageSubresource2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDeviceImageSubresourceInfo { + VkStructureType sType; + const void* pNext{}; + safe_VkImageCreateInfo* pCreateInfo{}; + safe_VkImageSubresource2* pSubresource{}; + + safe_VkDeviceImageSubresourceInfo(const VkDeviceImageSubresourceInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDeviceImageSubresourceInfo(const safe_VkDeviceImageSubresourceInfo& copy_src); + safe_VkDeviceImageSubresourceInfo& operator=(const safe_VkDeviceImageSubresourceInfo& copy_src); + safe_VkDeviceImageSubresourceInfo(); + ~safe_VkDeviceImageSubresourceInfo(); + void initialize(const VkDeviceImageSubresourceInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceImageSubresourceInfo* copy_src, PNextCopyState* copy_state = {}); + VkDeviceImageSubresourceInfo* ptr() { return reinterpret_cast(this); } + VkDeviceImageSubresourceInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSubresourceLayout2 { + VkStructureType sType; + void* pNext{}; + VkSubresourceLayout subresourceLayout; + + safe_VkSubresourceLayout2(const VkSubresourceLayout2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSubresourceLayout2(const safe_VkSubresourceLayout2& copy_src); + safe_VkSubresourceLayout2& operator=(const safe_VkSubresourceLayout2& copy_src); + safe_VkSubresourceLayout2(); + ~safe_VkSubresourceLayout2(); + void initialize(const VkSubresourceLayout2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSubresourceLayout2* copy_src, PNextCopyState* copy_state = {}); + VkSubresourceLayout2* ptr() { return reinterpret_cast(this); } + VkSubresourceLayout2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPipelineCreateFlags2CreateInfo { + VkStructureType sType; + const void* pNext{}; + VkPipelineCreateFlags2 flags; + + safe_VkPipelineCreateFlags2CreateInfo(const VkPipelineCreateFlags2CreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineCreateFlags2CreateInfo(const safe_VkPipelineCreateFlags2CreateInfo& copy_src); + safe_VkPipelineCreateFlags2CreateInfo& operator=(const safe_VkPipelineCreateFlags2CreateInfo& copy_src); + safe_VkPipelineCreateFlags2CreateInfo(); + ~safe_VkPipelineCreateFlags2CreateInfo(); + void initialize(const VkPipelineCreateFlags2CreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineCreateFlags2CreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineCreateFlags2CreateInfo* ptr() { return reinterpret_cast(this); } + VkPipelineCreateFlags2CreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkBufferUsageFlags2CreateInfo { + VkStructureType sType; + const void* pNext{}; + VkBufferUsageFlags2 usage; + + safe_VkBufferUsageFlags2CreateInfo(const VkBufferUsageFlags2CreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkBufferUsageFlags2CreateInfo(const safe_VkBufferUsageFlags2CreateInfo& copy_src); + safe_VkBufferUsageFlags2CreateInfo& operator=(const safe_VkBufferUsageFlags2CreateInfo& copy_src); + safe_VkBufferUsageFlags2CreateInfo(); + ~safe_VkBufferUsageFlags2CreateInfo(); + void initialize(const VkBufferUsageFlags2CreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBufferUsageFlags2CreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkBufferUsageFlags2CreateInfo* ptr() { return reinterpret_cast(this); } + VkBufferUsageFlags2CreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDevicePushDescriptorProperties { + VkStructureType sType; + void* pNext{}; + uint32_t maxPushDescriptors; + + safe_VkPhysicalDevicePushDescriptorProperties(const VkPhysicalDevicePushDescriptorProperties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePushDescriptorProperties(const safe_VkPhysicalDevicePushDescriptorProperties& copy_src); + safe_VkPhysicalDevicePushDescriptorProperties& operator=(const safe_VkPhysicalDevicePushDescriptorProperties& copy_src); + safe_VkPhysicalDevicePushDescriptorProperties(); + ~safe_VkPhysicalDevicePushDescriptorProperties(); + void initialize(const VkPhysicalDevicePushDescriptorProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePushDescriptorProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePushDescriptorProperties* ptr() { return reinterpret_cast(this); } + VkPhysicalDevicePushDescriptorProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 dynamicRenderingLocalRead; + + safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures& copy_src); + safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures& operator=( + const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures& copy_src); + safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(); + ~safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(); + void initialize(const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDynamicRenderingLocalReadFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDynamicRenderingLocalReadFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRenderingAttachmentLocationInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t colorAttachmentCount; + const uint32_t* pColorAttachmentLocations{}; + + safe_VkRenderingAttachmentLocationInfo(const VkRenderingAttachmentLocationInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkRenderingAttachmentLocationInfo(const safe_VkRenderingAttachmentLocationInfo& copy_src); + safe_VkRenderingAttachmentLocationInfo& operator=(const safe_VkRenderingAttachmentLocationInfo& copy_src); + safe_VkRenderingAttachmentLocationInfo(); + ~safe_VkRenderingAttachmentLocationInfo(); + void initialize(const VkRenderingAttachmentLocationInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderingAttachmentLocationInfo* copy_src, PNextCopyState* copy_state = {}); + VkRenderingAttachmentLocationInfo* ptr() { return reinterpret_cast(this); } + VkRenderingAttachmentLocationInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRenderingInputAttachmentIndexInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t colorAttachmentCount; + const uint32_t* pColorAttachmentInputIndices{}; + const uint32_t* pDepthInputAttachmentIndex{}; + const uint32_t* pStencilInputAttachmentIndex{}; + + safe_VkRenderingInputAttachmentIndexInfo(const VkRenderingInputAttachmentIndexInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkRenderingInputAttachmentIndexInfo(const safe_VkRenderingInputAttachmentIndexInfo& copy_src); + safe_VkRenderingInputAttachmentIndexInfo& operator=(const safe_VkRenderingInputAttachmentIndexInfo& copy_src); + safe_VkRenderingInputAttachmentIndexInfo(); + ~safe_VkRenderingInputAttachmentIndexInfo(); + void initialize(const VkRenderingInputAttachmentIndexInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderingInputAttachmentIndexInfo* copy_src, PNextCopyState* copy_state = {}); + VkRenderingInputAttachmentIndexInfo* ptr() { return reinterpret_cast(this); } + VkRenderingInputAttachmentIndexInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMaintenance6Features { + VkStructureType sType; + void* pNext{}; + VkBool32 maintenance6; + + safe_VkPhysicalDeviceMaintenance6Features(const VkPhysicalDeviceMaintenance6Features* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMaintenance6Features(const safe_VkPhysicalDeviceMaintenance6Features& copy_src); + safe_VkPhysicalDeviceMaintenance6Features& operator=(const safe_VkPhysicalDeviceMaintenance6Features& copy_src); + safe_VkPhysicalDeviceMaintenance6Features(); + ~safe_VkPhysicalDeviceMaintenance6Features(); + void initialize(const VkPhysicalDeviceMaintenance6Features* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMaintenance6Features* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMaintenance6Features* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMaintenance6Features const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMaintenance6Properties { + VkStructureType sType; + void* pNext{}; + VkBool32 blockTexelViewCompatibleMultipleLayers; + uint32_t maxCombinedImageSamplerDescriptorCount; + VkBool32 fragmentShadingRateClampCombinerInputs; + + safe_VkPhysicalDeviceMaintenance6Properties(const VkPhysicalDeviceMaintenance6Properties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMaintenance6Properties(const safe_VkPhysicalDeviceMaintenance6Properties& copy_src); + safe_VkPhysicalDeviceMaintenance6Properties& operator=(const safe_VkPhysicalDeviceMaintenance6Properties& copy_src); + safe_VkPhysicalDeviceMaintenance6Properties(); + ~safe_VkPhysicalDeviceMaintenance6Properties(); + void initialize(const VkPhysicalDeviceMaintenance6Properties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMaintenance6Properties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMaintenance6Properties* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMaintenance6Properties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkBindMemoryStatus { + VkStructureType sType; + const void* pNext{}; + VkResult* pResult{}; + + safe_VkBindMemoryStatus(const VkBindMemoryStatus* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkBindMemoryStatus(const safe_VkBindMemoryStatus& copy_src); + safe_VkBindMemoryStatus& operator=(const safe_VkBindMemoryStatus& copy_src); + safe_VkBindMemoryStatus(); + ~safe_VkBindMemoryStatus(); + void initialize(const VkBindMemoryStatus* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBindMemoryStatus* copy_src, PNextCopyState* copy_state = {}); + VkBindMemoryStatus* ptr() { return reinterpret_cast(this); } + VkBindMemoryStatus const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkBindDescriptorSetsInfo { + VkStructureType sType; + const void* pNext{}; + VkShaderStageFlags stageFlags; + VkPipelineLayout layout; + uint32_t firstSet; + uint32_t descriptorSetCount; + VkDescriptorSet* pDescriptorSets{}; + uint32_t dynamicOffsetCount; + const uint32_t* pDynamicOffsets{}; + + safe_VkBindDescriptorSetsInfo(const VkBindDescriptorSetsInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkBindDescriptorSetsInfo(const safe_VkBindDescriptorSetsInfo& copy_src); + safe_VkBindDescriptorSetsInfo& operator=(const safe_VkBindDescriptorSetsInfo& copy_src); + safe_VkBindDescriptorSetsInfo(); + ~safe_VkBindDescriptorSetsInfo(); + void initialize(const VkBindDescriptorSetsInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBindDescriptorSetsInfo* copy_src, PNextCopyState* copy_state = {}); + VkBindDescriptorSetsInfo* ptr() { return reinterpret_cast(this); } + VkBindDescriptorSetsInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPushConstantsInfo { + VkStructureType sType; + const void* pNext{}; + VkPipelineLayout layout; + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; + const void* pValues{}; + + safe_VkPushConstantsInfo(const VkPushConstantsInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPushConstantsInfo(const safe_VkPushConstantsInfo& copy_src); + safe_VkPushConstantsInfo& operator=(const safe_VkPushConstantsInfo& copy_src); + safe_VkPushConstantsInfo(); + ~safe_VkPushConstantsInfo(); + void initialize(const VkPushConstantsInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPushConstantsInfo* copy_src, PNextCopyState* copy_state = {}); + VkPushConstantsInfo* ptr() { return reinterpret_cast(this); } + VkPushConstantsInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPushDescriptorSetInfo { + VkStructureType sType; + const void* pNext{}; + VkShaderStageFlags stageFlags; + VkPipelineLayout layout; + uint32_t set; + uint32_t descriptorWriteCount; + safe_VkWriteDescriptorSet* pDescriptorWrites{}; + + safe_VkPushDescriptorSetInfo(const VkPushDescriptorSetInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPushDescriptorSetInfo(const safe_VkPushDescriptorSetInfo& copy_src); + safe_VkPushDescriptorSetInfo& operator=(const safe_VkPushDescriptorSetInfo& copy_src); + safe_VkPushDescriptorSetInfo(); + ~safe_VkPushDescriptorSetInfo(); + void initialize(const VkPushDescriptorSetInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPushDescriptorSetInfo* copy_src, PNextCopyState* copy_state = {}); + VkPushDescriptorSetInfo* ptr() { return reinterpret_cast(this); } + VkPushDescriptorSetInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPushDescriptorSetWithTemplateInfo { + VkStructureType sType; + const void* pNext{}; + VkDescriptorUpdateTemplate descriptorUpdateTemplate; + VkPipelineLayout layout; + uint32_t set; + const void* pData{}; + + safe_VkPushDescriptorSetWithTemplateInfo(const VkPushDescriptorSetWithTemplateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPushDescriptorSetWithTemplateInfo(const safe_VkPushDescriptorSetWithTemplateInfo& copy_src); + safe_VkPushDescriptorSetWithTemplateInfo& operator=(const safe_VkPushDescriptorSetWithTemplateInfo& copy_src); + safe_VkPushDescriptorSetWithTemplateInfo(); + ~safe_VkPushDescriptorSetWithTemplateInfo(); + void initialize(const VkPushDescriptorSetWithTemplateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPushDescriptorSetWithTemplateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPushDescriptorSetWithTemplateInfo* ptr() { return reinterpret_cast(this); } + VkPushDescriptorSetWithTemplateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDevicePipelineProtectedAccessFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 pipelineProtectedAccess; + + safe_VkPhysicalDevicePipelineProtectedAccessFeatures(const VkPhysicalDevicePipelineProtectedAccessFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePipelineProtectedAccessFeatures(const safe_VkPhysicalDevicePipelineProtectedAccessFeatures& copy_src); + safe_VkPhysicalDevicePipelineProtectedAccessFeatures& operator=( + const safe_VkPhysicalDevicePipelineProtectedAccessFeatures& copy_src); + safe_VkPhysicalDevicePipelineProtectedAccessFeatures(); + ~safe_VkPhysicalDevicePipelineProtectedAccessFeatures(); + void initialize(const VkPhysicalDevicePipelineProtectedAccessFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePipelineProtectedAccessFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePipelineProtectedAccessFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDevicePipelineProtectedAccessFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDevicePipelineRobustnessFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 pipelineRobustness; + + safe_VkPhysicalDevicePipelineRobustnessFeatures(const VkPhysicalDevicePipelineRobustnessFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePipelineRobustnessFeatures(const safe_VkPhysicalDevicePipelineRobustnessFeatures& copy_src); + safe_VkPhysicalDevicePipelineRobustnessFeatures& operator=(const safe_VkPhysicalDevicePipelineRobustnessFeatures& copy_src); + safe_VkPhysicalDevicePipelineRobustnessFeatures(); + ~safe_VkPhysicalDevicePipelineRobustnessFeatures(); + void initialize(const VkPhysicalDevicePipelineRobustnessFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePipelineRobustnessFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePipelineRobustnessFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDevicePipelineRobustnessFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDevicePipelineRobustnessProperties { + VkStructureType sType; + void* pNext{}; + VkPipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers; + VkPipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers; + VkPipelineRobustnessBufferBehavior defaultRobustnessVertexInputs; + VkPipelineRobustnessImageBehavior defaultRobustnessImages; + + safe_VkPhysicalDevicePipelineRobustnessProperties(const VkPhysicalDevicePipelineRobustnessProperties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePipelineRobustnessProperties(const safe_VkPhysicalDevicePipelineRobustnessProperties& copy_src); + safe_VkPhysicalDevicePipelineRobustnessProperties& operator=(const safe_VkPhysicalDevicePipelineRobustnessProperties& copy_src); + safe_VkPhysicalDevicePipelineRobustnessProperties(); + ~safe_VkPhysicalDevicePipelineRobustnessProperties(); + void initialize(const VkPhysicalDevicePipelineRobustnessProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePipelineRobustnessProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePipelineRobustnessProperties* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDevicePipelineRobustnessProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineRobustnessCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkPipelineRobustnessBufferBehavior storageBuffers; + VkPipelineRobustnessBufferBehavior uniformBuffers; + VkPipelineRobustnessBufferBehavior vertexInputs; + VkPipelineRobustnessImageBehavior images; + + safe_VkPipelineRobustnessCreateInfo(const VkPipelineRobustnessCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineRobustnessCreateInfo(const safe_VkPipelineRobustnessCreateInfo& copy_src); + safe_VkPipelineRobustnessCreateInfo& operator=(const safe_VkPipelineRobustnessCreateInfo& copy_src); + safe_VkPipelineRobustnessCreateInfo(); + ~safe_VkPipelineRobustnessCreateInfo(); + void initialize(const VkPipelineRobustnessCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineRobustnessCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineRobustnessCreateInfo* ptr() { return reinterpret_cast(this); } + VkPipelineRobustnessCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceHostImageCopyFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 hostImageCopy; + + safe_VkPhysicalDeviceHostImageCopyFeatures(const VkPhysicalDeviceHostImageCopyFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceHostImageCopyFeatures(const safe_VkPhysicalDeviceHostImageCopyFeatures& copy_src); + safe_VkPhysicalDeviceHostImageCopyFeatures& operator=(const safe_VkPhysicalDeviceHostImageCopyFeatures& copy_src); + safe_VkPhysicalDeviceHostImageCopyFeatures(); + ~safe_VkPhysicalDeviceHostImageCopyFeatures(); + void initialize(const VkPhysicalDeviceHostImageCopyFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceHostImageCopyFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceHostImageCopyFeatures* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceHostImageCopyFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceHostImageCopyProperties { + VkStructureType sType; + void* pNext{}; + uint32_t copySrcLayoutCount; + VkImageLayout* pCopySrcLayouts{}; + uint32_t copyDstLayoutCount; + VkImageLayout* pCopyDstLayouts{}; + uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE]; + VkBool32 identicalMemoryTypeRequirements; + + safe_VkPhysicalDeviceHostImageCopyProperties(const VkPhysicalDeviceHostImageCopyProperties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceHostImageCopyProperties(const safe_VkPhysicalDeviceHostImageCopyProperties& copy_src); + safe_VkPhysicalDeviceHostImageCopyProperties& operator=(const safe_VkPhysicalDeviceHostImageCopyProperties& copy_src); + safe_VkPhysicalDeviceHostImageCopyProperties(); + ~safe_VkPhysicalDeviceHostImageCopyProperties(); + void initialize(const VkPhysicalDeviceHostImageCopyProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceHostImageCopyProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceHostImageCopyProperties* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceHostImageCopyProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkMemoryToImageCopy { + VkStructureType sType; + const void* pNext{}; + const void* pHostPointer{}; + uint32_t memoryRowLength; + uint32_t memoryImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; + + safe_VkMemoryToImageCopy(const VkMemoryToImageCopy* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMemoryToImageCopy(const safe_VkMemoryToImageCopy& copy_src); + safe_VkMemoryToImageCopy& operator=(const safe_VkMemoryToImageCopy& copy_src); + safe_VkMemoryToImageCopy(); + ~safe_VkMemoryToImageCopy(); + void initialize(const VkMemoryToImageCopy* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryToImageCopy* copy_src, PNextCopyState* copy_state = {}); + VkMemoryToImageCopy* ptr() { return reinterpret_cast(this); } + VkMemoryToImageCopy const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImageToMemoryCopy { + VkStructureType sType; + const void* pNext{}; + void* pHostPointer{}; + uint32_t memoryRowLength; + uint32_t memoryImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; + + safe_VkImageToMemoryCopy(const VkImageToMemoryCopy* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImageToMemoryCopy(const safe_VkImageToMemoryCopy& copy_src); + safe_VkImageToMemoryCopy& operator=(const safe_VkImageToMemoryCopy& copy_src); + safe_VkImageToMemoryCopy(); + ~safe_VkImageToMemoryCopy(); + void initialize(const VkImageToMemoryCopy* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageToMemoryCopy* copy_src, PNextCopyState* copy_state = {}); + VkImageToMemoryCopy* ptr() { return reinterpret_cast(this); } + VkImageToMemoryCopy const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCopyMemoryToImageInfo { + VkStructureType sType; + const void* pNext{}; + VkHostImageCopyFlags flags; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + safe_VkMemoryToImageCopy* pRegions{}; + + safe_VkCopyMemoryToImageInfo(const VkCopyMemoryToImageInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkCopyMemoryToImageInfo(const safe_VkCopyMemoryToImageInfo& copy_src); + safe_VkCopyMemoryToImageInfo& operator=(const safe_VkCopyMemoryToImageInfo& copy_src); + safe_VkCopyMemoryToImageInfo(); + ~safe_VkCopyMemoryToImageInfo(); + void initialize(const VkCopyMemoryToImageInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyMemoryToImageInfo* copy_src, PNextCopyState* copy_state = {}); + VkCopyMemoryToImageInfo* ptr() { return reinterpret_cast(this); } + VkCopyMemoryToImageInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCopyImageToMemoryInfo { + VkStructureType sType; + const void* pNext{}; + VkHostImageCopyFlags flags; + VkImage srcImage; + VkImageLayout srcImageLayout; + uint32_t regionCount; + safe_VkImageToMemoryCopy* pRegions{}; + + safe_VkCopyImageToMemoryInfo(const VkCopyImageToMemoryInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkCopyImageToMemoryInfo(const safe_VkCopyImageToMemoryInfo& copy_src); + safe_VkCopyImageToMemoryInfo& operator=(const safe_VkCopyImageToMemoryInfo& copy_src); + safe_VkCopyImageToMemoryInfo(); + ~safe_VkCopyImageToMemoryInfo(); + void initialize(const VkCopyImageToMemoryInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyImageToMemoryInfo* copy_src, PNextCopyState* copy_state = {}); + VkCopyImageToMemoryInfo* ptr() { return reinterpret_cast(this); } + VkCopyImageToMemoryInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCopyImageToImageInfo { + VkStructureType sType; + const void* pNext{}; + VkHostImageCopyFlags flags; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + safe_VkImageCopy2* pRegions{}; + + safe_VkCopyImageToImageInfo(const VkCopyImageToImageInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkCopyImageToImageInfo(const safe_VkCopyImageToImageInfo& copy_src); + safe_VkCopyImageToImageInfo& operator=(const safe_VkCopyImageToImageInfo& copy_src); + safe_VkCopyImageToImageInfo(); + ~safe_VkCopyImageToImageInfo(); + void initialize(const VkCopyImageToImageInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyImageToImageInfo* copy_src, PNextCopyState* copy_state = {}); + VkCopyImageToImageInfo* ptr() { return reinterpret_cast(this); } + VkCopyImageToImageInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkHostImageLayoutTransitionInfo { + VkStructureType sType; + const void* pNext{}; + VkImage image; + VkImageLayout oldLayout; + VkImageLayout newLayout; + VkImageSubresourceRange subresourceRange; + + safe_VkHostImageLayoutTransitionInfo(const VkHostImageLayoutTransitionInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkHostImageLayoutTransitionInfo(const safe_VkHostImageLayoutTransitionInfo& copy_src); + safe_VkHostImageLayoutTransitionInfo& operator=(const safe_VkHostImageLayoutTransitionInfo& copy_src); + safe_VkHostImageLayoutTransitionInfo(); + ~safe_VkHostImageLayoutTransitionInfo(); + void initialize(const VkHostImageLayoutTransitionInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkHostImageLayoutTransitionInfo* copy_src, PNextCopyState* copy_state = {}); + VkHostImageLayoutTransitionInfo* ptr() { return reinterpret_cast(this); } + VkHostImageLayoutTransitionInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSubresourceHostMemcpySize { + VkStructureType sType; + void* pNext{}; + VkDeviceSize size; + + safe_VkSubresourceHostMemcpySize(const VkSubresourceHostMemcpySize* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSubresourceHostMemcpySize(const safe_VkSubresourceHostMemcpySize& copy_src); + safe_VkSubresourceHostMemcpySize& operator=(const safe_VkSubresourceHostMemcpySize& copy_src); + safe_VkSubresourceHostMemcpySize(); + ~safe_VkSubresourceHostMemcpySize(); + void initialize(const VkSubresourceHostMemcpySize* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSubresourceHostMemcpySize* copy_src, PNextCopyState* copy_state = {}); + VkSubresourceHostMemcpySize* ptr() { return reinterpret_cast(this); } + VkSubresourceHostMemcpySize const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkHostImageCopyDevicePerformanceQuery { + VkStructureType sType; + void* pNext{}; + VkBool32 optimalDeviceAccess; + VkBool32 identicalMemoryLayout; + + safe_VkHostImageCopyDevicePerformanceQuery(const VkHostImageCopyDevicePerformanceQuery* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkHostImageCopyDevicePerformanceQuery(const safe_VkHostImageCopyDevicePerformanceQuery& copy_src); + safe_VkHostImageCopyDevicePerformanceQuery& operator=(const safe_VkHostImageCopyDevicePerformanceQuery& copy_src); + safe_VkHostImageCopyDevicePerformanceQuery(); + ~safe_VkHostImageCopyDevicePerformanceQuery(); + void initialize(const VkHostImageCopyDevicePerformanceQuery* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkHostImageCopyDevicePerformanceQuery* copy_src, PNextCopyState* copy_state = {}); + VkHostImageCopyDevicePerformanceQuery* ptr() { return reinterpret_cast(this); } + VkHostImageCopyDevicePerformanceQuery const* ptr() const { + return reinterpret_cast(this); + } +}; struct safe_VkSwapchainCreateInfoKHR { VkStructureType sType; const void* pNext{}; @@ -6139,26 +7147,6 @@ struct safe_VkSemaphoreGetFdInfoKHR { VkSemaphoreGetFdInfoKHR* ptr() { return reinterpret_cast(this); } VkSemaphoreGetFdInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPhysicalDevicePushDescriptorPropertiesKHR { - VkStructureType sType; - void* pNext{}; - uint32_t maxPushDescriptors; - - safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src); - safe_VkPhysicalDevicePushDescriptorPropertiesKHR& operator=(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src); - safe_VkPhysicalDevicePushDescriptorPropertiesKHR(); - ~safe_VkPhysicalDevicePushDescriptorPropertiesKHR(); - void initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDevicePushDescriptorPropertiesKHR* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDevicePushDescriptorPropertiesKHR const* ptr() const { - return reinterpret_cast(this); - } -}; struct safe_VkPresentRegionKHR { uint32_t rectangleCount; const VkRectLayerKHR* pRectangles{}; @@ -6749,64 +7737,6 @@ struct safe_VkVideoDecodeH265DpbSlotInfoKHR { VkVideoDecodeH265DpbSlotInfoKHR* ptr() { return reinterpret_cast(this); } VkVideoDecodeH265DpbSlotInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkDeviceQueueGlobalPriorityCreateInfoKHR { - VkStructureType sType; - const void* pNext{}; - VkQueueGlobalPriorityKHR globalPriority; - - safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& copy_src); - safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& operator=(const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& copy_src); - safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(); - ~safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(); - void initialize(const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkDeviceQueueGlobalPriorityCreateInfoKHR* ptr() { return reinterpret_cast(this); } - VkDeviceQueueGlobalPriorityCreateInfoKHR const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR { - VkStructureType sType; - void* pNext{}; - VkBool32 globalPriorityQuery; - - safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src); - safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& operator=( - const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src); - safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(); - ~safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(); - void initialize(const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkQueueFamilyGlobalPriorityPropertiesKHR { - VkStructureType sType; - void* pNext{}; - uint32_t priorityCount; - VkQueueGlobalPriorityKHR priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_KHR]; - - safe_VkQueueFamilyGlobalPriorityPropertiesKHR(const VkQueueFamilyGlobalPriorityPropertiesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkQueueFamilyGlobalPriorityPropertiesKHR(const safe_VkQueueFamilyGlobalPriorityPropertiesKHR& copy_src); - safe_VkQueueFamilyGlobalPriorityPropertiesKHR& operator=(const safe_VkQueueFamilyGlobalPriorityPropertiesKHR& copy_src); - safe_VkQueueFamilyGlobalPriorityPropertiesKHR(); - ~safe_VkQueueFamilyGlobalPriorityPropertiesKHR(); - void initialize(const VkQueueFamilyGlobalPriorityPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkQueueFamilyGlobalPriorityPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkQueueFamilyGlobalPriorityPropertiesKHR* ptr() { return reinterpret_cast(this); } - VkQueueFamilyGlobalPriorityPropertiesKHR const* ptr() const { - return reinterpret_cast(this); - } -}; struct safe_VkFragmentShadingRateAttachmentInfoKHR { VkStructureType sType; const void* pNext{}; @@ -6950,68 +7880,6 @@ struct safe_VkRenderingFragmentShadingRateAttachmentInfoKHR { return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR { - VkStructureType sType; - void* pNext{}; - VkBool32 dynamicRenderingLocalRead; - - safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR( - const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src); - safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& operator=( - const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src); - safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(); - ~safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(); - void initialize(const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkRenderingAttachmentLocationInfoKHR { - VkStructureType sType; - const void* pNext{}; - uint32_t colorAttachmentCount; - const uint32_t* pColorAttachmentLocations{}; - - safe_VkRenderingAttachmentLocationInfoKHR(const VkRenderingAttachmentLocationInfoKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkRenderingAttachmentLocationInfoKHR(const safe_VkRenderingAttachmentLocationInfoKHR& copy_src); - safe_VkRenderingAttachmentLocationInfoKHR& operator=(const safe_VkRenderingAttachmentLocationInfoKHR& copy_src); - safe_VkRenderingAttachmentLocationInfoKHR(); - ~safe_VkRenderingAttachmentLocationInfoKHR(); - void initialize(const VkRenderingAttachmentLocationInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkRenderingAttachmentLocationInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkRenderingAttachmentLocationInfoKHR* ptr() { return reinterpret_cast(this); } - VkRenderingAttachmentLocationInfoKHR const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkRenderingInputAttachmentIndexInfoKHR { - VkStructureType sType; - const void* pNext{}; - uint32_t colorAttachmentCount; - const uint32_t* pColorAttachmentInputIndices{}; - const uint32_t* pDepthInputAttachmentIndex{}; - const uint32_t* pStencilInputAttachmentIndex{}; - - safe_VkRenderingInputAttachmentIndexInfoKHR(const VkRenderingInputAttachmentIndexInfoKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkRenderingInputAttachmentIndexInfoKHR(const safe_VkRenderingInputAttachmentIndexInfoKHR& copy_src); - safe_VkRenderingInputAttachmentIndexInfoKHR& operator=(const safe_VkRenderingInputAttachmentIndexInfoKHR& copy_src); - safe_VkRenderingInputAttachmentIndexInfoKHR(); - ~safe_VkRenderingInputAttachmentIndexInfoKHR(); - void initialize(const VkRenderingInputAttachmentIndexInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkRenderingInputAttachmentIndexInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkRenderingInputAttachmentIndexInfoKHR* ptr() { return reinterpret_cast(this); } - VkRenderingInputAttachmentIndexInfoKHR const* ptr() const { - return reinterpret_cast(this); - } -}; struct safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR { VkStructureType sType; void* pNext{}; @@ -7188,40 +8056,6 @@ struct safe_VkPipelineExecutableInternalRepresentationKHR { return reinterpret_cast(this); } }; -struct safe_VkMemoryMapInfoKHR { - VkStructureType sType; - const void* pNext{}; - VkMemoryMapFlags flags; - VkDeviceMemory memory; - VkDeviceSize offset; - VkDeviceSize size; - - safe_VkMemoryMapInfoKHR(const VkMemoryMapInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkMemoryMapInfoKHR(const safe_VkMemoryMapInfoKHR& copy_src); - safe_VkMemoryMapInfoKHR& operator=(const safe_VkMemoryMapInfoKHR& copy_src); - safe_VkMemoryMapInfoKHR(); - ~safe_VkMemoryMapInfoKHR(); - void initialize(const VkMemoryMapInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkMemoryMapInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkMemoryMapInfoKHR* ptr() { return reinterpret_cast(this); } - VkMemoryMapInfoKHR const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkMemoryUnmapInfoKHR { - VkStructureType sType; - const void* pNext{}; - VkMemoryUnmapFlagsKHR flags; - VkDeviceMemory memory; - - safe_VkMemoryUnmapInfoKHR(const VkMemoryUnmapInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkMemoryUnmapInfoKHR(const safe_VkMemoryUnmapInfoKHR& copy_src); - safe_VkMemoryUnmapInfoKHR& operator=(const safe_VkMemoryUnmapInfoKHR& copy_src); - safe_VkMemoryUnmapInfoKHR(); - ~safe_VkMemoryUnmapInfoKHR(); - void initialize(const VkMemoryUnmapInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkMemoryUnmapInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkMemoryUnmapInfoKHR* ptr() { return reinterpret_cast(this); } - VkMemoryUnmapInfoKHR const* ptr() const { return reinterpret_cast(this); } -}; struct safe_VkPipelineLibraryCreateInfoKHR { VkStructureType sType; const void* pNext{}; @@ -7611,28 +8445,6 @@ struct safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR { return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR { - VkStructureType sType; - void* pNext{}; - VkBool32 shaderSubgroupRotate; - VkBool32 shaderSubgroupRotateClustered; - - safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src); - safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& operator=( - const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src); - safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(); - ~safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(); - void initialize(const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR const* ptr() const { - return reinterpret_cast(this); - } -}; struct safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR { VkStructureType sType; void* pNext{}; @@ -7656,147 +8468,6 @@ struct safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR { return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceMaintenance5FeaturesKHR { - VkStructureType sType; - void* pNext{}; - VkBool32 maintenance5; - - safe_VkPhysicalDeviceMaintenance5FeaturesKHR(const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceMaintenance5FeaturesKHR(const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src); - safe_VkPhysicalDeviceMaintenance5FeaturesKHR& operator=(const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src); - safe_VkPhysicalDeviceMaintenance5FeaturesKHR(); - ~safe_VkPhysicalDeviceMaintenance5FeaturesKHR(); - void initialize(const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceMaintenance5FeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceMaintenance5FeaturesKHR* ptr() { return reinterpret_cast(this); } - VkPhysicalDeviceMaintenance5FeaturesKHR const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkPhysicalDeviceMaintenance5PropertiesKHR { - VkStructureType sType; - void* pNext{}; - VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting; - VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting; - VkBool32 depthStencilSwizzleOneSupport; - VkBool32 polygonModePointSize; - VkBool32 nonStrictSinglePixelWideLinesUseParallelogram; - VkBool32 nonStrictWideLinesUseParallelogram; - - safe_VkPhysicalDeviceMaintenance5PropertiesKHR(const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceMaintenance5PropertiesKHR(const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src); - safe_VkPhysicalDeviceMaintenance5PropertiesKHR& operator=(const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src); - safe_VkPhysicalDeviceMaintenance5PropertiesKHR(); - ~safe_VkPhysicalDeviceMaintenance5PropertiesKHR(); - void initialize(const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceMaintenance5PropertiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceMaintenance5PropertiesKHR* ptr() { return reinterpret_cast(this); } - VkPhysicalDeviceMaintenance5PropertiesKHR const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkRenderingAreaInfoKHR { - VkStructureType sType; - const void* pNext{}; - uint32_t viewMask; - uint32_t colorAttachmentCount; - const VkFormat* pColorAttachmentFormats{}; - VkFormat depthAttachmentFormat; - VkFormat stencilAttachmentFormat; - - safe_VkRenderingAreaInfoKHR(const VkRenderingAreaInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkRenderingAreaInfoKHR(const safe_VkRenderingAreaInfoKHR& copy_src); - safe_VkRenderingAreaInfoKHR& operator=(const safe_VkRenderingAreaInfoKHR& copy_src); - safe_VkRenderingAreaInfoKHR(); - ~safe_VkRenderingAreaInfoKHR(); - void initialize(const VkRenderingAreaInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkRenderingAreaInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkRenderingAreaInfoKHR* ptr() { return reinterpret_cast(this); } - VkRenderingAreaInfoKHR const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkImageSubresource2KHR { - VkStructureType sType; - void* pNext{}; - VkImageSubresource imageSubresource; - - safe_VkImageSubresource2KHR(const VkImageSubresource2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkImageSubresource2KHR(const safe_VkImageSubresource2KHR& copy_src); - safe_VkImageSubresource2KHR& operator=(const safe_VkImageSubresource2KHR& copy_src); - safe_VkImageSubresource2KHR(); - ~safe_VkImageSubresource2KHR(); - void initialize(const VkImageSubresource2KHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkImageSubresource2KHR* copy_src, PNextCopyState* copy_state = {}); - VkImageSubresource2KHR* ptr() { return reinterpret_cast(this); } - VkImageSubresource2KHR const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkDeviceImageSubresourceInfoKHR { - VkStructureType sType; - const void* pNext{}; - safe_VkImageCreateInfo* pCreateInfo{}; - safe_VkImageSubresource2KHR* pSubresource{}; - - safe_VkDeviceImageSubresourceInfoKHR(const VkDeviceImageSubresourceInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkDeviceImageSubresourceInfoKHR(const safe_VkDeviceImageSubresourceInfoKHR& copy_src); - safe_VkDeviceImageSubresourceInfoKHR& operator=(const safe_VkDeviceImageSubresourceInfoKHR& copy_src); - safe_VkDeviceImageSubresourceInfoKHR(); - ~safe_VkDeviceImageSubresourceInfoKHR(); - void initialize(const VkDeviceImageSubresourceInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkDeviceImageSubresourceInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkDeviceImageSubresourceInfoKHR* ptr() { return reinterpret_cast(this); } - VkDeviceImageSubresourceInfoKHR const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkSubresourceLayout2KHR { - VkStructureType sType; - void* pNext{}; - VkSubresourceLayout subresourceLayout; - - safe_VkSubresourceLayout2KHR(const VkSubresourceLayout2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkSubresourceLayout2KHR(const safe_VkSubresourceLayout2KHR& copy_src); - safe_VkSubresourceLayout2KHR& operator=(const safe_VkSubresourceLayout2KHR& copy_src); - safe_VkSubresourceLayout2KHR(); - ~safe_VkSubresourceLayout2KHR(); - void initialize(const VkSubresourceLayout2KHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkSubresourceLayout2KHR* copy_src, PNextCopyState* copy_state = {}); - VkSubresourceLayout2KHR* ptr() { return reinterpret_cast(this); } - VkSubresourceLayout2KHR const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkPipelineCreateFlags2CreateInfoKHR { - VkStructureType sType; - const void* pNext{}; - VkPipelineCreateFlags2KHR flags; - - safe_VkPipelineCreateFlags2CreateInfoKHR(const VkPipelineCreateFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkPipelineCreateFlags2CreateInfoKHR(const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src); - safe_VkPipelineCreateFlags2CreateInfoKHR& operator=(const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src); - safe_VkPipelineCreateFlags2CreateInfoKHR(); - ~safe_VkPipelineCreateFlags2CreateInfoKHR(); - void initialize(const VkPipelineCreateFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPipelineCreateFlags2CreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkPipelineCreateFlags2CreateInfoKHR* ptr() { return reinterpret_cast(this); } - VkPipelineCreateFlags2CreateInfoKHR const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkBufferUsageFlags2CreateInfoKHR { - VkStructureType sType; - const void* pNext{}; - VkBufferUsageFlags2KHR usage; - - safe_VkBufferUsageFlags2CreateInfoKHR(const VkBufferUsageFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkBufferUsageFlags2CreateInfoKHR(const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src); - safe_VkBufferUsageFlags2CreateInfoKHR& operator=(const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src); - safe_VkBufferUsageFlags2CreateInfoKHR(); - ~safe_VkBufferUsageFlags2CreateInfoKHR(); - void initialize(const VkBufferUsageFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkBufferUsageFlags2CreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkBufferUsageFlags2CreateInfoKHR* ptr() { return reinterpret_cast(this); } - VkBufferUsageFlags2CreateInfoKHR const* ptr() const { return reinterpret_cast(this); } -}; struct safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR { VkStructureType sType; void* pNext{}; @@ -8453,247 +9124,71 @@ struct safe_VkVideoEncodeAV1RateControlInfoKHR { ~safe_VkVideoEncodeAV1RateControlInfoKHR(); void initialize(const VkVideoEncodeAV1RateControlInfoKHR* in_struct, PNextCopyState* copy_state = {}); void initialize(const safe_VkVideoEncodeAV1RateControlInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeAV1RateControlInfoKHR* ptr() { return reinterpret_cast(this); } - VkVideoEncodeAV1RateControlInfoKHR const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkVideoEncodeAV1RateControlLayerInfoKHR { - VkStructureType sType; - const void* pNext{}; - VkBool32 useMinQIndex; - VkVideoEncodeAV1QIndexKHR minQIndex; - VkBool32 useMaxQIndex; - VkVideoEncodeAV1QIndexKHR maxQIndex; - VkBool32 useMaxFrameSize; - VkVideoEncodeAV1FrameSizeKHR maxFrameSize; - - safe_VkVideoEncodeAV1RateControlLayerInfoKHR(const VkVideoEncodeAV1RateControlLayerInfoKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeAV1RateControlLayerInfoKHR(const safe_VkVideoEncodeAV1RateControlLayerInfoKHR& copy_src); - safe_VkVideoEncodeAV1RateControlLayerInfoKHR& operator=(const safe_VkVideoEncodeAV1RateControlLayerInfoKHR& copy_src); - safe_VkVideoEncodeAV1RateControlLayerInfoKHR(); - ~safe_VkVideoEncodeAV1RateControlLayerInfoKHR(); - void initialize(const VkVideoEncodeAV1RateControlLayerInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeAV1RateControlLayerInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeAV1RateControlLayerInfoKHR* ptr() { return reinterpret_cast(this); } - VkVideoEncodeAV1RateControlLayerInfoKHR const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR { - VkStructureType sType; - void* pNext{}; - VkBool32 videoMaintenance1; - - safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src); - safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& operator=(const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src); - safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(); - ~safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(); - void initialize(const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceVideoMaintenance1FeaturesKHR* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDeviceVideoMaintenance1FeaturesKHR const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkVideoInlineQueryInfoKHR { - VkStructureType sType; - const void* pNext{}; - VkQueryPool queryPool; - uint32_t firstQuery; - uint32_t queryCount; - - safe_VkVideoInlineQueryInfoKHR(const VkVideoInlineQueryInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoInlineQueryInfoKHR(const safe_VkVideoInlineQueryInfoKHR& copy_src); - safe_VkVideoInlineQueryInfoKHR& operator=(const safe_VkVideoInlineQueryInfoKHR& copy_src); - safe_VkVideoInlineQueryInfoKHR(); - ~safe_VkVideoInlineQueryInfoKHR(); - void initialize(const VkVideoInlineQueryInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoInlineQueryInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoInlineQueryInfoKHR* ptr() { return reinterpret_cast(this); } - VkVideoInlineQueryInfoKHR const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR { - VkStructureType sType; - void* pNext{}; - uint32_t maxVertexAttribDivisor; - VkBool32 supportsNonZeroFirstInstance; - - safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR( - const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src); - safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& operator=( - const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src); - safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(); - ~safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(); - void initialize(const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkPipelineVertexInputDivisorStateCreateInfoKHR { - VkStructureType sType; - const void* pNext{}; - uint32_t vertexBindingDivisorCount; - const VkVertexInputBindingDivisorDescriptionKHR* pVertexBindingDivisors{}; - - safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src); - safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& operator=( - const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src); - safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(); - ~safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(); - void initialize(const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkPipelineVertexInputDivisorStateCreateInfoKHR* ptr() { - return reinterpret_cast(this); - } - VkPipelineVertexInputDivisorStateCreateInfoKHR const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR { - VkStructureType sType; - void* pNext{}; - VkBool32 vertexAttributeInstanceRateDivisor; - VkBool32 vertexAttributeInstanceRateZeroDivisor; - - safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src); - safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& operator=( - const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src); - safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(); - ~safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(); - void initialize(const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR { - VkStructureType sType; - void* pNext{}; - VkBool32 shaderFloatControls2; - - safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src); - safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& operator=( - const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src); - safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(); - ~safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(); - void initialize(const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceShaderFloatControls2FeaturesKHR* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDeviceShaderFloatControls2FeaturesKHR const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR { - VkStructureType sType; - void* pNext{}; - VkBool32 indexTypeUint8; - - safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src); - safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& operator=(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src); - safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(); - ~safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(); - void initialize(const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceIndexTypeUint8FeaturesKHR* ptr() { return reinterpret_cast(this); } - VkPhysicalDeviceIndexTypeUint8FeaturesKHR const* ptr() const { - return reinterpret_cast(this); + VkVideoEncodeAV1RateControlInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeAV1RateControlInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceLineRasterizationFeaturesKHR { +struct safe_VkVideoEncodeAV1RateControlLayerInfoKHR { VkStructureType sType; - void* pNext{}; - VkBool32 rectangularLines; - VkBool32 bresenhamLines; - VkBool32 smoothLines; - VkBool32 stippledRectangularLines; - VkBool32 stippledBresenhamLines; - VkBool32 stippledSmoothLines; + const void* pNext{}; + VkBool32 useMinQIndex; + VkVideoEncodeAV1QIndexKHR minQIndex; + VkBool32 useMaxQIndex; + VkVideoEncodeAV1QIndexKHR maxQIndex; + VkBool32 useMaxFrameSize; + VkVideoEncodeAV1FrameSizeKHR maxFrameSize; - safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& copy_src); - safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& operator=(const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& copy_src); - safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(); - ~safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(); - void initialize(const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceLineRasterizationFeaturesKHR* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDeviceLineRasterizationFeaturesKHR const* ptr() const { - return reinterpret_cast(this); + safe_VkVideoEncodeAV1RateControlLayerInfoKHR(const VkVideoEncodeAV1RateControlLayerInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeAV1RateControlLayerInfoKHR(const safe_VkVideoEncodeAV1RateControlLayerInfoKHR& copy_src); + safe_VkVideoEncodeAV1RateControlLayerInfoKHR& operator=(const safe_VkVideoEncodeAV1RateControlLayerInfoKHR& copy_src); + safe_VkVideoEncodeAV1RateControlLayerInfoKHR(); + ~safe_VkVideoEncodeAV1RateControlLayerInfoKHR(); + void initialize(const VkVideoEncodeAV1RateControlLayerInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeAV1RateControlLayerInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeAV1RateControlLayerInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeAV1RateControlLayerInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceLineRasterizationPropertiesKHR { +struct safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR { VkStructureType sType; void* pNext{}; - uint32_t lineSubPixelPrecisionBits; + VkBool32 videoMaintenance1; - safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& copy_src); - safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& operator=( - const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& copy_src); - safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(); - ~safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(); - void initialize(const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceLineRasterizationPropertiesKHR* ptr() { - return reinterpret_cast(this); + safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src); + safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& operator=(const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src); + safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(); + ~safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(); + void initialize(const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVideoMaintenance1FeaturesKHR* ptr() { + return reinterpret_cast(this); } - VkPhysicalDeviceLineRasterizationPropertiesKHR const* ptr() const { - return reinterpret_cast(this); + VkPhysicalDeviceVideoMaintenance1FeaturesKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkPipelineRasterizationLineStateCreateInfoKHR { +struct safe_VkVideoInlineQueryInfoKHR { VkStructureType sType; const void* pNext{}; - VkLineRasterizationModeKHR lineRasterizationMode; - VkBool32 stippledLineEnable; - uint32_t lineStippleFactor; - uint16_t lineStipplePattern; + VkQueryPool queryPool; + uint32_t firstQuery; + uint32_t queryCount; - safe_VkPipelineRasterizationLineStateCreateInfoKHR(const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPipelineRasterizationLineStateCreateInfoKHR(const safe_VkPipelineRasterizationLineStateCreateInfoKHR& copy_src); - safe_VkPipelineRasterizationLineStateCreateInfoKHR& operator=( - const safe_VkPipelineRasterizationLineStateCreateInfoKHR& copy_src); - safe_VkPipelineRasterizationLineStateCreateInfoKHR(); - ~safe_VkPipelineRasterizationLineStateCreateInfoKHR(); - void initialize(const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPipelineRasterizationLineStateCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkPipelineRasterizationLineStateCreateInfoKHR* ptr() { - return reinterpret_cast(this); - } - VkPipelineRasterizationLineStateCreateInfoKHR const* ptr() const { - return reinterpret_cast(this); - } + safe_VkVideoInlineQueryInfoKHR(const VkVideoInlineQueryInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoInlineQueryInfoKHR(const safe_VkVideoInlineQueryInfoKHR& copy_src); + safe_VkVideoInlineQueryInfoKHR& operator=(const safe_VkVideoInlineQueryInfoKHR& copy_src); + safe_VkVideoInlineQueryInfoKHR(); + ~safe_VkVideoInlineQueryInfoKHR(); + void initialize(const VkVideoInlineQueryInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoInlineQueryInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoInlineQueryInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoInlineQueryInfoKHR const* ptr() const { return reinterpret_cast(this); } }; struct safe_VkCalibratedTimestampInfoKHR { VkStructureType sType; @@ -8711,162 +9206,6 @@ struct safe_VkCalibratedTimestampInfoKHR { VkCalibratedTimestampInfoKHR* ptr() { return reinterpret_cast(this); } VkCalibratedTimestampInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR { - VkStructureType sType; - void* pNext{}; - VkBool32 shaderExpectAssume; - - safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src); - safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& operator=( - const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src); - safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(); - ~safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(); - void initialize(const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDeviceShaderExpectAssumeFeaturesKHR const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkPhysicalDeviceMaintenance6FeaturesKHR { - VkStructureType sType; - void* pNext{}; - VkBool32 maintenance6; - - safe_VkPhysicalDeviceMaintenance6FeaturesKHR(const VkPhysicalDeviceMaintenance6FeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceMaintenance6FeaturesKHR(const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& copy_src); - safe_VkPhysicalDeviceMaintenance6FeaturesKHR& operator=(const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& copy_src); - safe_VkPhysicalDeviceMaintenance6FeaturesKHR(); - ~safe_VkPhysicalDeviceMaintenance6FeaturesKHR(); - void initialize(const VkPhysicalDeviceMaintenance6FeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceMaintenance6FeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceMaintenance6FeaturesKHR* ptr() { return reinterpret_cast(this); } - VkPhysicalDeviceMaintenance6FeaturesKHR const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkPhysicalDeviceMaintenance6PropertiesKHR { - VkStructureType sType; - void* pNext{}; - VkBool32 blockTexelViewCompatibleMultipleLayers; - uint32_t maxCombinedImageSamplerDescriptorCount; - VkBool32 fragmentShadingRateClampCombinerInputs; - - safe_VkPhysicalDeviceMaintenance6PropertiesKHR(const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceMaintenance6PropertiesKHR(const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src); - safe_VkPhysicalDeviceMaintenance6PropertiesKHR& operator=(const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src); - safe_VkPhysicalDeviceMaintenance6PropertiesKHR(); - ~safe_VkPhysicalDeviceMaintenance6PropertiesKHR(); - void initialize(const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceMaintenance6PropertiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceMaintenance6PropertiesKHR* ptr() { return reinterpret_cast(this); } - VkPhysicalDeviceMaintenance6PropertiesKHR const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkBindMemoryStatusKHR { - VkStructureType sType; - const void* pNext{}; - VkResult* pResult{}; - - safe_VkBindMemoryStatusKHR(const VkBindMemoryStatusKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkBindMemoryStatusKHR(const safe_VkBindMemoryStatusKHR& copy_src); - safe_VkBindMemoryStatusKHR& operator=(const safe_VkBindMemoryStatusKHR& copy_src); - safe_VkBindMemoryStatusKHR(); - ~safe_VkBindMemoryStatusKHR(); - void initialize(const VkBindMemoryStatusKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkBindMemoryStatusKHR* copy_src, PNextCopyState* copy_state = {}); - VkBindMemoryStatusKHR* ptr() { return reinterpret_cast(this); } - VkBindMemoryStatusKHR const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkBindDescriptorSetsInfoKHR { - VkStructureType sType; - const void* pNext{}; - VkShaderStageFlags stageFlags; - VkPipelineLayout layout; - uint32_t firstSet; - uint32_t descriptorSetCount; - VkDescriptorSet* pDescriptorSets{}; - uint32_t dynamicOffsetCount; - const uint32_t* pDynamicOffsets{}; - - safe_VkBindDescriptorSetsInfoKHR(const VkBindDescriptorSetsInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkBindDescriptorSetsInfoKHR(const safe_VkBindDescriptorSetsInfoKHR& copy_src); - safe_VkBindDescriptorSetsInfoKHR& operator=(const safe_VkBindDescriptorSetsInfoKHR& copy_src); - safe_VkBindDescriptorSetsInfoKHR(); - ~safe_VkBindDescriptorSetsInfoKHR(); - void initialize(const VkBindDescriptorSetsInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkBindDescriptorSetsInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkBindDescriptorSetsInfoKHR* ptr() { return reinterpret_cast(this); } - VkBindDescriptorSetsInfoKHR const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkPushConstantsInfoKHR { - VkStructureType sType; - const void* pNext{}; - VkPipelineLayout layout; - VkShaderStageFlags stageFlags; - uint32_t offset; - uint32_t size; - const void* pValues{}; - - safe_VkPushConstantsInfoKHR(const VkPushConstantsInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPushConstantsInfoKHR(const safe_VkPushConstantsInfoKHR& copy_src); - safe_VkPushConstantsInfoKHR& operator=(const safe_VkPushConstantsInfoKHR& copy_src); - safe_VkPushConstantsInfoKHR(); - ~safe_VkPushConstantsInfoKHR(); - void initialize(const VkPushConstantsInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPushConstantsInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkPushConstantsInfoKHR* ptr() { return reinterpret_cast(this); } - VkPushConstantsInfoKHR const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkPushDescriptorSetInfoKHR { - VkStructureType sType; - const void* pNext{}; - VkShaderStageFlags stageFlags; - VkPipelineLayout layout; - uint32_t set; - uint32_t descriptorWriteCount; - safe_VkWriteDescriptorSet* pDescriptorWrites{}; - - safe_VkPushDescriptorSetInfoKHR(const VkPushDescriptorSetInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkPushDescriptorSetInfoKHR(const safe_VkPushDescriptorSetInfoKHR& copy_src); - safe_VkPushDescriptorSetInfoKHR& operator=(const safe_VkPushDescriptorSetInfoKHR& copy_src); - safe_VkPushDescriptorSetInfoKHR(); - ~safe_VkPushDescriptorSetInfoKHR(); - void initialize(const VkPushDescriptorSetInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPushDescriptorSetInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkPushDescriptorSetInfoKHR* ptr() { return reinterpret_cast(this); } - VkPushDescriptorSetInfoKHR const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkPushDescriptorSetWithTemplateInfoKHR { - VkStructureType sType; - const void* pNext{}; - VkDescriptorUpdateTemplate descriptorUpdateTemplate; - VkPipelineLayout layout; - uint32_t set; - const void* pData{}; - - safe_VkPushDescriptorSetWithTemplateInfoKHR(const VkPushDescriptorSetWithTemplateInfoKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPushDescriptorSetWithTemplateInfoKHR(const safe_VkPushDescriptorSetWithTemplateInfoKHR& copy_src); - safe_VkPushDescriptorSetWithTemplateInfoKHR& operator=(const safe_VkPushDescriptorSetWithTemplateInfoKHR& copy_src); - safe_VkPushDescriptorSetWithTemplateInfoKHR(); - ~safe_VkPushDescriptorSetWithTemplateInfoKHR(); - void initialize(const VkPushDescriptorSetWithTemplateInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPushDescriptorSetWithTemplateInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkPushDescriptorSetWithTemplateInfoKHR* ptr() { return reinterpret_cast(this); } - VkPushDescriptorSetWithTemplateInfoKHR const* ptr() const { - return reinterpret_cast(this); - } -}; struct safe_VkSetDescriptorBufferOffsetsInfoEXT { VkStructureType sType; const void* pNext{}; @@ -9811,72 +10150,6 @@ struct safe_VkPhysicalDeviceASTCDecodeFeaturesEXT { return reinterpret_cast(this); } }; -struct safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT { - VkStructureType sType; - void* pNext{}; - VkBool32 pipelineRobustness; - - safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(const VkPhysicalDevicePipelineRobustnessFeaturesEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& copy_src); - safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& operator=( - const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& copy_src); - safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(); - ~safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(); - void initialize(const VkPhysicalDevicePipelineRobustnessFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDevicePipelineRobustnessFeaturesEXT* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDevicePipelineRobustnessFeaturesEXT const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT { - VkStructureType sType; - void* pNext{}; - VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessStorageBuffers; - VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessUniformBuffers; - VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessVertexInputs; - VkPipelineRobustnessImageBehaviorEXT defaultRobustnessImages; - - safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(const VkPhysicalDevicePipelineRobustnessPropertiesEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& copy_src); - safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& operator=( - const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& copy_src); - safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(); - ~safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(); - void initialize(const VkPhysicalDevicePipelineRobustnessPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDevicePipelineRobustnessPropertiesEXT* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDevicePipelineRobustnessPropertiesEXT const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkPipelineRobustnessCreateInfoEXT { - VkStructureType sType; - const void* pNext{}; - VkPipelineRobustnessBufferBehaviorEXT storageBuffers; - VkPipelineRobustnessBufferBehaviorEXT uniformBuffers; - VkPipelineRobustnessBufferBehaviorEXT vertexInputs; - VkPipelineRobustnessImageBehaviorEXT images; - - safe_VkPipelineRobustnessCreateInfoEXT(const VkPipelineRobustnessCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkPipelineRobustnessCreateInfoEXT(const safe_VkPipelineRobustnessCreateInfoEXT& copy_src); - safe_VkPipelineRobustnessCreateInfoEXT& operator=(const safe_VkPipelineRobustnessCreateInfoEXT& copy_src); - safe_VkPipelineRobustnessCreateInfoEXT(); - ~safe_VkPipelineRobustnessCreateInfoEXT(); - void initialize(const VkPipelineRobustnessCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPipelineRobustnessCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkPipelineRobustnessCreateInfoEXT* ptr() { return reinterpret_cast(this); } - VkPipelineRobustnessCreateInfoEXT const* ptr() const { - return reinterpret_cast(this); - } -}; struct safe_VkConditionalRenderingBeginInfoEXT { VkStructureType sType; const void* pNext{}; @@ -12817,207 +13090,6 @@ struct safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT { return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceHostImageCopyFeaturesEXT { - VkStructureType sType; - void* pNext{}; - VkBool32 hostImageCopy; - - safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(const VkPhysicalDeviceHostImageCopyFeaturesEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& copy_src); - safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& operator=(const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& copy_src); - safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(); - ~safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(); - void initialize(const VkPhysicalDeviceHostImageCopyFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceHostImageCopyFeaturesEXT* ptr() { return reinterpret_cast(this); } - VkPhysicalDeviceHostImageCopyFeaturesEXT const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkPhysicalDeviceHostImageCopyPropertiesEXT { - VkStructureType sType; - void* pNext{}; - uint32_t copySrcLayoutCount; - VkImageLayout* pCopySrcLayouts{}; - uint32_t copyDstLayoutCount; - VkImageLayout* pCopyDstLayouts{}; - uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE]; - VkBool32 identicalMemoryTypeRequirements; - - safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(const VkPhysicalDeviceHostImageCopyPropertiesEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& copy_src); - safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& operator=(const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& copy_src); - safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(); - ~safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(); - void initialize(const VkPhysicalDeviceHostImageCopyPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceHostImageCopyPropertiesEXT* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDeviceHostImageCopyPropertiesEXT const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkMemoryToImageCopyEXT { - VkStructureType sType; - const void* pNext{}; - const void* pHostPointer{}; - uint32_t memoryRowLength; - uint32_t memoryImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; - - safe_VkMemoryToImageCopyEXT(const VkMemoryToImageCopyEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkMemoryToImageCopyEXT(const safe_VkMemoryToImageCopyEXT& copy_src); - safe_VkMemoryToImageCopyEXT& operator=(const safe_VkMemoryToImageCopyEXT& copy_src); - safe_VkMemoryToImageCopyEXT(); - ~safe_VkMemoryToImageCopyEXT(); - void initialize(const VkMemoryToImageCopyEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkMemoryToImageCopyEXT* copy_src, PNextCopyState* copy_state = {}); - VkMemoryToImageCopyEXT* ptr() { return reinterpret_cast(this); } - VkMemoryToImageCopyEXT const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkImageToMemoryCopyEXT { - VkStructureType sType; - const void* pNext{}; - void* pHostPointer{}; - uint32_t memoryRowLength; - uint32_t memoryImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; - - safe_VkImageToMemoryCopyEXT(const VkImageToMemoryCopyEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkImageToMemoryCopyEXT(const safe_VkImageToMemoryCopyEXT& copy_src); - safe_VkImageToMemoryCopyEXT& operator=(const safe_VkImageToMemoryCopyEXT& copy_src); - safe_VkImageToMemoryCopyEXT(); - ~safe_VkImageToMemoryCopyEXT(); - void initialize(const VkImageToMemoryCopyEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkImageToMemoryCopyEXT* copy_src, PNextCopyState* copy_state = {}); - VkImageToMemoryCopyEXT* ptr() { return reinterpret_cast(this); } - VkImageToMemoryCopyEXT const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkCopyMemoryToImageInfoEXT { - VkStructureType sType; - const void* pNext{}; - VkHostImageCopyFlagsEXT flags; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - safe_VkMemoryToImageCopyEXT* pRegions{}; - - safe_VkCopyMemoryToImageInfoEXT(const VkCopyMemoryToImageInfoEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkCopyMemoryToImageInfoEXT(const safe_VkCopyMemoryToImageInfoEXT& copy_src); - safe_VkCopyMemoryToImageInfoEXT& operator=(const safe_VkCopyMemoryToImageInfoEXT& copy_src); - safe_VkCopyMemoryToImageInfoEXT(); - ~safe_VkCopyMemoryToImageInfoEXT(); - void initialize(const VkCopyMemoryToImageInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkCopyMemoryToImageInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkCopyMemoryToImageInfoEXT* ptr() { return reinterpret_cast(this); } - VkCopyMemoryToImageInfoEXT const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkCopyImageToMemoryInfoEXT { - VkStructureType sType; - const void* pNext{}; - VkHostImageCopyFlagsEXT flags; - VkImage srcImage; - VkImageLayout srcImageLayout; - uint32_t regionCount; - safe_VkImageToMemoryCopyEXT* pRegions{}; - - safe_VkCopyImageToMemoryInfoEXT(const VkCopyImageToMemoryInfoEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkCopyImageToMemoryInfoEXT(const safe_VkCopyImageToMemoryInfoEXT& copy_src); - safe_VkCopyImageToMemoryInfoEXT& operator=(const safe_VkCopyImageToMemoryInfoEXT& copy_src); - safe_VkCopyImageToMemoryInfoEXT(); - ~safe_VkCopyImageToMemoryInfoEXT(); - void initialize(const VkCopyImageToMemoryInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkCopyImageToMemoryInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkCopyImageToMemoryInfoEXT* ptr() { return reinterpret_cast(this); } - VkCopyImageToMemoryInfoEXT const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkCopyImageToImageInfoEXT { - VkStructureType sType; - const void* pNext{}; - VkHostImageCopyFlagsEXT flags; - VkImage srcImage; - VkImageLayout srcImageLayout; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - safe_VkImageCopy2* pRegions{}; - - safe_VkCopyImageToImageInfoEXT(const VkCopyImageToImageInfoEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkCopyImageToImageInfoEXT(const safe_VkCopyImageToImageInfoEXT& copy_src); - safe_VkCopyImageToImageInfoEXT& operator=(const safe_VkCopyImageToImageInfoEXT& copy_src); - safe_VkCopyImageToImageInfoEXT(); - ~safe_VkCopyImageToImageInfoEXT(); - void initialize(const VkCopyImageToImageInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkCopyImageToImageInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkCopyImageToImageInfoEXT* ptr() { return reinterpret_cast(this); } - VkCopyImageToImageInfoEXT const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkHostImageLayoutTransitionInfoEXT { - VkStructureType sType; - const void* pNext{}; - VkImage image; - VkImageLayout oldLayout; - VkImageLayout newLayout; - VkImageSubresourceRange subresourceRange; - - safe_VkHostImageLayoutTransitionInfoEXT(const VkHostImageLayoutTransitionInfoEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkHostImageLayoutTransitionInfoEXT(const safe_VkHostImageLayoutTransitionInfoEXT& copy_src); - safe_VkHostImageLayoutTransitionInfoEXT& operator=(const safe_VkHostImageLayoutTransitionInfoEXT& copy_src); - safe_VkHostImageLayoutTransitionInfoEXT(); - ~safe_VkHostImageLayoutTransitionInfoEXT(); - void initialize(const VkHostImageLayoutTransitionInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkHostImageLayoutTransitionInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkHostImageLayoutTransitionInfoEXT* ptr() { return reinterpret_cast(this); } - VkHostImageLayoutTransitionInfoEXT const* ptr() const { - return reinterpret_cast(this); - } -}; -struct safe_VkSubresourceHostMemcpySizeEXT { - VkStructureType sType; - void* pNext{}; - VkDeviceSize size; - - safe_VkSubresourceHostMemcpySizeEXT(const VkSubresourceHostMemcpySizeEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkSubresourceHostMemcpySizeEXT(const safe_VkSubresourceHostMemcpySizeEXT& copy_src); - safe_VkSubresourceHostMemcpySizeEXT& operator=(const safe_VkSubresourceHostMemcpySizeEXT& copy_src); - safe_VkSubresourceHostMemcpySizeEXT(); - ~safe_VkSubresourceHostMemcpySizeEXT(); - void initialize(const VkSubresourceHostMemcpySizeEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkSubresourceHostMemcpySizeEXT* copy_src, PNextCopyState* copy_state = {}); - VkSubresourceHostMemcpySizeEXT* ptr() { return reinterpret_cast(this); } - VkSubresourceHostMemcpySizeEXT const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkHostImageCopyDevicePerformanceQueryEXT { - VkStructureType sType; - void* pNext{}; - VkBool32 optimalDeviceAccess; - VkBool32 identicalMemoryLayout; - - safe_VkHostImageCopyDevicePerformanceQueryEXT(const VkHostImageCopyDevicePerformanceQueryEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkHostImageCopyDevicePerformanceQueryEXT(const safe_VkHostImageCopyDevicePerformanceQueryEXT& copy_src); - safe_VkHostImageCopyDevicePerformanceQueryEXT& operator=(const safe_VkHostImageCopyDevicePerformanceQueryEXT& copy_src); - safe_VkHostImageCopyDevicePerformanceQueryEXT(); - ~safe_VkHostImageCopyDevicePerformanceQueryEXT(); - void initialize(const VkHostImageCopyDevicePerformanceQueryEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkHostImageCopyDevicePerformanceQueryEXT* copy_src, PNextCopyState* copy_state = {}); - VkHostImageCopyDevicePerformanceQueryEXT* ptr() { return reinterpret_cast(this); } - VkHostImageCopyDevicePerformanceQueryEXT const* ptr() const { - return reinterpret_cast(this); - } -}; struct safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT { VkStructureType sType; void* pNext{}; @@ -17674,28 +17746,6 @@ struct safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT { return reinterpret_cast(this); } }; -struct safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT { - VkStructureType sType; - void* pNext{}; - VkBool32 pipelineProtectedAccess; - - safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT( - const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& copy_src); - safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& operator=( - const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& copy_src); - safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(); - ~safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(); - void initialize(const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDevicePipelineProtectedAccessFeaturesEXT const* ptr() const { - return reinterpret_cast(this); - } -}; #ifdef VK_USE_PLATFORM_ANDROID_KHR struct safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID { VkStructureType sType; diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp index f5a10d1..ca9e0d9 100644 --- a/include/vulkan/utility/vk_struct_helper.hpp +++ b/include/vulkan/utility/vk_struct_helper.hpp @@ -232,6 +232,56 @@ template <> inline VkStructureType GetSType inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_MEMORY_MAP_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_RENDERING_AREA_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR; } @@ -330,7 +380,6 @@ template <> inline VkStructureType GetSType() #endif // VK_USE_PLATFORM_WIN32_KHR template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR; } #ifdef VK_USE_PLATFORM_WIN32_KHR @@ -366,18 +415,12 @@ template <> inline VkStructureType GetSType inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; } @@ -387,8 +430,6 @@ template <> inline VkStructureType GetSType() template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PRESENT_ID_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR; } @@ -408,16 +449,7 @@ template <> inline VkStructureType GetSType inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR; } @@ -452,23 +484,7 @@ template <> inline VkStructureType GetSType( template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR; } @@ -522,9 +538,6 @@ template <> inline VkStructureType GetSType() { return #endif // VK_USE_PLATFORM_VI_NN template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT; } @@ -681,16 +694,6 @@ template <> inline VkStructureType GetSType inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT; } @@ -924,7 +927,6 @@ template <> inline VkStructureType GetSType() template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT; } #ifdef VK_USE_PLATFORM_ANDROID_KHR template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID; } diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h index ffa113f..d169a27 100644 --- a/include/vulkan/vk_enum_string_helper.h +++ b/include/vulkan/vk_enum_string_helper.h @@ -64,6 +64,8 @@ static inline const char* string_VkResult(VkResult input_value) { return "VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"; case VK_PIPELINE_COMPILE_REQUIRED: return "VK_PIPELINE_COMPILE_REQUIRED"; + case VK_ERROR_NOT_PERMITTED: + return "VK_ERROR_NOT_PERMITTED"; case VK_ERROR_SURFACE_LOST_KHR: return "VK_ERROR_SURFACE_LOST_KHR"; case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: @@ -92,8 +94,6 @@ static inline const char* string_VkResult(VkResult input_value) { return "VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR"; case VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: return "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT"; - case VK_ERROR_NOT_PERMITTED_KHR: - return "VK_ERROR_NOT_PERMITTED_KHR"; case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: return "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT"; case VK_THREAD_IDLE_KHR: @@ -552,6 +552,106 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS"; case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS: return "VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES"; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: + return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES"; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: + return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES"; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: + return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES"; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: + return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES"; + case VK_STRUCTURE_TYPE_MEMORY_MAP_INFO: + return "VK_STRUCTURE_TYPE_MEMORY_MAP_INFO"; + case VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO: + return "VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES"; + case VK_STRUCTURE_TYPE_RENDERING_AREA_INFO: + return "VK_STRUCTURE_TYPE_RENDERING_AREA_INFO"; + case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO: + return "VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO"; + case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2: + return "VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2"; + case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2: + return "VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2"; + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: + return "VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO"; + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: + return "VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES"; + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: + return "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO"; + case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: + return "VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES"; + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: + return "VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS"; + case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO: + return "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO"; + case VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO: + return "VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO"; + case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO: + return "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO"; + case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO: + return "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES"; + case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: + return "VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES"; + case VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY: + return "VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY"; + case VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY: + return "VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY"; + case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO: + return "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO"; + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO: + return "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO"; + case VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO: + return "VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO"; + case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO: + return "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO"; + case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: + return "VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE"; + case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: + return "VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY"; case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR"; case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR: @@ -750,12 +850,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT"; - case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: - return "VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT"; case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR"; case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: @@ -784,8 +878,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR"; case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR: return "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR"; case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: @@ -1064,12 +1156,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR"; case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR"; - case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: - return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR"; - case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: - return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR"; case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: return "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: @@ -1142,12 +1228,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR"; - case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR: - return "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR"; - case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR: - return "VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: @@ -1216,30 +1296,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR"; case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT"; - case VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT: - return "VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT"; - case VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT: - return "VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT"; - case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT: - return "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT"; - case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT: - return "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT"; - case VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT: - return "VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT"; - case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT: - return "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT"; - case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: - return "VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT"; - case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: - return "VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT"; - case VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR: - return "VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR"; - case VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR: - return "VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT: @@ -1618,8 +1674,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR"; case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: @@ -1730,30 +1784,12 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID"; case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID: return "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR"; - case VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR: - return "VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR"; - case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR: - return "VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR"; - case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR: - return "VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR"; - case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR: - return "VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR"; - case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: - return "VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR"; - case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: - return "VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD"; case VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD: @@ -1914,14 +1950,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR"; - case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: - return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR"; case VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX: return "VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX"; case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX: @@ -1934,32 +1962,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) { return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR"; - case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: - return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR"; case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR: return "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR"; - case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: - return "VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR"; - case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR: - return "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR"; - case VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR: - return "VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR"; - case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR: - return "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR"; - case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR: - return "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR"; case VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT: return "VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT"; case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT: @@ -2110,6 +2114,8 @@ static inline const char* string_VkImageLayout(VkImageLayout input_value) { return "VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL"; case VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL: return "VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL"; + case VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ: + return "VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ"; case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR: return "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR"; case VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR: @@ -2124,8 +2130,6 @@ static inline const char* string_VkImageLayout(VkImageLayout input_value) { return "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"; case VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR: return "VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR"; - case VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR: - return "VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR"; case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR: return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR"; case VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR: @@ -2780,6 +2784,10 @@ static inline const char* string_VkFormat(VkFormat input_value) { return "VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK"; case VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK: return "VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK"; + case VK_FORMAT_A1B5G5R5_UNORM_PACK16: + return "VK_FORMAT_A1B5G5R5_UNORM_PACK16"; + case VK_FORMAT_A8_UNORM: + return "VK_FORMAT_A8_UNORM"; case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: return "VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG"; case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: @@ -2798,10 +2806,6 @@ static inline const char* string_VkFormat(VkFormat input_value) { return "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG"; case VK_FORMAT_R16G16_SFIXED5_NV: return "VK_FORMAT_R16G16_SFIXED5_NV"; - case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR: - return "VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR"; - case VK_FORMAT_A8_UNORM_KHR: - return "VK_FORMAT_A8_UNORM_KHR"; default: return "Unhandled VkFormat"; } @@ -3160,6 +3164,8 @@ static inline const char* string_VkDynamicState(VkDynamicState input_value) { return "VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE"; case VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE: return "VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE"; + case VK_DYNAMIC_STATE_LINE_STIPPLE: + return "VK_DYNAMIC_STATE_LINE_STIPPLE"; case VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV: return "VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV"; case VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT: @@ -3254,8 +3260,6 @@ static inline const char* string_VkDynamicState(VkDynamicState input_value) { return "VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV"; case VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT: 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: @@ -3492,8 +3496,8 @@ static inline const char* string_VkAttachmentLoadOp(VkAttachmentLoadOp input_val return "VK_ATTACHMENT_LOAD_OP_CLEAR"; case VK_ATTACHMENT_LOAD_OP_DONT_CARE: return "VK_ATTACHMENT_LOAD_OP_DONT_CARE"; - case VK_ATTACHMENT_LOAD_OP_NONE_KHR: - return "VK_ATTACHMENT_LOAD_OP_NONE_KHR"; + case VK_ATTACHMENT_LOAD_OP_NONE: + return "VK_ATTACHMENT_LOAD_OP_NONE"; default: return "Unhandled VkAttachmentLoadOp"; } @@ -3544,10 +3548,10 @@ static inline const char* string_VkIndexType(VkIndexType input_value) { return "VK_INDEX_TYPE_UINT16"; case VK_INDEX_TYPE_UINT32: return "VK_INDEX_TYPE_UINT32"; + case VK_INDEX_TYPE_UINT8: + return "VK_INDEX_TYPE_UINT8"; case VK_INDEX_TYPE_NONE_KHR: return "VK_INDEX_TYPE_NONE_KHR"; - case VK_INDEX_TYPE_UINT8_KHR: - return "VK_INDEX_TYPE_UINT8_KHR"; default: return "Unhandled VkIndexType"; } @@ -3624,8 +3628,8 @@ static inline const char* string_VkDescriptorUpdateTemplateType(VkDescriptorUpda switch (input_value) { case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET: return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET"; - case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR: - return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR"; + case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS: + return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS"; default: return "Unhandled VkDescriptorUpdateTemplateType"; } @@ -3726,6 +3730,62 @@ static inline const char* string_VkSemaphoreType(VkSemaphoreType input_value) { return "Unhandled VkSemaphoreType"; } } +static inline const char* string_VkPipelineRobustnessBufferBehavior(VkPipelineRobustnessBufferBehavior input_value) { + switch (input_value) { + case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT: + return "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT"; + case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED: + return "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED"; + case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS: + return "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS"; + case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2: + return "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2"; + default: + return "Unhandled VkPipelineRobustnessBufferBehavior"; + } +} +static inline const char* string_VkPipelineRobustnessImageBehavior(VkPipelineRobustnessImageBehavior input_value) { + switch (input_value) { + case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT: + return "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT"; + case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED: + return "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED"; + case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS: + return "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS"; + case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2: + return "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2"; + default: + return "Unhandled VkPipelineRobustnessImageBehavior"; + } +} +static inline const char* string_VkQueueGlobalPriority(VkQueueGlobalPriority input_value) { + switch (input_value) { + case VK_QUEUE_GLOBAL_PRIORITY_LOW: + return "VK_QUEUE_GLOBAL_PRIORITY_LOW"; + case VK_QUEUE_GLOBAL_PRIORITY_MEDIUM: + return "VK_QUEUE_GLOBAL_PRIORITY_MEDIUM"; + case VK_QUEUE_GLOBAL_PRIORITY_HIGH: + return "VK_QUEUE_GLOBAL_PRIORITY_HIGH"; + case VK_QUEUE_GLOBAL_PRIORITY_REALTIME: + return "VK_QUEUE_GLOBAL_PRIORITY_REALTIME"; + default: + return "Unhandled VkQueueGlobalPriority"; + } +} +static inline const char* string_VkLineRasterizationMode(VkLineRasterizationMode input_value) { + switch (input_value) { + case VK_LINE_RASTERIZATION_MODE_DEFAULT: + return "VK_LINE_RASTERIZATION_MODE_DEFAULT"; + case VK_LINE_RASTERIZATION_MODE_RECTANGULAR: + return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR"; + case VK_LINE_RASTERIZATION_MODE_BRESENHAM: + return "VK_LINE_RASTERIZATION_MODE_BRESENHAM"; + case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH: + return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH"; + default: + return "Unhandled VkLineRasterizationMode"; + } +} static inline const char* string_VkPresentModeKHR(VkPresentModeKHR input_value) { switch (input_value) { case VK_PRESENT_MODE_IMMEDIATE_KHR: @@ -3856,20 +3916,6 @@ static inline const char* string_VkPerformanceCounterStorageKHR(VkPerformanceCou return "Unhandled VkPerformanceCounterStorageKHR"; } } -static inline const char* string_VkQueueGlobalPriorityKHR(VkQueueGlobalPriorityKHR input_value) { - switch (input_value) { - case VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR: - return "VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR"; - case VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR: - return "VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR"; - case VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR: - return "VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR"; - case VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR: - return "VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR"; - default: - return "Unhandled VkQueueGlobalPriorityKHR"; - } -} static inline const char* string_VkFragmentShadingRateCombinerOpKHR(VkFragmentShadingRateCombinerOpKHR input_value) { switch (input_value) { case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR: @@ -3984,20 +4030,6 @@ static inline const char* string_VkVideoEncodeAV1RateControlGroupKHR(VkVideoEnco return "Unhandled VkVideoEncodeAV1RateControlGroupKHR"; } } -static inline const char* string_VkLineRasterizationModeKHR(VkLineRasterizationModeKHR input_value) { - switch (input_value) { - case VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR: - return "VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR"; - case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR: - return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR"; - case VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR: - return "VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR"; - case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR: - return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR"; - default: - return "Unhandled VkLineRasterizationModeKHR"; - } -} static inline const char* string_VkTimeDomainKHR(VkTimeDomainKHR input_value) { switch (input_value) { case VK_TIME_DOMAIN_DEVICE_KHR: @@ -4148,34 +4180,6 @@ static inline const char* string_VkValidationCheckEXT(VkValidationCheckEXT input return "Unhandled VkValidationCheckEXT"; } } -static inline const char* string_VkPipelineRobustnessBufferBehaviorEXT(VkPipelineRobustnessBufferBehaviorEXT input_value) { - switch (input_value) { - case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT: - return "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT"; - case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT: - return "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT"; - case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT: - return "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT"; - case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT: - return "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT"; - default: - return "Unhandled VkPipelineRobustnessBufferBehaviorEXT"; - } -} -static inline const char* string_VkPipelineRobustnessImageBehaviorEXT(VkPipelineRobustnessImageBehaviorEXT input_value) { - switch (input_value) { - case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT: - return "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT"; - case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT: - return "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT"; - case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT: - return "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT"; - case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT: - return "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT"; - default: - return "Unhandled VkPipelineRobustnessImageBehaviorEXT"; - } -} static inline const char* string_VkDisplayPowerStateEXT(VkDisplayPowerStateEXT input_value) { switch (input_value) { case VK_DISPLAY_POWER_STATE_OFF_EXT: @@ -5412,6 +5416,8 @@ static inline const char* string_VkImageUsageFlagBits(VkImageUsageFlagBits input return "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT"; case VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT: return "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT"; + case VK_IMAGE_USAGE_HOST_TRANSFER_BIT: + return "VK_IMAGE_USAGE_HOST_TRANSFER_BIT"; case VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR: return "VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR"; case VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR: @@ -5422,8 +5428,6 @@ static inline const char* string_VkImageUsageFlagBits(VkImageUsageFlagBits input return "VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT"; case VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: return "VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; - case VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT: - return "VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT"; case VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR: return "VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR"; case VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR: @@ -6125,6 +6129,10 @@ static inline const char* string_VkPipelineCreateFlagBits(VkPipelineCreateFlagBi return "VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT"; case VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT: return "VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT"; + case VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT: + return "VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT"; + case VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT: + return "VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT"; case VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR: return "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR"; case VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR: @@ -6171,10 +6179,6 @@ static inline const char* string_VkPipelineCreateFlagBits(VkPipelineCreateFlagBi case VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV: return "VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV"; #endif // VK_ENABLE_BETA_EXTENSIONS - case VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT: - return "VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT"; - case VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT: - return "VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT"; default: return "Unhandled VkPipelineCreateFlagBits"; } @@ -6457,8 +6461,8 @@ static inline const char* string_VkDescriptorSetLayoutCreateFlagBits(VkDescripto switch (input_value) { case VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT: return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT"; - case VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR: - return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR"; + case VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT: + return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT"; case VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT: return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT"; case VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT: @@ -6814,12 +6818,12 @@ static inline const char* string_VkSubgroupFeatureFlagBits(VkSubgroupFeatureFlag return "VK_SUBGROUP_FEATURE_CLUSTERED_BIT"; case VK_SUBGROUP_FEATURE_QUAD_BIT: return "VK_SUBGROUP_FEATURE_QUAD_BIT"; + case VK_SUBGROUP_FEATURE_ROTATE_BIT: + return "VK_SUBGROUP_FEATURE_ROTATE_BIT"; + case VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT: + return "VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT"; case VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV: return "VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV"; - case VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR: - return "VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR"; - case VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR: - return "VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR"; default: return "Unhandled VkSubgroupFeatureFlagBits"; } @@ -7505,7 +7509,6 @@ static inline const char* string_VkFormatFeatureFlagBits2(uint64_t input_value) if (input_value == VK_FORMAT_FEATURE_2_BLIT_SRC_BIT) return "VK_FORMAT_FEATURE_2_BLIT_SRC_BIT"; if (input_value == VK_FORMAT_FEATURE_2_BLIT_DST_BIT) return "VK_FORMAT_FEATURE_2_BLIT_DST_BIT"; if (input_value == VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT) return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT"; - if (input_value == VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT) return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT"; if (input_value == VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT) return "VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT"; if (input_value == VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT) return "VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT"; if (input_value == VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT) return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT"; @@ -7519,12 +7522,13 @@ static inline const char* string_VkFormatFeatureFlagBits2(uint64_t input_value) if (input_value == VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT) return "VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT"; if (input_value == VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT) return "VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT"; if (input_value == VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT) return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT"; + if (input_value == VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT) return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT"; + if (input_value == VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT) return "VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT"; if (input_value == VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR"; if (input_value == VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR"; if (input_value == VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR) return "VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"; if (input_value == VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT) return "VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT"; if (input_value == VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) return "VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; - if (input_value == VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT) return "VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT"; if (input_value == VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR"; if (input_value == VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR"; if (input_value == VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV) return "VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV"; @@ -7556,6 +7560,162 @@ static inline std::string string_VkFormatFeatureFlags2(VkFormatFeatureFlags2 inp return ret; } #endif // __cplusplus +static inline const char* string_VkMemoryUnmapFlagBits(VkMemoryUnmapFlagBits input_value) { + switch (input_value) { + case VK_MEMORY_UNMAP_RESERVE_BIT_EXT: + return "VK_MEMORY_UNMAP_RESERVE_BIT_EXT"; + default: + return "Unhandled VkMemoryUnmapFlagBits"; + } +} + +#ifdef __cplusplus +static inline std::string string_VkMemoryUnmapFlags(VkMemoryUnmapFlags input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkMemoryUnmapFlagBits(static_cast(1U << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkMemoryUnmapFlags(0)"); + return ret; +} +#endif // __cplusplus +static inline const char* string_VkPipelineCreateFlagBits2(uint64_t input_value) { + if (input_value == VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT) return "VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT"; + if (input_value == VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT) return "VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT"; + if (input_value == VK_PIPELINE_CREATE_2_DERIVATIVE_BIT) return "VK_PIPELINE_CREATE_2_DERIVATIVE_BIT"; + if (input_value == VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT) return "VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT"; + if (input_value == VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT) return "VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT"; + if (input_value == VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT) return "VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT"; + if (input_value == VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT) return "VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT"; + if (input_value == VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT) return "VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT"; + if (input_value == VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT) return "VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT"; +#ifdef VK_ENABLE_BETA_EXTENSIONS + if (input_value == VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX) return "VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX"; +#endif // VK_ENABLE_BETA_EXTENSIONS + if (input_value == VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT) return "VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT"; + if (input_value == VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV) return "VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV"; + if (input_value == VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR) return "VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR"; + if (input_value == VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR) return "VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR"; + if (input_value == VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT) return "VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT"; + if (input_value == VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT) return "VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT"; + if (input_value == VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR) return "VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR"; + if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR"; + if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR"; + if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR"; + if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR"; + if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR"; + if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR"; + if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR"; + if (input_value == VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV) return "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV"; + if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV) return "VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV"; + if (input_value == VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) return "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; + if (input_value == VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT) return "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"; + if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT) return "VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT"; + if (input_value == VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) return "VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; + if (input_value == VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) return "VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; + if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV) return "VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV"; + if (input_value == VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT"; + if (input_value == VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR) return "VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR"; + if (input_value == VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT) return "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT"; + return "Unhandled VkPipelineCreateFlagBits2"; +} + +#ifdef __cplusplus +static inline std::string string_VkPipelineCreateFlags2(VkPipelineCreateFlags2 input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkPipelineCreateFlagBits2(static_cast(1ULL << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkPipelineCreateFlags2(0)"); + return ret; +} +#endif // __cplusplus +static inline const char* string_VkBufferUsageFlagBits2(uint64_t input_value) { + if (input_value == VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT) return "VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT"; + if (input_value == VK_BUFFER_USAGE_2_TRANSFER_DST_BIT) return "VK_BUFFER_USAGE_2_TRANSFER_DST_BIT"; + if (input_value == VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT) return "VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT"; + if (input_value == VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT) return "VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT"; + if (input_value == VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT) return "VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT"; + if (input_value == VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT) return "VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT"; + if (input_value == VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT) return "VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT"; + if (input_value == VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT) return "VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT"; + if (input_value == VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT) return "VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT"; + if (input_value == VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT) return "VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT"; +#ifdef VK_ENABLE_BETA_EXTENSIONS + if (input_value == VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX) return "VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX"; +#endif // VK_ENABLE_BETA_EXTENSIONS + if (input_value == VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT) return "VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT"; + if (input_value == VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR) return "VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR"; + if (input_value == VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT"; + if (input_value == VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT"; + if (input_value == VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR"; + if (input_value == VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR"; + if (input_value == VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR"; + if (input_value == VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR"; + if (input_value == VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR) return "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR"; + if (input_value == VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR) return "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR"; + if (input_value == VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT"; + if (input_value == VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT"; + 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 VkBufferUsageFlagBits2"; +} + +#ifdef __cplusplus +static inline std::string string_VkBufferUsageFlags2(VkBufferUsageFlags2 input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkBufferUsageFlagBits2(static_cast(1ULL << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkBufferUsageFlags2(0)"); + return ret; +} +#endif // __cplusplus +static inline const char* string_VkHostImageCopyFlagBits(VkHostImageCopyFlagBits input_value) { + switch (input_value) { + case VK_HOST_IMAGE_COPY_MEMCPY: + return "VK_HOST_IMAGE_COPY_MEMCPY"; + default: + return "Unhandled VkHostImageCopyFlagBits"; + } +} + +#ifdef __cplusplus +static inline std::string string_VkHostImageCopyFlags(VkHostImageCopyFlags input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkHostImageCopyFlagBits(static_cast(1U << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkHostImageCopyFlags(0)"); + return ret; +} +#endif // __cplusplus static inline const char* string_VkSurfaceTransformFlagBitsKHR(VkSurfaceTransformFlagBitsKHR input_value) { switch (input_value) { case VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR: @@ -8392,31 +8552,6 @@ static inline std::string string_VkPerformanceCounterDescriptionFlagsKHR(VkPerfo return ret; } #endif // __cplusplus -static inline const char* string_VkMemoryUnmapFlagBitsKHR(VkMemoryUnmapFlagBitsKHR input_value) { - switch (input_value) { - case VK_MEMORY_UNMAP_RESERVE_BIT_EXT: - return "VK_MEMORY_UNMAP_RESERVE_BIT_EXT"; - default: - return "Unhandled VkMemoryUnmapFlagBitsKHR"; - } -} - -#ifdef __cplusplus -static inline std::string string_VkMemoryUnmapFlagsKHR(VkMemoryUnmapFlagsKHR input_value) { - std::string ret; - int index = 0; - while(input_value) { - if (input_value & 1) { - if( !ret.empty()) ret.append("|"); - ret.append(string_VkMemoryUnmapFlagBitsKHR(static_cast(1U << index))); - } - ++index; - input_value >>= 1; - } - if (ret.empty()) ret.append("VkMemoryUnmapFlagsKHR(0)"); - return ret; -} -#endif // __cplusplus static inline const char* string_VkVideoEncodeFlagBitsKHR(VkVideoEncodeFlagBitsKHR input_value) { switch (input_value) { case VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR: @@ -8599,112 +8734,6 @@ static inline std::string string_VkVideoEncodeContentFlagsKHR(VkVideoEncodeConte return ret; } #endif // __cplusplus -static inline const char* string_VkPipelineCreateFlagBits2KHR(uint64_t input_value) { - if (input_value == VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR) return "VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR"; - if (input_value == VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR) return "VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR"; - if (input_value == VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR) return "VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR"; -#ifdef VK_ENABLE_BETA_EXTENSIONS - if (input_value == VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX) return "VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX"; -#endif // VK_ENABLE_BETA_EXTENSIONS - if (input_value == VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT) return "VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT"; - if (input_value == VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR) return "VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR"; - if (input_value == VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR) return "VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR"; - if (input_value == VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV) return "VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV"; - if (input_value == VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR) return "VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR"; - if (input_value == VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR) return "VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR"; - if (input_value == VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR) return "VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR"; - if (input_value == VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR) return "VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR"; - if (input_value == VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT) return "VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT"; - if (input_value == VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT) return "VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT"; - if (input_value == VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR) return "VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR"; - if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR"; - if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR"; - if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR"; - if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR"; - if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR"; - if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR"; - if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR"; - if (input_value == VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV) return "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV"; - if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV) return "VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV"; - if (input_value == VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) return "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; - if (input_value == VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT) return "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"; - if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT) return "VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT"; - if (input_value == VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) return "VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; - if (input_value == VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) return "VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; - if (input_value == VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT) return "VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT"; - if (input_value == VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT) return "VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT"; - if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV) return "VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV"; - if (input_value == VK_PIPELINE_CREATE_2_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"; -} - -#ifdef __cplusplus -static inline std::string string_VkPipelineCreateFlags2KHR(VkPipelineCreateFlags2KHR input_value) { - std::string ret; - int index = 0; - while(input_value) { - if (input_value & 1) { - if( !ret.empty()) ret.append("|"); - ret.append(string_VkPipelineCreateFlagBits2KHR(static_cast(1ULL << index))); - } - ++index; - input_value >>= 1; - } - if (ret.empty()) ret.append("VkPipelineCreateFlags2KHR(0)"); - return ret; -} -#endif // __cplusplus -static inline const char* string_VkBufferUsageFlagBits2KHR(uint64_t input_value) { - if (input_value == VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR) return "VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR"; - if (input_value == VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR) return "VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR"; - if (input_value == VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR) return "VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR"; - if (input_value == VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR) return "VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR"; - if (input_value == VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR) return "VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR"; - if (input_value == VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR) return "VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR"; - if (input_value == VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR) return "VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR"; - if (input_value == VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR) return "VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR"; - if (input_value == VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR) return "VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR"; -#ifdef VK_ENABLE_BETA_EXTENSIONS - if (input_value == VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX) return "VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX"; -#endif // VK_ENABLE_BETA_EXTENSIONS - if (input_value == VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT) return "VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT"; - if (input_value == VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR) return "VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR"; - if (input_value == VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT"; - if (input_value == VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT"; - if (input_value == VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR"; - if (input_value == VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR"; - if (input_value == VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR"; - if (input_value == VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR"; - if (input_value == VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR) return "VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR"; - if (input_value == VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR) return "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR"; - if (input_value == VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR) return "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR"; - if (input_value == VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT"; - if (input_value == VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT"; - 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"; -} - -#ifdef __cplusplus -static inline std::string string_VkBufferUsageFlags2KHR(VkBufferUsageFlags2KHR input_value) { - std::string ret; - int index = 0; - while(input_value) { - if (input_value & 1) { - if( !ret.empty()) ret.append("|"); - ret.append(string_VkBufferUsageFlagBits2KHR(static_cast(1ULL << index))); - } - ++index; - input_value >>= 1; - } - if (ret.empty()) ret.append("VkBufferUsageFlags2KHR(0)"); - return ret; -} -#endif // __cplusplus static inline const char* string_VkVideoEncodeAV1CapabilityFlagBitsKHR(VkVideoEncodeAV1CapabilityFlagBitsKHR input_value) { switch (input_value) { case VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR: @@ -9141,31 +9170,6 @@ static inline std::string string_VkBuildAccelerationStructureFlagsKHR(VkBuildAcc return ret; } #endif // __cplusplus -static inline const char* string_VkHostImageCopyFlagBitsEXT(VkHostImageCopyFlagBitsEXT input_value) { - switch (input_value) { - case VK_HOST_IMAGE_COPY_MEMCPY_EXT: - return "VK_HOST_IMAGE_COPY_MEMCPY_EXT"; - default: - return "Unhandled VkHostImageCopyFlagBitsEXT"; - } -} - -#ifdef __cplusplus -static inline std::string string_VkHostImageCopyFlagsEXT(VkHostImageCopyFlagsEXT input_value) { - std::string ret; - int index = 0; - while(input_value) { - if (input_value & 1) { - if( !ret.empty()) ret.append("|"); - ret.append(string_VkHostImageCopyFlagBitsEXT(static_cast(1U << index))); - } - ++index; - input_value >>= 1; - } - if (ret.empty()) ret.append("VkHostImageCopyFlagsEXT(0)"); - return ret; -} -#endif // __cplusplus static inline const char* string_VkPresentScalingFlagBitsEXT(VkPresentScalingFlagBitsEXT input_value) { switch (input_value) { case VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT: diff --git a/scripts/generators/safe_struct_generator.py b/scripts/generators/safe_struct_generator.py index e7d8086..282115e 100644 --- a/scripts/generators/safe_struct_generator.py +++ b/scripts/generators/safe_struct_generator.py @@ -487,9 +487,9 @@ def generateSource(self): } } ''', - # TODO: VkPushDescriptorSetWithTemplateInfoKHR needs a custom constructor to handle pData - # https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/7169 - 'VkPushDescriptorSetWithTemplateInfoKHR': ''' + # TODO: VkPushDescriptorSetWithTemplateInfo needs a custom constructor to handle pData + # https://github.com/KhronosGroup/Vulkan-Utility-Libraries/issues/193 + 'VkPushDescriptorSetWithTemplateInfo': ''' ''', } diff --git a/scripts/known_good.json b/scripts/known_good.json index 07e048e..5de8cec 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.302" + "commit": "v1.4.303" }, { "name": "googletest", diff --git a/src/vulkan/vk_safe_struct_core.cpp b/src/vulkan/vk_safe_struct_core.cpp index 21e9108..f99de19 100644 --- a/src/vulkan/vk_safe_struct_core.cpp +++ b/src/vulkan/vk_safe_struct_core.cpp @@ -18768,6 +18768,3820 @@ void safe_VkDeviceImageMemoryRequirements::initialize(const safe_VkDeviceImageMe if (copy_src->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src->pCreateInfo); } +safe_VkPhysicalDeviceVulkan14Features::safe_VkPhysicalDeviceVulkan14Features(const VkPhysicalDeviceVulkan14Features* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + globalPriorityQuery(in_struct->globalPriorityQuery), + shaderSubgroupRotate(in_struct->shaderSubgroupRotate), + shaderSubgroupRotateClustered(in_struct->shaderSubgroupRotateClustered), + shaderFloatControls2(in_struct->shaderFloatControls2), + shaderExpectAssume(in_struct->shaderExpectAssume), + rectangularLines(in_struct->rectangularLines), + bresenhamLines(in_struct->bresenhamLines), + smoothLines(in_struct->smoothLines), + stippledRectangularLines(in_struct->stippledRectangularLines), + stippledBresenhamLines(in_struct->stippledBresenhamLines), + stippledSmoothLines(in_struct->stippledSmoothLines), + vertexAttributeInstanceRateDivisor(in_struct->vertexAttributeInstanceRateDivisor), + vertexAttributeInstanceRateZeroDivisor(in_struct->vertexAttributeInstanceRateZeroDivisor), + indexTypeUint8(in_struct->indexTypeUint8), + dynamicRenderingLocalRead(in_struct->dynamicRenderingLocalRead), + maintenance5(in_struct->maintenance5), + maintenance6(in_struct->maintenance6), + pipelineProtectedAccess(in_struct->pipelineProtectedAccess), + pipelineRobustness(in_struct->pipelineRobustness), + hostImageCopy(in_struct->hostImageCopy), + pushDescriptor(in_struct->pushDescriptor) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceVulkan14Features::safe_VkPhysicalDeviceVulkan14Features() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES), + pNext(nullptr), + globalPriorityQuery(), + shaderSubgroupRotate(), + shaderSubgroupRotateClustered(), + shaderFloatControls2(), + shaderExpectAssume(), + rectangularLines(), + bresenhamLines(), + smoothLines(), + stippledRectangularLines(), + stippledBresenhamLines(), + stippledSmoothLines(), + vertexAttributeInstanceRateDivisor(), + vertexAttributeInstanceRateZeroDivisor(), + indexTypeUint8(), + dynamicRenderingLocalRead(), + maintenance5(), + maintenance6(), + pipelineProtectedAccess(), + pipelineRobustness(), + hostImageCopy(), + pushDescriptor() {} + +safe_VkPhysicalDeviceVulkan14Features::safe_VkPhysicalDeviceVulkan14Features( + const safe_VkPhysicalDeviceVulkan14Features& copy_src) { + sType = copy_src.sType; + globalPriorityQuery = copy_src.globalPriorityQuery; + shaderSubgroupRotate = copy_src.shaderSubgroupRotate; + shaderSubgroupRotateClustered = copy_src.shaderSubgroupRotateClustered; + shaderFloatControls2 = copy_src.shaderFloatControls2; + shaderExpectAssume = copy_src.shaderExpectAssume; + rectangularLines = copy_src.rectangularLines; + bresenhamLines = copy_src.bresenhamLines; + smoothLines = copy_src.smoothLines; + stippledRectangularLines = copy_src.stippledRectangularLines; + stippledBresenhamLines = copy_src.stippledBresenhamLines; + stippledSmoothLines = copy_src.stippledSmoothLines; + vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor; + vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor; + indexTypeUint8 = copy_src.indexTypeUint8; + dynamicRenderingLocalRead = copy_src.dynamicRenderingLocalRead; + maintenance5 = copy_src.maintenance5; + maintenance6 = copy_src.maintenance6; + pipelineProtectedAccess = copy_src.pipelineProtectedAccess; + pipelineRobustness = copy_src.pipelineRobustness; + hostImageCopy = copy_src.hostImageCopy; + pushDescriptor = copy_src.pushDescriptor; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceVulkan14Features& safe_VkPhysicalDeviceVulkan14Features::operator=( + const safe_VkPhysicalDeviceVulkan14Features& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + globalPriorityQuery = copy_src.globalPriorityQuery; + shaderSubgroupRotate = copy_src.shaderSubgroupRotate; + shaderSubgroupRotateClustered = copy_src.shaderSubgroupRotateClustered; + shaderFloatControls2 = copy_src.shaderFloatControls2; + shaderExpectAssume = copy_src.shaderExpectAssume; + rectangularLines = copy_src.rectangularLines; + bresenhamLines = copy_src.bresenhamLines; + smoothLines = copy_src.smoothLines; + stippledRectangularLines = copy_src.stippledRectangularLines; + stippledBresenhamLines = copy_src.stippledBresenhamLines; + stippledSmoothLines = copy_src.stippledSmoothLines; + vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor; + vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor; + indexTypeUint8 = copy_src.indexTypeUint8; + dynamicRenderingLocalRead = copy_src.dynamicRenderingLocalRead; + maintenance5 = copy_src.maintenance5; + maintenance6 = copy_src.maintenance6; + pipelineProtectedAccess = copy_src.pipelineProtectedAccess; + pipelineRobustness = copy_src.pipelineRobustness; + hostImageCopy = copy_src.hostImageCopy; + pushDescriptor = copy_src.pushDescriptor; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceVulkan14Features::~safe_VkPhysicalDeviceVulkan14Features() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceVulkan14Features::initialize(const VkPhysicalDeviceVulkan14Features* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + globalPriorityQuery = in_struct->globalPriorityQuery; + shaderSubgroupRotate = in_struct->shaderSubgroupRotate; + shaderSubgroupRotateClustered = in_struct->shaderSubgroupRotateClustered; + shaderFloatControls2 = in_struct->shaderFloatControls2; + shaderExpectAssume = in_struct->shaderExpectAssume; + rectangularLines = in_struct->rectangularLines; + bresenhamLines = in_struct->bresenhamLines; + smoothLines = in_struct->smoothLines; + stippledRectangularLines = in_struct->stippledRectangularLines; + stippledBresenhamLines = in_struct->stippledBresenhamLines; + stippledSmoothLines = in_struct->stippledSmoothLines; + vertexAttributeInstanceRateDivisor = in_struct->vertexAttributeInstanceRateDivisor; + vertexAttributeInstanceRateZeroDivisor = in_struct->vertexAttributeInstanceRateZeroDivisor; + indexTypeUint8 = in_struct->indexTypeUint8; + dynamicRenderingLocalRead = in_struct->dynamicRenderingLocalRead; + maintenance5 = in_struct->maintenance5; + maintenance6 = in_struct->maintenance6; + pipelineProtectedAccess = in_struct->pipelineProtectedAccess; + pipelineRobustness = in_struct->pipelineRobustness; + hostImageCopy = in_struct->hostImageCopy; + pushDescriptor = in_struct->pushDescriptor; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceVulkan14Features::initialize(const safe_VkPhysicalDeviceVulkan14Features* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + globalPriorityQuery = copy_src->globalPriorityQuery; + shaderSubgroupRotate = copy_src->shaderSubgroupRotate; + shaderSubgroupRotateClustered = copy_src->shaderSubgroupRotateClustered; + shaderFloatControls2 = copy_src->shaderFloatControls2; + shaderExpectAssume = copy_src->shaderExpectAssume; + rectangularLines = copy_src->rectangularLines; + bresenhamLines = copy_src->bresenhamLines; + smoothLines = copy_src->smoothLines; + stippledRectangularLines = copy_src->stippledRectangularLines; + stippledBresenhamLines = copy_src->stippledBresenhamLines; + stippledSmoothLines = copy_src->stippledSmoothLines; + vertexAttributeInstanceRateDivisor = copy_src->vertexAttributeInstanceRateDivisor; + vertexAttributeInstanceRateZeroDivisor = copy_src->vertexAttributeInstanceRateZeroDivisor; + indexTypeUint8 = copy_src->indexTypeUint8; + dynamicRenderingLocalRead = copy_src->dynamicRenderingLocalRead; + maintenance5 = copy_src->maintenance5; + maintenance6 = copy_src->maintenance6; + pipelineProtectedAccess = copy_src->pipelineProtectedAccess; + pipelineRobustness = copy_src->pipelineRobustness; + hostImageCopy = copy_src->hostImageCopy; + pushDescriptor = copy_src->pushDescriptor; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceVulkan14Properties::safe_VkPhysicalDeviceVulkan14Properties( + const VkPhysicalDeviceVulkan14Properties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + lineSubPixelPrecisionBits(in_struct->lineSubPixelPrecisionBits), + maxVertexAttribDivisor(in_struct->maxVertexAttribDivisor), + supportsNonZeroFirstInstance(in_struct->supportsNonZeroFirstInstance), + maxPushDescriptors(in_struct->maxPushDescriptors), + dynamicRenderingLocalReadDepthStencilAttachments(in_struct->dynamicRenderingLocalReadDepthStencilAttachments), + dynamicRenderingLocalReadMultisampledAttachments(in_struct->dynamicRenderingLocalReadMultisampledAttachments), + earlyFragmentMultisampleCoverageAfterSampleCounting(in_struct->earlyFragmentMultisampleCoverageAfterSampleCounting), + earlyFragmentSampleMaskTestBeforeSampleCounting(in_struct->earlyFragmentSampleMaskTestBeforeSampleCounting), + depthStencilSwizzleOneSupport(in_struct->depthStencilSwizzleOneSupport), + polygonModePointSize(in_struct->polygonModePointSize), + nonStrictSinglePixelWideLinesUseParallelogram(in_struct->nonStrictSinglePixelWideLinesUseParallelogram), + nonStrictWideLinesUseParallelogram(in_struct->nonStrictWideLinesUseParallelogram), + blockTexelViewCompatibleMultipleLayers(in_struct->blockTexelViewCompatibleMultipleLayers), + maxCombinedImageSamplerDescriptorCount(in_struct->maxCombinedImageSamplerDescriptorCount), + fragmentShadingRateClampCombinerInputs(in_struct->fragmentShadingRateClampCombinerInputs), + defaultRobustnessStorageBuffers(in_struct->defaultRobustnessStorageBuffers), + defaultRobustnessUniformBuffers(in_struct->defaultRobustnessUniformBuffers), + defaultRobustnessVertexInputs(in_struct->defaultRobustnessVertexInputs), + defaultRobustnessImages(in_struct->defaultRobustnessImages), + copySrcLayoutCount(in_struct->copySrcLayoutCount), + pCopySrcLayouts(nullptr), + copyDstLayoutCount(in_struct->copyDstLayoutCount), + pCopyDstLayouts(nullptr), + identicalMemoryTypeRequirements(in_struct->identicalMemoryTypeRequirements) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pCopySrcLayouts) { + pCopySrcLayouts = new VkImageLayout[in_struct->copySrcLayoutCount]; + memcpy((void*)pCopySrcLayouts, (void*)in_struct->pCopySrcLayouts, sizeof(VkImageLayout) * in_struct->copySrcLayoutCount); + } + + if (in_struct->pCopyDstLayouts) { + pCopyDstLayouts = new VkImageLayout[in_struct->copyDstLayoutCount]; + memcpy((void*)pCopyDstLayouts, (void*)in_struct->pCopyDstLayouts, sizeof(VkImageLayout) * in_struct->copyDstLayoutCount); + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + optimalTilingLayoutUUID[i] = in_struct->optimalTilingLayoutUUID[i]; + } +} + +safe_VkPhysicalDeviceVulkan14Properties::safe_VkPhysicalDeviceVulkan14Properties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES), + pNext(nullptr), + lineSubPixelPrecisionBits(), + maxVertexAttribDivisor(), + supportsNonZeroFirstInstance(), + maxPushDescriptors(), + dynamicRenderingLocalReadDepthStencilAttachments(), + dynamicRenderingLocalReadMultisampledAttachments(), + earlyFragmentMultisampleCoverageAfterSampleCounting(), + earlyFragmentSampleMaskTestBeforeSampleCounting(), + depthStencilSwizzleOneSupport(), + polygonModePointSize(), + nonStrictSinglePixelWideLinesUseParallelogram(), + nonStrictWideLinesUseParallelogram(), + blockTexelViewCompatibleMultipleLayers(), + maxCombinedImageSamplerDescriptorCount(), + fragmentShadingRateClampCombinerInputs(), + defaultRobustnessStorageBuffers(), + defaultRobustnessUniformBuffers(), + defaultRobustnessVertexInputs(), + defaultRobustnessImages(), + copySrcLayoutCount(), + pCopySrcLayouts(nullptr), + copyDstLayoutCount(), + pCopyDstLayouts(nullptr), + identicalMemoryTypeRequirements() {} + +safe_VkPhysicalDeviceVulkan14Properties::safe_VkPhysicalDeviceVulkan14Properties( + const safe_VkPhysicalDeviceVulkan14Properties& copy_src) { + sType = copy_src.sType; + lineSubPixelPrecisionBits = copy_src.lineSubPixelPrecisionBits; + maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor; + supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance; + maxPushDescriptors = copy_src.maxPushDescriptors; + dynamicRenderingLocalReadDepthStencilAttachments = copy_src.dynamicRenderingLocalReadDepthStencilAttachments; + dynamicRenderingLocalReadMultisampledAttachments = copy_src.dynamicRenderingLocalReadMultisampledAttachments; + earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src.earlyFragmentMultisampleCoverageAfterSampleCounting; + earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src.earlyFragmentSampleMaskTestBeforeSampleCounting; + depthStencilSwizzleOneSupport = copy_src.depthStencilSwizzleOneSupport; + polygonModePointSize = copy_src.polygonModePointSize; + nonStrictSinglePixelWideLinesUseParallelogram = copy_src.nonStrictSinglePixelWideLinesUseParallelogram; + nonStrictWideLinesUseParallelogram = copy_src.nonStrictWideLinesUseParallelogram; + blockTexelViewCompatibleMultipleLayers = copy_src.blockTexelViewCompatibleMultipleLayers; + maxCombinedImageSamplerDescriptorCount = copy_src.maxCombinedImageSamplerDescriptorCount; + fragmentShadingRateClampCombinerInputs = copy_src.fragmentShadingRateClampCombinerInputs; + defaultRobustnessStorageBuffers = copy_src.defaultRobustnessStorageBuffers; + defaultRobustnessUniformBuffers = copy_src.defaultRobustnessUniformBuffers; + defaultRobustnessVertexInputs = copy_src.defaultRobustnessVertexInputs; + defaultRobustnessImages = copy_src.defaultRobustnessImages; + copySrcLayoutCount = copy_src.copySrcLayoutCount; + pCopySrcLayouts = nullptr; + copyDstLayoutCount = copy_src.copyDstLayoutCount; + pCopyDstLayouts = nullptr; + identicalMemoryTypeRequirements = copy_src.identicalMemoryTypeRequirements; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pCopySrcLayouts) { + pCopySrcLayouts = new VkImageLayout[copy_src.copySrcLayoutCount]; + memcpy((void*)pCopySrcLayouts, (void*)copy_src.pCopySrcLayouts, sizeof(VkImageLayout) * copy_src.copySrcLayoutCount); + } + + if (copy_src.pCopyDstLayouts) { + pCopyDstLayouts = new VkImageLayout[copy_src.copyDstLayoutCount]; + memcpy((void*)pCopyDstLayouts, (void*)copy_src.pCopyDstLayouts, sizeof(VkImageLayout) * copy_src.copyDstLayoutCount); + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + optimalTilingLayoutUUID[i] = copy_src.optimalTilingLayoutUUID[i]; + } +} + +safe_VkPhysicalDeviceVulkan14Properties& safe_VkPhysicalDeviceVulkan14Properties::operator=( + const safe_VkPhysicalDeviceVulkan14Properties& copy_src) { + if (©_src == this) return *this; + + if (pCopySrcLayouts) delete[] pCopySrcLayouts; + if (pCopyDstLayouts) delete[] pCopyDstLayouts; + FreePnextChain(pNext); + + sType = copy_src.sType; + lineSubPixelPrecisionBits = copy_src.lineSubPixelPrecisionBits; + maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor; + supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance; + maxPushDescriptors = copy_src.maxPushDescriptors; + dynamicRenderingLocalReadDepthStencilAttachments = copy_src.dynamicRenderingLocalReadDepthStencilAttachments; + dynamicRenderingLocalReadMultisampledAttachments = copy_src.dynamicRenderingLocalReadMultisampledAttachments; + earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src.earlyFragmentMultisampleCoverageAfterSampleCounting; + earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src.earlyFragmentSampleMaskTestBeforeSampleCounting; + depthStencilSwizzleOneSupport = copy_src.depthStencilSwizzleOneSupport; + polygonModePointSize = copy_src.polygonModePointSize; + nonStrictSinglePixelWideLinesUseParallelogram = copy_src.nonStrictSinglePixelWideLinesUseParallelogram; + nonStrictWideLinesUseParallelogram = copy_src.nonStrictWideLinesUseParallelogram; + blockTexelViewCompatibleMultipleLayers = copy_src.blockTexelViewCompatibleMultipleLayers; + maxCombinedImageSamplerDescriptorCount = copy_src.maxCombinedImageSamplerDescriptorCount; + fragmentShadingRateClampCombinerInputs = copy_src.fragmentShadingRateClampCombinerInputs; + defaultRobustnessStorageBuffers = copy_src.defaultRobustnessStorageBuffers; + defaultRobustnessUniformBuffers = copy_src.defaultRobustnessUniformBuffers; + defaultRobustnessVertexInputs = copy_src.defaultRobustnessVertexInputs; + defaultRobustnessImages = copy_src.defaultRobustnessImages; + copySrcLayoutCount = copy_src.copySrcLayoutCount; + pCopySrcLayouts = nullptr; + copyDstLayoutCount = copy_src.copyDstLayoutCount; + pCopyDstLayouts = nullptr; + identicalMemoryTypeRequirements = copy_src.identicalMemoryTypeRequirements; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pCopySrcLayouts) { + pCopySrcLayouts = new VkImageLayout[copy_src.copySrcLayoutCount]; + memcpy((void*)pCopySrcLayouts, (void*)copy_src.pCopySrcLayouts, sizeof(VkImageLayout) * copy_src.copySrcLayoutCount); + } + + if (copy_src.pCopyDstLayouts) { + pCopyDstLayouts = new VkImageLayout[copy_src.copyDstLayoutCount]; + memcpy((void*)pCopyDstLayouts, (void*)copy_src.pCopyDstLayouts, sizeof(VkImageLayout) * copy_src.copyDstLayoutCount); + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + optimalTilingLayoutUUID[i] = copy_src.optimalTilingLayoutUUID[i]; + } + + return *this; +} + +safe_VkPhysicalDeviceVulkan14Properties::~safe_VkPhysicalDeviceVulkan14Properties() { + if (pCopySrcLayouts) delete[] pCopySrcLayouts; + if (pCopyDstLayouts) delete[] pCopyDstLayouts; + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceVulkan14Properties::initialize(const VkPhysicalDeviceVulkan14Properties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pCopySrcLayouts) delete[] pCopySrcLayouts; + if (pCopyDstLayouts) delete[] pCopyDstLayouts; + FreePnextChain(pNext); + sType = in_struct->sType; + lineSubPixelPrecisionBits = in_struct->lineSubPixelPrecisionBits; + maxVertexAttribDivisor = in_struct->maxVertexAttribDivisor; + supportsNonZeroFirstInstance = in_struct->supportsNonZeroFirstInstance; + maxPushDescriptors = in_struct->maxPushDescriptors; + dynamicRenderingLocalReadDepthStencilAttachments = in_struct->dynamicRenderingLocalReadDepthStencilAttachments; + dynamicRenderingLocalReadMultisampledAttachments = in_struct->dynamicRenderingLocalReadMultisampledAttachments; + earlyFragmentMultisampleCoverageAfterSampleCounting = in_struct->earlyFragmentMultisampleCoverageAfterSampleCounting; + earlyFragmentSampleMaskTestBeforeSampleCounting = in_struct->earlyFragmentSampleMaskTestBeforeSampleCounting; + depthStencilSwizzleOneSupport = in_struct->depthStencilSwizzleOneSupport; + polygonModePointSize = in_struct->polygonModePointSize; + nonStrictSinglePixelWideLinesUseParallelogram = in_struct->nonStrictSinglePixelWideLinesUseParallelogram; + nonStrictWideLinesUseParallelogram = in_struct->nonStrictWideLinesUseParallelogram; + blockTexelViewCompatibleMultipleLayers = in_struct->blockTexelViewCompatibleMultipleLayers; + maxCombinedImageSamplerDescriptorCount = in_struct->maxCombinedImageSamplerDescriptorCount; + fragmentShadingRateClampCombinerInputs = in_struct->fragmentShadingRateClampCombinerInputs; + defaultRobustnessStorageBuffers = in_struct->defaultRobustnessStorageBuffers; + defaultRobustnessUniformBuffers = in_struct->defaultRobustnessUniformBuffers; + defaultRobustnessVertexInputs = in_struct->defaultRobustnessVertexInputs; + defaultRobustnessImages = in_struct->defaultRobustnessImages; + copySrcLayoutCount = in_struct->copySrcLayoutCount; + pCopySrcLayouts = nullptr; + copyDstLayoutCount = in_struct->copyDstLayoutCount; + pCopyDstLayouts = nullptr; + identicalMemoryTypeRequirements = in_struct->identicalMemoryTypeRequirements; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pCopySrcLayouts) { + pCopySrcLayouts = new VkImageLayout[in_struct->copySrcLayoutCount]; + memcpy((void*)pCopySrcLayouts, (void*)in_struct->pCopySrcLayouts, sizeof(VkImageLayout) * in_struct->copySrcLayoutCount); + } + + if (in_struct->pCopyDstLayouts) { + pCopyDstLayouts = new VkImageLayout[in_struct->copyDstLayoutCount]; + memcpy((void*)pCopyDstLayouts, (void*)in_struct->pCopyDstLayouts, sizeof(VkImageLayout) * in_struct->copyDstLayoutCount); + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + optimalTilingLayoutUUID[i] = in_struct->optimalTilingLayoutUUID[i]; + } +} + +void safe_VkPhysicalDeviceVulkan14Properties::initialize(const safe_VkPhysicalDeviceVulkan14Properties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + lineSubPixelPrecisionBits = copy_src->lineSubPixelPrecisionBits; + maxVertexAttribDivisor = copy_src->maxVertexAttribDivisor; + supportsNonZeroFirstInstance = copy_src->supportsNonZeroFirstInstance; + maxPushDescriptors = copy_src->maxPushDescriptors; + dynamicRenderingLocalReadDepthStencilAttachments = copy_src->dynamicRenderingLocalReadDepthStencilAttachments; + dynamicRenderingLocalReadMultisampledAttachments = copy_src->dynamicRenderingLocalReadMultisampledAttachments; + earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src->earlyFragmentMultisampleCoverageAfterSampleCounting; + earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src->earlyFragmentSampleMaskTestBeforeSampleCounting; + depthStencilSwizzleOneSupport = copy_src->depthStencilSwizzleOneSupport; + polygonModePointSize = copy_src->polygonModePointSize; + nonStrictSinglePixelWideLinesUseParallelogram = copy_src->nonStrictSinglePixelWideLinesUseParallelogram; + nonStrictWideLinesUseParallelogram = copy_src->nonStrictWideLinesUseParallelogram; + blockTexelViewCompatibleMultipleLayers = copy_src->blockTexelViewCompatibleMultipleLayers; + maxCombinedImageSamplerDescriptorCount = copy_src->maxCombinedImageSamplerDescriptorCount; + fragmentShadingRateClampCombinerInputs = copy_src->fragmentShadingRateClampCombinerInputs; + defaultRobustnessStorageBuffers = copy_src->defaultRobustnessStorageBuffers; + defaultRobustnessUniformBuffers = copy_src->defaultRobustnessUniformBuffers; + defaultRobustnessVertexInputs = copy_src->defaultRobustnessVertexInputs; + defaultRobustnessImages = copy_src->defaultRobustnessImages; + copySrcLayoutCount = copy_src->copySrcLayoutCount; + pCopySrcLayouts = nullptr; + copyDstLayoutCount = copy_src->copyDstLayoutCount; + pCopyDstLayouts = nullptr; + identicalMemoryTypeRequirements = copy_src->identicalMemoryTypeRequirements; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pCopySrcLayouts) { + pCopySrcLayouts = new VkImageLayout[copy_src->copySrcLayoutCount]; + memcpy((void*)pCopySrcLayouts, (void*)copy_src->pCopySrcLayouts, sizeof(VkImageLayout) * copy_src->copySrcLayoutCount); + } + + if (copy_src->pCopyDstLayouts) { + pCopyDstLayouts = new VkImageLayout[copy_src->copyDstLayoutCount]; + memcpy((void*)pCopyDstLayouts, (void*)copy_src->pCopyDstLayouts, sizeof(VkImageLayout) * copy_src->copyDstLayoutCount); + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + optimalTilingLayoutUUID[i] = copy_src->optimalTilingLayoutUUID[i]; + } +} + +safe_VkDeviceQueueGlobalPriorityCreateInfo::safe_VkDeviceQueueGlobalPriorityCreateInfo( + const VkDeviceQueueGlobalPriorityCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), globalPriority(in_struct->globalPriority) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDeviceQueueGlobalPriorityCreateInfo::safe_VkDeviceQueueGlobalPriorityCreateInfo() + : sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO), pNext(nullptr), globalPriority() {} + +safe_VkDeviceQueueGlobalPriorityCreateInfo::safe_VkDeviceQueueGlobalPriorityCreateInfo( + const safe_VkDeviceQueueGlobalPriorityCreateInfo& copy_src) { + sType = copy_src.sType; + globalPriority = copy_src.globalPriority; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDeviceQueueGlobalPriorityCreateInfo& safe_VkDeviceQueueGlobalPriorityCreateInfo::operator=( + const safe_VkDeviceQueueGlobalPriorityCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + globalPriority = copy_src.globalPriority; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDeviceQueueGlobalPriorityCreateInfo::~safe_VkDeviceQueueGlobalPriorityCreateInfo() { FreePnextChain(pNext); } + +void safe_VkDeviceQueueGlobalPriorityCreateInfo::initialize(const VkDeviceQueueGlobalPriorityCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + globalPriority = in_struct->globalPriority; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDeviceQueueGlobalPriorityCreateInfo::initialize(const safe_VkDeviceQueueGlobalPriorityCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + globalPriority = copy_src->globalPriority; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceGlobalPriorityQueryFeatures::safe_VkPhysicalDeviceGlobalPriorityQueryFeatures( + const VkPhysicalDeviceGlobalPriorityQueryFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), globalPriorityQuery(in_struct->globalPriorityQuery) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceGlobalPriorityQueryFeatures::safe_VkPhysicalDeviceGlobalPriorityQueryFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES), pNext(nullptr), globalPriorityQuery() {} + +safe_VkPhysicalDeviceGlobalPriorityQueryFeatures::safe_VkPhysicalDeviceGlobalPriorityQueryFeatures( + const safe_VkPhysicalDeviceGlobalPriorityQueryFeatures& copy_src) { + sType = copy_src.sType; + globalPriorityQuery = copy_src.globalPriorityQuery; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceGlobalPriorityQueryFeatures& safe_VkPhysicalDeviceGlobalPriorityQueryFeatures::operator=( + const safe_VkPhysicalDeviceGlobalPriorityQueryFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + globalPriorityQuery = copy_src.globalPriorityQuery; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceGlobalPriorityQueryFeatures::~safe_VkPhysicalDeviceGlobalPriorityQueryFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceGlobalPriorityQueryFeatures::initialize(const VkPhysicalDeviceGlobalPriorityQueryFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + globalPriorityQuery = in_struct->globalPriorityQuery; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceGlobalPriorityQueryFeatures::initialize(const safe_VkPhysicalDeviceGlobalPriorityQueryFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + globalPriorityQuery = copy_src->globalPriorityQuery; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkQueueFamilyGlobalPriorityProperties::safe_VkQueueFamilyGlobalPriorityProperties( + const VkQueueFamilyGlobalPriorityProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), priorityCount(in_struct->priorityCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE; ++i) { + priorities[i] = in_struct->priorities[i]; + } +} + +safe_VkQueueFamilyGlobalPriorityProperties::safe_VkQueueFamilyGlobalPriorityProperties() + : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES), pNext(nullptr), priorityCount() {} + +safe_VkQueueFamilyGlobalPriorityProperties::safe_VkQueueFamilyGlobalPriorityProperties( + const safe_VkQueueFamilyGlobalPriorityProperties& copy_src) { + sType = copy_src.sType; + priorityCount = copy_src.priorityCount; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE; ++i) { + priorities[i] = copy_src.priorities[i]; + } +} + +safe_VkQueueFamilyGlobalPriorityProperties& safe_VkQueueFamilyGlobalPriorityProperties::operator=( + const safe_VkQueueFamilyGlobalPriorityProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + priorityCount = copy_src.priorityCount; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE; ++i) { + priorities[i] = copy_src.priorities[i]; + } + + return *this; +} + +safe_VkQueueFamilyGlobalPriorityProperties::~safe_VkQueueFamilyGlobalPriorityProperties() { FreePnextChain(pNext); } + +void safe_VkQueueFamilyGlobalPriorityProperties::initialize(const VkQueueFamilyGlobalPriorityProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + priorityCount = in_struct->priorityCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE; ++i) { + priorities[i] = in_struct->priorities[i]; + } +} + +void safe_VkQueueFamilyGlobalPriorityProperties::initialize(const safe_VkQueueFamilyGlobalPriorityProperties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + priorityCount = copy_src->priorityCount; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE; ++i) { + priorities[i] = copy_src->priorities[i]; + } +} + +safe_VkPhysicalDeviceShaderSubgroupRotateFeatures::safe_VkPhysicalDeviceShaderSubgroupRotateFeatures( + const VkPhysicalDeviceShaderSubgroupRotateFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shaderSubgroupRotate(in_struct->shaderSubgroupRotate), + shaderSubgroupRotateClustered(in_struct->shaderSubgroupRotateClustered) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderSubgroupRotateFeatures::safe_VkPhysicalDeviceShaderSubgroupRotateFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES), + pNext(nullptr), + shaderSubgroupRotate(), + shaderSubgroupRotateClustered() {} + +safe_VkPhysicalDeviceShaderSubgroupRotateFeatures::safe_VkPhysicalDeviceShaderSubgroupRotateFeatures( + const safe_VkPhysicalDeviceShaderSubgroupRotateFeatures& copy_src) { + sType = copy_src.sType; + shaderSubgroupRotate = copy_src.shaderSubgroupRotate; + shaderSubgroupRotateClustered = copy_src.shaderSubgroupRotateClustered; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderSubgroupRotateFeatures& safe_VkPhysicalDeviceShaderSubgroupRotateFeatures::operator=( + const safe_VkPhysicalDeviceShaderSubgroupRotateFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderSubgroupRotate = copy_src.shaderSubgroupRotate; + shaderSubgroupRotateClustered = copy_src.shaderSubgroupRotateClustered; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderSubgroupRotateFeatures::~safe_VkPhysicalDeviceShaderSubgroupRotateFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderSubgroupRotateFeatures::initialize(const VkPhysicalDeviceShaderSubgroupRotateFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderSubgroupRotate = in_struct->shaderSubgroupRotate; + shaderSubgroupRotateClustered = in_struct->shaderSubgroupRotateClustered; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderSubgroupRotateFeatures::initialize( + const safe_VkPhysicalDeviceShaderSubgroupRotateFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderSubgroupRotate = copy_src->shaderSubgroupRotate; + shaderSubgroupRotateClustered = copy_src->shaderSubgroupRotateClustered; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderFloatControls2Features::safe_VkPhysicalDeviceShaderFloatControls2Features( + const VkPhysicalDeviceShaderFloatControls2Features* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), shaderFloatControls2(in_struct->shaderFloatControls2) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderFloatControls2Features::safe_VkPhysicalDeviceShaderFloatControls2Features() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES), pNext(nullptr), shaderFloatControls2() {} + +safe_VkPhysicalDeviceShaderFloatControls2Features::safe_VkPhysicalDeviceShaderFloatControls2Features( + const safe_VkPhysicalDeviceShaderFloatControls2Features& copy_src) { + sType = copy_src.sType; + shaderFloatControls2 = copy_src.shaderFloatControls2; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderFloatControls2Features& safe_VkPhysicalDeviceShaderFloatControls2Features::operator=( + const safe_VkPhysicalDeviceShaderFloatControls2Features& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderFloatControls2 = copy_src.shaderFloatControls2; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderFloatControls2Features::~safe_VkPhysicalDeviceShaderFloatControls2Features() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderFloatControls2Features::initialize(const VkPhysicalDeviceShaderFloatControls2Features* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderFloatControls2 = in_struct->shaderFloatControls2; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderFloatControls2Features::initialize( + const safe_VkPhysicalDeviceShaderFloatControls2Features* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderFloatControls2 = copy_src->shaderFloatControls2; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderExpectAssumeFeatures::safe_VkPhysicalDeviceShaderExpectAssumeFeatures( + const VkPhysicalDeviceShaderExpectAssumeFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), shaderExpectAssume(in_struct->shaderExpectAssume) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderExpectAssumeFeatures::safe_VkPhysicalDeviceShaderExpectAssumeFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES), pNext(nullptr), shaderExpectAssume() {} + +safe_VkPhysicalDeviceShaderExpectAssumeFeatures::safe_VkPhysicalDeviceShaderExpectAssumeFeatures( + const safe_VkPhysicalDeviceShaderExpectAssumeFeatures& copy_src) { + sType = copy_src.sType; + shaderExpectAssume = copy_src.shaderExpectAssume; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderExpectAssumeFeatures& safe_VkPhysicalDeviceShaderExpectAssumeFeatures::operator=( + const safe_VkPhysicalDeviceShaderExpectAssumeFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderExpectAssume = copy_src.shaderExpectAssume; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderExpectAssumeFeatures::~safe_VkPhysicalDeviceShaderExpectAssumeFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderExpectAssumeFeatures::initialize(const VkPhysicalDeviceShaderExpectAssumeFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderExpectAssume = in_struct->shaderExpectAssume; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderExpectAssumeFeatures::initialize(const safe_VkPhysicalDeviceShaderExpectAssumeFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderExpectAssume = copy_src->shaderExpectAssume; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceLineRasterizationFeatures::safe_VkPhysicalDeviceLineRasterizationFeatures( + const VkPhysicalDeviceLineRasterizationFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + rectangularLines(in_struct->rectangularLines), + bresenhamLines(in_struct->bresenhamLines), + smoothLines(in_struct->smoothLines), + stippledRectangularLines(in_struct->stippledRectangularLines), + stippledBresenhamLines(in_struct->stippledBresenhamLines), + stippledSmoothLines(in_struct->stippledSmoothLines) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceLineRasterizationFeatures::safe_VkPhysicalDeviceLineRasterizationFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES), + pNext(nullptr), + rectangularLines(), + bresenhamLines(), + smoothLines(), + stippledRectangularLines(), + stippledBresenhamLines(), + stippledSmoothLines() {} + +safe_VkPhysicalDeviceLineRasterizationFeatures::safe_VkPhysicalDeviceLineRasterizationFeatures( + const safe_VkPhysicalDeviceLineRasterizationFeatures& copy_src) { + sType = copy_src.sType; + rectangularLines = copy_src.rectangularLines; + bresenhamLines = copy_src.bresenhamLines; + smoothLines = copy_src.smoothLines; + stippledRectangularLines = copy_src.stippledRectangularLines; + stippledBresenhamLines = copy_src.stippledBresenhamLines; + stippledSmoothLines = copy_src.stippledSmoothLines; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceLineRasterizationFeatures& safe_VkPhysicalDeviceLineRasterizationFeatures::operator=( + const safe_VkPhysicalDeviceLineRasterizationFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + rectangularLines = copy_src.rectangularLines; + bresenhamLines = copy_src.bresenhamLines; + smoothLines = copy_src.smoothLines; + stippledRectangularLines = copy_src.stippledRectangularLines; + stippledBresenhamLines = copy_src.stippledBresenhamLines; + stippledSmoothLines = copy_src.stippledSmoothLines; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceLineRasterizationFeatures::~safe_VkPhysicalDeviceLineRasterizationFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceLineRasterizationFeatures::initialize(const VkPhysicalDeviceLineRasterizationFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + rectangularLines = in_struct->rectangularLines; + bresenhamLines = in_struct->bresenhamLines; + smoothLines = in_struct->smoothLines; + stippledRectangularLines = in_struct->stippledRectangularLines; + stippledBresenhamLines = in_struct->stippledBresenhamLines; + stippledSmoothLines = in_struct->stippledSmoothLines; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceLineRasterizationFeatures::initialize(const safe_VkPhysicalDeviceLineRasterizationFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + rectangularLines = copy_src->rectangularLines; + bresenhamLines = copy_src->bresenhamLines; + smoothLines = copy_src->smoothLines; + stippledRectangularLines = copy_src->stippledRectangularLines; + stippledBresenhamLines = copy_src->stippledBresenhamLines; + stippledSmoothLines = copy_src->stippledSmoothLines; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceLineRasterizationProperties::safe_VkPhysicalDeviceLineRasterizationProperties( + const VkPhysicalDeviceLineRasterizationProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), lineSubPixelPrecisionBits(in_struct->lineSubPixelPrecisionBits) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceLineRasterizationProperties::safe_VkPhysicalDeviceLineRasterizationProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES), pNext(nullptr), lineSubPixelPrecisionBits() {} + +safe_VkPhysicalDeviceLineRasterizationProperties::safe_VkPhysicalDeviceLineRasterizationProperties( + const safe_VkPhysicalDeviceLineRasterizationProperties& copy_src) { + sType = copy_src.sType; + lineSubPixelPrecisionBits = copy_src.lineSubPixelPrecisionBits; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceLineRasterizationProperties& safe_VkPhysicalDeviceLineRasterizationProperties::operator=( + const safe_VkPhysicalDeviceLineRasterizationProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + lineSubPixelPrecisionBits = copy_src.lineSubPixelPrecisionBits; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceLineRasterizationProperties::~safe_VkPhysicalDeviceLineRasterizationProperties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceLineRasterizationProperties::initialize(const VkPhysicalDeviceLineRasterizationProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + lineSubPixelPrecisionBits = in_struct->lineSubPixelPrecisionBits; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceLineRasterizationProperties::initialize(const safe_VkPhysicalDeviceLineRasterizationProperties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + lineSubPixelPrecisionBits = copy_src->lineSubPixelPrecisionBits; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineRasterizationLineStateCreateInfo::safe_VkPipelineRasterizationLineStateCreateInfo( + const VkPipelineRasterizationLineStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + lineRasterizationMode(in_struct->lineRasterizationMode), + stippledLineEnable(in_struct->stippledLineEnable), + lineStippleFactor(in_struct->lineStippleFactor), + lineStipplePattern(in_struct->lineStipplePattern) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineRasterizationLineStateCreateInfo::safe_VkPipelineRasterizationLineStateCreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO), + pNext(nullptr), + lineRasterizationMode(), + stippledLineEnable(), + lineStippleFactor(), + lineStipplePattern() {} + +safe_VkPipelineRasterizationLineStateCreateInfo::safe_VkPipelineRasterizationLineStateCreateInfo( + const safe_VkPipelineRasterizationLineStateCreateInfo& copy_src) { + sType = copy_src.sType; + lineRasterizationMode = copy_src.lineRasterizationMode; + stippledLineEnable = copy_src.stippledLineEnable; + lineStippleFactor = copy_src.lineStippleFactor; + lineStipplePattern = copy_src.lineStipplePattern; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineRasterizationLineStateCreateInfo& safe_VkPipelineRasterizationLineStateCreateInfo::operator=( + const safe_VkPipelineRasterizationLineStateCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + lineRasterizationMode = copy_src.lineRasterizationMode; + stippledLineEnable = copy_src.stippledLineEnable; + lineStippleFactor = copy_src.lineStippleFactor; + lineStipplePattern = copy_src.lineStipplePattern; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineRasterizationLineStateCreateInfo::~safe_VkPipelineRasterizationLineStateCreateInfo() { FreePnextChain(pNext); } + +void safe_VkPipelineRasterizationLineStateCreateInfo::initialize(const VkPipelineRasterizationLineStateCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + lineRasterizationMode = in_struct->lineRasterizationMode; + stippledLineEnable = in_struct->stippledLineEnable; + lineStippleFactor = in_struct->lineStippleFactor; + lineStipplePattern = in_struct->lineStipplePattern; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineRasterizationLineStateCreateInfo::initialize(const safe_VkPipelineRasterizationLineStateCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + lineRasterizationMode = copy_src->lineRasterizationMode; + stippledLineEnable = copy_src->stippledLineEnable; + lineStippleFactor = copy_src->lineStippleFactor; + lineStipplePattern = copy_src->lineStipplePattern; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceVertexAttributeDivisorProperties::safe_VkPhysicalDeviceVertexAttributeDivisorProperties( + const VkPhysicalDeviceVertexAttributeDivisorProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + maxVertexAttribDivisor(in_struct->maxVertexAttribDivisor), + supportsNonZeroFirstInstance(in_struct->supportsNonZeroFirstInstance) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceVertexAttributeDivisorProperties::safe_VkPhysicalDeviceVertexAttributeDivisorProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES), + pNext(nullptr), + maxVertexAttribDivisor(), + supportsNonZeroFirstInstance() {} + +safe_VkPhysicalDeviceVertexAttributeDivisorProperties::safe_VkPhysicalDeviceVertexAttributeDivisorProperties( + const safe_VkPhysicalDeviceVertexAttributeDivisorProperties& copy_src) { + sType = copy_src.sType; + maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor; + supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceVertexAttributeDivisorProperties& safe_VkPhysicalDeviceVertexAttributeDivisorProperties::operator=( + const safe_VkPhysicalDeviceVertexAttributeDivisorProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor; + supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceVertexAttributeDivisorProperties::~safe_VkPhysicalDeviceVertexAttributeDivisorProperties() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceVertexAttributeDivisorProperties::initialize( + const VkPhysicalDeviceVertexAttributeDivisorProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxVertexAttribDivisor = in_struct->maxVertexAttribDivisor; + supportsNonZeroFirstInstance = in_struct->supportsNonZeroFirstInstance; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceVertexAttributeDivisorProperties::initialize( + const safe_VkPhysicalDeviceVertexAttributeDivisorProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxVertexAttribDivisor = copy_src->maxVertexAttribDivisor; + supportsNonZeroFirstInstance = copy_src->supportsNonZeroFirstInstance; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineVertexInputDivisorStateCreateInfo::safe_VkPipelineVertexInputDivisorStateCreateInfo( + const VkPipelineVertexInputDivisorStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), vertexBindingDivisorCount(in_struct->vertexBindingDivisorCount), pVertexBindingDivisors(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pVertexBindingDivisors) { + pVertexBindingDivisors = new VkVertexInputBindingDivisorDescription[in_struct->vertexBindingDivisorCount]; + memcpy((void*)pVertexBindingDivisors, (void*)in_struct->pVertexBindingDivisors, + sizeof(VkVertexInputBindingDivisorDescription) * in_struct->vertexBindingDivisorCount); + } +} + +safe_VkPipelineVertexInputDivisorStateCreateInfo::safe_VkPipelineVertexInputDivisorStateCreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO), + pNext(nullptr), + vertexBindingDivisorCount(), + pVertexBindingDivisors(nullptr) {} + +safe_VkPipelineVertexInputDivisorStateCreateInfo::safe_VkPipelineVertexInputDivisorStateCreateInfo( + const safe_VkPipelineVertexInputDivisorStateCreateInfo& copy_src) { + sType = copy_src.sType; + vertexBindingDivisorCount = copy_src.vertexBindingDivisorCount; + pVertexBindingDivisors = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pVertexBindingDivisors) { + pVertexBindingDivisors = new VkVertexInputBindingDivisorDescription[copy_src.vertexBindingDivisorCount]; + memcpy((void*)pVertexBindingDivisors, (void*)copy_src.pVertexBindingDivisors, + sizeof(VkVertexInputBindingDivisorDescription) * copy_src.vertexBindingDivisorCount); + } +} + +safe_VkPipelineVertexInputDivisorStateCreateInfo& safe_VkPipelineVertexInputDivisorStateCreateInfo::operator=( + const safe_VkPipelineVertexInputDivisorStateCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pVertexBindingDivisors) delete[] pVertexBindingDivisors; + FreePnextChain(pNext); + + sType = copy_src.sType; + vertexBindingDivisorCount = copy_src.vertexBindingDivisorCount; + pVertexBindingDivisors = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pVertexBindingDivisors) { + pVertexBindingDivisors = new VkVertexInputBindingDivisorDescription[copy_src.vertexBindingDivisorCount]; + memcpy((void*)pVertexBindingDivisors, (void*)copy_src.pVertexBindingDivisors, + sizeof(VkVertexInputBindingDivisorDescription) * copy_src.vertexBindingDivisorCount); + } + + return *this; +} + +safe_VkPipelineVertexInputDivisorStateCreateInfo::~safe_VkPipelineVertexInputDivisorStateCreateInfo() { + if (pVertexBindingDivisors) delete[] pVertexBindingDivisors; + FreePnextChain(pNext); +} + +void safe_VkPipelineVertexInputDivisorStateCreateInfo::initialize(const VkPipelineVertexInputDivisorStateCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pVertexBindingDivisors) delete[] pVertexBindingDivisors; + FreePnextChain(pNext); + sType = in_struct->sType; + vertexBindingDivisorCount = in_struct->vertexBindingDivisorCount; + pVertexBindingDivisors = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pVertexBindingDivisors) { + pVertexBindingDivisors = new VkVertexInputBindingDivisorDescription[in_struct->vertexBindingDivisorCount]; + memcpy((void*)pVertexBindingDivisors, (void*)in_struct->pVertexBindingDivisors, + sizeof(VkVertexInputBindingDivisorDescription) * in_struct->vertexBindingDivisorCount); + } +} + +void safe_VkPipelineVertexInputDivisorStateCreateInfo::initialize(const safe_VkPipelineVertexInputDivisorStateCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + vertexBindingDivisorCount = copy_src->vertexBindingDivisorCount; + pVertexBindingDivisors = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pVertexBindingDivisors) { + pVertexBindingDivisors = new VkVertexInputBindingDivisorDescription[copy_src->vertexBindingDivisorCount]; + memcpy((void*)pVertexBindingDivisors, (void*)copy_src->pVertexBindingDivisors, + sizeof(VkVertexInputBindingDivisorDescription) * copy_src->vertexBindingDivisorCount); + } +} + +safe_VkPhysicalDeviceVertexAttributeDivisorFeatures::safe_VkPhysicalDeviceVertexAttributeDivisorFeatures( + const VkPhysicalDeviceVertexAttributeDivisorFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + vertexAttributeInstanceRateDivisor(in_struct->vertexAttributeInstanceRateDivisor), + vertexAttributeInstanceRateZeroDivisor(in_struct->vertexAttributeInstanceRateZeroDivisor) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceVertexAttributeDivisorFeatures::safe_VkPhysicalDeviceVertexAttributeDivisorFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES), + pNext(nullptr), + vertexAttributeInstanceRateDivisor(), + vertexAttributeInstanceRateZeroDivisor() {} + +safe_VkPhysicalDeviceVertexAttributeDivisorFeatures::safe_VkPhysicalDeviceVertexAttributeDivisorFeatures( + const safe_VkPhysicalDeviceVertexAttributeDivisorFeatures& copy_src) { + sType = copy_src.sType; + vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor; + vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceVertexAttributeDivisorFeatures& safe_VkPhysicalDeviceVertexAttributeDivisorFeatures::operator=( + const safe_VkPhysicalDeviceVertexAttributeDivisorFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor; + vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceVertexAttributeDivisorFeatures::~safe_VkPhysicalDeviceVertexAttributeDivisorFeatures() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceVertexAttributeDivisorFeatures::initialize( + const VkPhysicalDeviceVertexAttributeDivisorFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + vertexAttributeInstanceRateDivisor = in_struct->vertexAttributeInstanceRateDivisor; + vertexAttributeInstanceRateZeroDivisor = in_struct->vertexAttributeInstanceRateZeroDivisor; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceVertexAttributeDivisorFeatures::initialize( + const safe_VkPhysicalDeviceVertexAttributeDivisorFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + vertexAttributeInstanceRateDivisor = copy_src->vertexAttributeInstanceRateDivisor; + vertexAttributeInstanceRateZeroDivisor = copy_src->vertexAttributeInstanceRateZeroDivisor; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceIndexTypeUint8Features::safe_VkPhysicalDeviceIndexTypeUint8Features( + const VkPhysicalDeviceIndexTypeUint8Features* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), indexTypeUint8(in_struct->indexTypeUint8) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceIndexTypeUint8Features::safe_VkPhysicalDeviceIndexTypeUint8Features() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES), pNext(nullptr), indexTypeUint8() {} + +safe_VkPhysicalDeviceIndexTypeUint8Features::safe_VkPhysicalDeviceIndexTypeUint8Features( + const safe_VkPhysicalDeviceIndexTypeUint8Features& copy_src) { + sType = copy_src.sType; + indexTypeUint8 = copy_src.indexTypeUint8; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceIndexTypeUint8Features& safe_VkPhysicalDeviceIndexTypeUint8Features::operator=( + const safe_VkPhysicalDeviceIndexTypeUint8Features& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + indexTypeUint8 = copy_src.indexTypeUint8; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceIndexTypeUint8Features::~safe_VkPhysicalDeviceIndexTypeUint8Features() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceIndexTypeUint8Features::initialize(const VkPhysicalDeviceIndexTypeUint8Features* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + indexTypeUint8 = in_struct->indexTypeUint8; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceIndexTypeUint8Features::initialize(const safe_VkPhysicalDeviceIndexTypeUint8Features* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + indexTypeUint8 = copy_src->indexTypeUint8; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMemoryMapInfo::safe_VkMemoryMapInfo(const VkMemoryMapInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + memory(in_struct->memory), + offset(in_struct->offset), + size(in_struct->size) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMemoryMapInfo::safe_VkMemoryMapInfo() + : sType(VK_STRUCTURE_TYPE_MEMORY_MAP_INFO), pNext(nullptr), flags(), memory(), offset(), size() {} + +safe_VkMemoryMapInfo::safe_VkMemoryMapInfo(const safe_VkMemoryMapInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + memory = copy_src.memory; + offset = copy_src.offset; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryMapInfo& safe_VkMemoryMapInfo::operator=(const safe_VkMemoryMapInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + memory = copy_src.memory; + offset = copy_src.offset; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryMapInfo::~safe_VkMemoryMapInfo() { FreePnextChain(pNext); } + +void safe_VkMemoryMapInfo::initialize(const VkMemoryMapInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + memory = in_struct->memory; + offset = in_struct->offset; + size = in_struct->size; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryMapInfo::initialize(const safe_VkMemoryMapInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + memory = copy_src->memory; + offset = copy_src->offset; + size = copy_src->size; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMemoryUnmapInfo::safe_VkMemoryUnmapInfo(const VkMemoryUnmapInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), memory(in_struct->memory) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMemoryUnmapInfo::safe_VkMemoryUnmapInfo() : sType(VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO), pNext(nullptr), flags(), memory() {} + +safe_VkMemoryUnmapInfo::safe_VkMemoryUnmapInfo(const safe_VkMemoryUnmapInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + memory = copy_src.memory; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryUnmapInfo& safe_VkMemoryUnmapInfo::operator=(const safe_VkMemoryUnmapInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + memory = copy_src.memory; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryUnmapInfo::~safe_VkMemoryUnmapInfo() { FreePnextChain(pNext); } + +void safe_VkMemoryUnmapInfo::initialize(const VkMemoryUnmapInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + memory = in_struct->memory; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryUnmapInfo::initialize(const safe_VkMemoryUnmapInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + memory = copy_src->memory; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMaintenance5Features::safe_VkPhysicalDeviceMaintenance5Features( + const VkPhysicalDeviceMaintenance5Features* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), maintenance5(in_struct->maintenance5) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMaintenance5Features::safe_VkPhysicalDeviceMaintenance5Features() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES), pNext(nullptr), maintenance5() {} + +safe_VkPhysicalDeviceMaintenance5Features::safe_VkPhysicalDeviceMaintenance5Features( + const safe_VkPhysicalDeviceMaintenance5Features& copy_src) { + sType = copy_src.sType; + maintenance5 = copy_src.maintenance5; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMaintenance5Features& safe_VkPhysicalDeviceMaintenance5Features::operator=( + const safe_VkPhysicalDeviceMaintenance5Features& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maintenance5 = copy_src.maintenance5; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMaintenance5Features::~safe_VkPhysicalDeviceMaintenance5Features() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMaintenance5Features::initialize(const VkPhysicalDeviceMaintenance5Features* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maintenance5 = in_struct->maintenance5; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMaintenance5Features::initialize(const safe_VkPhysicalDeviceMaintenance5Features* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maintenance5 = copy_src->maintenance5; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMaintenance5Properties::safe_VkPhysicalDeviceMaintenance5Properties( + const VkPhysicalDeviceMaintenance5Properties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + earlyFragmentMultisampleCoverageAfterSampleCounting(in_struct->earlyFragmentMultisampleCoverageAfterSampleCounting), + earlyFragmentSampleMaskTestBeforeSampleCounting(in_struct->earlyFragmentSampleMaskTestBeforeSampleCounting), + depthStencilSwizzleOneSupport(in_struct->depthStencilSwizzleOneSupport), + polygonModePointSize(in_struct->polygonModePointSize), + nonStrictSinglePixelWideLinesUseParallelogram(in_struct->nonStrictSinglePixelWideLinesUseParallelogram), + nonStrictWideLinesUseParallelogram(in_struct->nonStrictWideLinesUseParallelogram) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMaintenance5Properties::safe_VkPhysicalDeviceMaintenance5Properties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES), + pNext(nullptr), + earlyFragmentMultisampleCoverageAfterSampleCounting(), + earlyFragmentSampleMaskTestBeforeSampleCounting(), + depthStencilSwizzleOneSupport(), + polygonModePointSize(), + nonStrictSinglePixelWideLinesUseParallelogram(), + nonStrictWideLinesUseParallelogram() {} + +safe_VkPhysicalDeviceMaintenance5Properties::safe_VkPhysicalDeviceMaintenance5Properties( + const safe_VkPhysicalDeviceMaintenance5Properties& copy_src) { + sType = copy_src.sType; + earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src.earlyFragmentMultisampleCoverageAfterSampleCounting; + earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src.earlyFragmentSampleMaskTestBeforeSampleCounting; + depthStencilSwizzleOneSupport = copy_src.depthStencilSwizzleOneSupport; + polygonModePointSize = copy_src.polygonModePointSize; + nonStrictSinglePixelWideLinesUseParallelogram = copy_src.nonStrictSinglePixelWideLinesUseParallelogram; + nonStrictWideLinesUseParallelogram = copy_src.nonStrictWideLinesUseParallelogram; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMaintenance5Properties& safe_VkPhysicalDeviceMaintenance5Properties::operator=( + const safe_VkPhysicalDeviceMaintenance5Properties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src.earlyFragmentMultisampleCoverageAfterSampleCounting; + earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src.earlyFragmentSampleMaskTestBeforeSampleCounting; + depthStencilSwizzleOneSupport = copy_src.depthStencilSwizzleOneSupport; + polygonModePointSize = copy_src.polygonModePointSize; + nonStrictSinglePixelWideLinesUseParallelogram = copy_src.nonStrictSinglePixelWideLinesUseParallelogram; + nonStrictWideLinesUseParallelogram = copy_src.nonStrictWideLinesUseParallelogram; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMaintenance5Properties::~safe_VkPhysicalDeviceMaintenance5Properties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMaintenance5Properties::initialize(const VkPhysicalDeviceMaintenance5Properties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + earlyFragmentMultisampleCoverageAfterSampleCounting = in_struct->earlyFragmentMultisampleCoverageAfterSampleCounting; + earlyFragmentSampleMaskTestBeforeSampleCounting = in_struct->earlyFragmentSampleMaskTestBeforeSampleCounting; + depthStencilSwizzleOneSupport = in_struct->depthStencilSwizzleOneSupport; + polygonModePointSize = in_struct->polygonModePointSize; + nonStrictSinglePixelWideLinesUseParallelogram = in_struct->nonStrictSinglePixelWideLinesUseParallelogram; + nonStrictWideLinesUseParallelogram = in_struct->nonStrictWideLinesUseParallelogram; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMaintenance5Properties::initialize(const safe_VkPhysicalDeviceMaintenance5Properties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src->earlyFragmentMultisampleCoverageAfterSampleCounting; + earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src->earlyFragmentSampleMaskTestBeforeSampleCounting; + depthStencilSwizzleOneSupport = copy_src->depthStencilSwizzleOneSupport; + polygonModePointSize = copy_src->polygonModePointSize; + nonStrictSinglePixelWideLinesUseParallelogram = copy_src->nonStrictSinglePixelWideLinesUseParallelogram; + nonStrictWideLinesUseParallelogram = copy_src->nonStrictWideLinesUseParallelogram; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkRenderingAreaInfo::safe_VkRenderingAreaInfo(const VkRenderingAreaInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + viewMask(in_struct->viewMask), + colorAttachmentCount(in_struct->colorAttachmentCount), + pColorAttachmentFormats(nullptr), + depthAttachmentFormat(in_struct->depthAttachmentFormat), + stencilAttachmentFormat(in_struct->stencilAttachmentFormat) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pColorAttachmentFormats) { + pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount]; + memcpy((void*)pColorAttachmentFormats, (void*)in_struct->pColorAttachmentFormats, + sizeof(VkFormat) * in_struct->colorAttachmentCount); + } +} + +safe_VkRenderingAreaInfo::safe_VkRenderingAreaInfo() + : sType(VK_STRUCTURE_TYPE_RENDERING_AREA_INFO), + pNext(nullptr), + viewMask(), + colorAttachmentCount(), + pColorAttachmentFormats(nullptr), + depthAttachmentFormat(), + stencilAttachmentFormat() {} + +safe_VkRenderingAreaInfo::safe_VkRenderingAreaInfo(const safe_VkRenderingAreaInfo& copy_src) { + sType = copy_src.sType; + viewMask = copy_src.viewMask; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachmentFormats = nullptr; + depthAttachmentFormat = copy_src.depthAttachmentFormat; + stencilAttachmentFormat = copy_src.stencilAttachmentFormat; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pColorAttachmentFormats) { + pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount]; + memcpy((void*)pColorAttachmentFormats, (void*)copy_src.pColorAttachmentFormats, + sizeof(VkFormat) * copy_src.colorAttachmentCount); + } +} + +safe_VkRenderingAreaInfo& safe_VkRenderingAreaInfo::operator=(const safe_VkRenderingAreaInfo& copy_src) { + if (©_src == this) return *this; + + if (pColorAttachmentFormats) delete[] pColorAttachmentFormats; + FreePnextChain(pNext); + + sType = copy_src.sType; + viewMask = copy_src.viewMask; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachmentFormats = nullptr; + depthAttachmentFormat = copy_src.depthAttachmentFormat; + stencilAttachmentFormat = copy_src.stencilAttachmentFormat; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pColorAttachmentFormats) { + pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount]; + memcpy((void*)pColorAttachmentFormats, (void*)copy_src.pColorAttachmentFormats, + sizeof(VkFormat) * copy_src.colorAttachmentCount); + } + + return *this; +} + +safe_VkRenderingAreaInfo::~safe_VkRenderingAreaInfo() { + if (pColorAttachmentFormats) delete[] pColorAttachmentFormats; + FreePnextChain(pNext); +} + +void safe_VkRenderingAreaInfo::initialize(const VkRenderingAreaInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pColorAttachmentFormats) delete[] pColorAttachmentFormats; + FreePnextChain(pNext); + sType = in_struct->sType; + viewMask = in_struct->viewMask; + colorAttachmentCount = in_struct->colorAttachmentCount; + pColorAttachmentFormats = nullptr; + depthAttachmentFormat = in_struct->depthAttachmentFormat; + stencilAttachmentFormat = in_struct->stencilAttachmentFormat; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pColorAttachmentFormats) { + pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount]; + memcpy((void*)pColorAttachmentFormats, (void*)in_struct->pColorAttachmentFormats, + sizeof(VkFormat) * in_struct->colorAttachmentCount); + } +} + +void safe_VkRenderingAreaInfo::initialize(const safe_VkRenderingAreaInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + viewMask = copy_src->viewMask; + colorAttachmentCount = copy_src->colorAttachmentCount; + pColorAttachmentFormats = nullptr; + depthAttachmentFormat = copy_src->depthAttachmentFormat; + stencilAttachmentFormat = copy_src->stencilAttachmentFormat; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pColorAttachmentFormats) { + pColorAttachmentFormats = new VkFormat[copy_src->colorAttachmentCount]; + memcpy((void*)pColorAttachmentFormats, (void*)copy_src->pColorAttachmentFormats, + sizeof(VkFormat) * copy_src->colorAttachmentCount); + } +} + +safe_VkImageSubresource2::safe_VkImageSubresource2(const VkImageSubresource2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), imageSubresource(in_struct->imageSubresource) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageSubresource2::safe_VkImageSubresource2() + : sType(VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2), pNext(nullptr), imageSubresource() {} + +safe_VkImageSubresource2::safe_VkImageSubresource2(const safe_VkImageSubresource2& copy_src) { + sType = copy_src.sType; + imageSubresource = copy_src.imageSubresource; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageSubresource2& safe_VkImageSubresource2::operator=(const safe_VkImageSubresource2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + imageSubresource = copy_src.imageSubresource; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageSubresource2::~safe_VkImageSubresource2() { FreePnextChain(pNext); } + +void safe_VkImageSubresource2::initialize(const VkImageSubresource2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + imageSubresource = in_struct->imageSubresource; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageSubresource2::initialize(const safe_VkImageSubresource2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + imageSubresource = copy_src->imageSubresource; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDeviceImageSubresourceInfo::safe_VkDeviceImageSubresourceInfo(const VkDeviceImageSubresourceInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pCreateInfo(nullptr), pSubresource(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(in_struct->pCreateInfo); + if (in_struct->pSubresource) pSubresource = new safe_VkImageSubresource2(in_struct->pSubresource); +} + +safe_VkDeviceImageSubresourceInfo::safe_VkDeviceImageSubresourceInfo() + : sType(VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO), pNext(nullptr), pCreateInfo(nullptr), pSubresource(nullptr) {} + +safe_VkDeviceImageSubresourceInfo::safe_VkDeviceImageSubresourceInfo(const safe_VkDeviceImageSubresourceInfo& copy_src) { + sType = copy_src.sType; + pCreateInfo = nullptr; + pSubresource = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src.pCreateInfo); + if (copy_src.pSubresource) pSubresource = new safe_VkImageSubresource2(*copy_src.pSubresource); +} + +safe_VkDeviceImageSubresourceInfo& safe_VkDeviceImageSubresourceInfo::operator=(const safe_VkDeviceImageSubresourceInfo& copy_src) { + if (©_src == this) return *this; + + if (pCreateInfo) delete pCreateInfo; + if (pSubresource) delete pSubresource; + FreePnextChain(pNext); + + sType = copy_src.sType; + pCreateInfo = nullptr; + pSubresource = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src.pCreateInfo); + if (copy_src.pSubresource) pSubresource = new safe_VkImageSubresource2(*copy_src.pSubresource); + + return *this; +} + +safe_VkDeviceImageSubresourceInfo::~safe_VkDeviceImageSubresourceInfo() { + if (pCreateInfo) delete pCreateInfo; + if (pSubresource) delete pSubresource; + FreePnextChain(pNext); +} + +void safe_VkDeviceImageSubresourceInfo::initialize(const VkDeviceImageSubresourceInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pCreateInfo) delete pCreateInfo; + if (pSubresource) delete pSubresource; + FreePnextChain(pNext); + sType = in_struct->sType; + pCreateInfo = nullptr; + pSubresource = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (in_struct->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(in_struct->pCreateInfo); + if (in_struct->pSubresource) pSubresource = new safe_VkImageSubresource2(in_struct->pSubresource); +} + +void safe_VkDeviceImageSubresourceInfo::initialize(const safe_VkDeviceImageSubresourceInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pCreateInfo = nullptr; + pSubresource = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (copy_src->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src->pCreateInfo); + if (copy_src->pSubresource) pSubresource = new safe_VkImageSubresource2(*copy_src->pSubresource); +} + +safe_VkSubresourceLayout2::safe_VkSubresourceLayout2(const VkSubresourceLayout2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), subresourceLayout(in_struct->subresourceLayout) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSubresourceLayout2::safe_VkSubresourceLayout2() + : sType(VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2), pNext(nullptr), subresourceLayout() {} + +safe_VkSubresourceLayout2::safe_VkSubresourceLayout2(const safe_VkSubresourceLayout2& copy_src) { + sType = copy_src.sType; + subresourceLayout = copy_src.subresourceLayout; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSubresourceLayout2& safe_VkSubresourceLayout2::operator=(const safe_VkSubresourceLayout2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + subresourceLayout = copy_src.subresourceLayout; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSubresourceLayout2::~safe_VkSubresourceLayout2() { FreePnextChain(pNext); } + +void safe_VkSubresourceLayout2::initialize(const VkSubresourceLayout2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + subresourceLayout = in_struct->subresourceLayout; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSubresourceLayout2::initialize(const safe_VkSubresourceLayout2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + subresourceLayout = copy_src->subresourceLayout; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineCreateFlags2CreateInfo::safe_VkPipelineCreateFlags2CreateInfo(const VkPipelineCreateFlags2CreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineCreateFlags2CreateInfo::safe_VkPipelineCreateFlags2CreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO), pNext(nullptr), flags() {} + +safe_VkPipelineCreateFlags2CreateInfo::safe_VkPipelineCreateFlags2CreateInfo( + const safe_VkPipelineCreateFlags2CreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineCreateFlags2CreateInfo& safe_VkPipelineCreateFlags2CreateInfo::operator=( + const safe_VkPipelineCreateFlags2CreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineCreateFlags2CreateInfo::~safe_VkPipelineCreateFlags2CreateInfo() { FreePnextChain(pNext); } + +void safe_VkPipelineCreateFlags2CreateInfo::initialize(const VkPipelineCreateFlags2CreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineCreateFlags2CreateInfo::initialize(const safe_VkPipelineCreateFlags2CreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBufferUsageFlags2CreateInfo::safe_VkBufferUsageFlags2CreateInfo(const VkBufferUsageFlags2CreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), usage(in_struct->usage) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBufferUsageFlags2CreateInfo::safe_VkBufferUsageFlags2CreateInfo() + : sType(VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO), pNext(nullptr), usage() {} + +safe_VkBufferUsageFlags2CreateInfo::safe_VkBufferUsageFlags2CreateInfo(const safe_VkBufferUsageFlags2CreateInfo& copy_src) { + sType = copy_src.sType; + usage = copy_src.usage; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBufferUsageFlags2CreateInfo& safe_VkBufferUsageFlags2CreateInfo::operator=( + const safe_VkBufferUsageFlags2CreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + usage = copy_src.usage; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBufferUsageFlags2CreateInfo::~safe_VkBufferUsageFlags2CreateInfo() { FreePnextChain(pNext); } + +void safe_VkBufferUsageFlags2CreateInfo::initialize(const VkBufferUsageFlags2CreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + usage = in_struct->usage; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBufferUsageFlags2CreateInfo::initialize(const safe_VkBufferUsageFlags2CreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + usage = copy_src->usage; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePushDescriptorProperties::safe_VkPhysicalDevicePushDescriptorProperties( + const VkPhysicalDevicePushDescriptorProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), maxPushDescriptors(in_struct->maxPushDescriptors) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePushDescriptorProperties::safe_VkPhysicalDevicePushDescriptorProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES), pNext(nullptr), maxPushDescriptors() {} + +safe_VkPhysicalDevicePushDescriptorProperties::safe_VkPhysicalDevicePushDescriptorProperties( + const safe_VkPhysicalDevicePushDescriptorProperties& copy_src) { + sType = copy_src.sType; + maxPushDescriptors = copy_src.maxPushDescriptors; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePushDescriptorProperties& safe_VkPhysicalDevicePushDescriptorProperties::operator=( + const safe_VkPhysicalDevicePushDescriptorProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxPushDescriptors = copy_src.maxPushDescriptors; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePushDescriptorProperties::~safe_VkPhysicalDevicePushDescriptorProperties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePushDescriptorProperties::initialize(const VkPhysicalDevicePushDescriptorProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxPushDescriptors = in_struct->maxPushDescriptors; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePushDescriptorProperties::initialize(const safe_VkPhysicalDevicePushDescriptorProperties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxPushDescriptors = copy_src->maxPushDescriptors; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures( + const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), dynamicRenderingLocalRead(in_struct->dynamicRenderingLocalRead) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES), pNext(nullptr), dynamicRenderingLocalRead() {} + +safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures( + const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures& copy_src) { + sType = copy_src.sType; + dynamicRenderingLocalRead = copy_src.dynamicRenderingLocalRead; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures& safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures::operator=( + const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + dynamicRenderingLocalRead = copy_src.dynamicRenderingLocalRead; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures::~safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures::initialize( + const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + dynamicRenderingLocalRead = in_struct->dynamicRenderingLocalRead; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures::initialize( + const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + dynamicRenderingLocalRead = copy_src->dynamicRenderingLocalRead; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkRenderingAttachmentLocationInfo::safe_VkRenderingAttachmentLocationInfo(const VkRenderingAttachmentLocationInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), colorAttachmentCount(in_struct->colorAttachmentCount), pColorAttachmentLocations(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pColorAttachmentLocations) { + pColorAttachmentLocations = new uint32_t[in_struct->colorAttachmentCount]; + memcpy((void*)pColorAttachmentLocations, (void*)in_struct->pColorAttachmentLocations, + sizeof(uint32_t) * in_struct->colorAttachmentCount); + } +} + +safe_VkRenderingAttachmentLocationInfo::safe_VkRenderingAttachmentLocationInfo() + : sType(VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO), + pNext(nullptr), + colorAttachmentCount(), + pColorAttachmentLocations(nullptr) {} + +safe_VkRenderingAttachmentLocationInfo::safe_VkRenderingAttachmentLocationInfo( + const safe_VkRenderingAttachmentLocationInfo& copy_src) { + sType = copy_src.sType; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachmentLocations = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pColorAttachmentLocations) { + pColorAttachmentLocations = new uint32_t[copy_src.colorAttachmentCount]; + memcpy((void*)pColorAttachmentLocations, (void*)copy_src.pColorAttachmentLocations, + sizeof(uint32_t) * copy_src.colorAttachmentCount); + } +} + +safe_VkRenderingAttachmentLocationInfo& safe_VkRenderingAttachmentLocationInfo::operator=( + const safe_VkRenderingAttachmentLocationInfo& copy_src) { + if (©_src == this) return *this; + + if (pColorAttachmentLocations) delete[] pColorAttachmentLocations; + FreePnextChain(pNext); + + sType = copy_src.sType; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachmentLocations = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pColorAttachmentLocations) { + pColorAttachmentLocations = new uint32_t[copy_src.colorAttachmentCount]; + memcpy((void*)pColorAttachmentLocations, (void*)copy_src.pColorAttachmentLocations, + sizeof(uint32_t) * copy_src.colorAttachmentCount); + } + + return *this; +} + +safe_VkRenderingAttachmentLocationInfo::~safe_VkRenderingAttachmentLocationInfo() { + if (pColorAttachmentLocations) delete[] pColorAttachmentLocations; + FreePnextChain(pNext); +} + +void safe_VkRenderingAttachmentLocationInfo::initialize(const VkRenderingAttachmentLocationInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pColorAttachmentLocations) delete[] pColorAttachmentLocations; + FreePnextChain(pNext); + sType = in_struct->sType; + colorAttachmentCount = in_struct->colorAttachmentCount; + pColorAttachmentLocations = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pColorAttachmentLocations) { + pColorAttachmentLocations = new uint32_t[in_struct->colorAttachmentCount]; + memcpy((void*)pColorAttachmentLocations, (void*)in_struct->pColorAttachmentLocations, + sizeof(uint32_t) * in_struct->colorAttachmentCount); + } +} + +void safe_VkRenderingAttachmentLocationInfo::initialize(const safe_VkRenderingAttachmentLocationInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + colorAttachmentCount = copy_src->colorAttachmentCount; + pColorAttachmentLocations = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pColorAttachmentLocations) { + pColorAttachmentLocations = new uint32_t[copy_src->colorAttachmentCount]; + memcpy((void*)pColorAttachmentLocations, (void*)copy_src->pColorAttachmentLocations, + sizeof(uint32_t) * copy_src->colorAttachmentCount); + } +} + +safe_VkRenderingInputAttachmentIndexInfo::safe_VkRenderingInputAttachmentIndexInfo( + const VkRenderingInputAttachmentIndexInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + colorAttachmentCount(in_struct->colorAttachmentCount), + pColorAttachmentInputIndices(nullptr), + pDepthInputAttachmentIndex(nullptr), + pStencilInputAttachmentIndex(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pColorAttachmentInputIndices) { + pColorAttachmentInputIndices = new uint32_t[in_struct->colorAttachmentCount]; + memcpy((void*)pColorAttachmentInputIndices, (void*)in_struct->pColorAttachmentInputIndices, + sizeof(uint32_t) * in_struct->colorAttachmentCount); + } + + if (in_struct->pDepthInputAttachmentIndex) { + pDepthInputAttachmentIndex = new uint32_t(*in_struct->pDepthInputAttachmentIndex); + } + + if (in_struct->pStencilInputAttachmentIndex) { + pStencilInputAttachmentIndex = new uint32_t(*in_struct->pStencilInputAttachmentIndex); + } +} + +safe_VkRenderingInputAttachmentIndexInfo::safe_VkRenderingInputAttachmentIndexInfo() + : sType(VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO), + pNext(nullptr), + colorAttachmentCount(), + pColorAttachmentInputIndices(nullptr), + pDepthInputAttachmentIndex(nullptr), + pStencilInputAttachmentIndex(nullptr) {} + +safe_VkRenderingInputAttachmentIndexInfo::safe_VkRenderingInputAttachmentIndexInfo( + const safe_VkRenderingInputAttachmentIndexInfo& copy_src) { + sType = copy_src.sType; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachmentInputIndices = nullptr; + pDepthInputAttachmentIndex = nullptr; + pStencilInputAttachmentIndex = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pColorAttachmentInputIndices) { + pColorAttachmentInputIndices = new uint32_t[copy_src.colorAttachmentCount]; + memcpy((void*)pColorAttachmentInputIndices, (void*)copy_src.pColorAttachmentInputIndices, + sizeof(uint32_t) * copy_src.colorAttachmentCount); + } + + if (copy_src.pDepthInputAttachmentIndex) { + pDepthInputAttachmentIndex = new uint32_t(*copy_src.pDepthInputAttachmentIndex); + } + + if (copy_src.pStencilInputAttachmentIndex) { + pStencilInputAttachmentIndex = new uint32_t(*copy_src.pStencilInputAttachmentIndex); + } +} + +safe_VkRenderingInputAttachmentIndexInfo& safe_VkRenderingInputAttachmentIndexInfo::operator=( + const safe_VkRenderingInputAttachmentIndexInfo& copy_src) { + if (©_src == this) return *this; + + if (pColorAttachmentInputIndices) delete[] pColorAttachmentInputIndices; + if (pDepthInputAttachmentIndex) delete pDepthInputAttachmentIndex; + if (pStencilInputAttachmentIndex) delete pStencilInputAttachmentIndex; + FreePnextChain(pNext); + + sType = copy_src.sType; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachmentInputIndices = nullptr; + pDepthInputAttachmentIndex = nullptr; + pStencilInputAttachmentIndex = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pColorAttachmentInputIndices) { + pColorAttachmentInputIndices = new uint32_t[copy_src.colorAttachmentCount]; + memcpy((void*)pColorAttachmentInputIndices, (void*)copy_src.pColorAttachmentInputIndices, + sizeof(uint32_t) * copy_src.colorAttachmentCount); + } + + if (copy_src.pDepthInputAttachmentIndex) { + pDepthInputAttachmentIndex = new uint32_t(*copy_src.pDepthInputAttachmentIndex); + } + + if (copy_src.pStencilInputAttachmentIndex) { + pStencilInputAttachmentIndex = new uint32_t(*copy_src.pStencilInputAttachmentIndex); + } + + return *this; +} + +safe_VkRenderingInputAttachmentIndexInfo::~safe_VkRenderingInputAttachmentIndexInfo() { + if (pColorAttachmentInputIndices) delete[] pColorAttachmentInputIndices; + if (pDepthInputAttachmentIndex) delete pDepthInputAttachmentIndex; + if (pStencilInputAttachmentIndex) delete pStencilInputAttachmentIndex; + FreePnextChain(pNext); +} + +void safe_VkRenderingInputAttachmentIndexInfo::initialize(const VkRenderingInputAttachmentIndexInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pColorAttachmentInputIndices) delete[] pColorAttachmentInputIndices; + if (pDepthInputAttachmentIndex) delete pDepthInputAttachmentIndex; + if (pStencilInputAttachmentIndex) delete pStencilInputAttachmentIndex; + FreePnextChain(pNext); + sType = in_struct->sType; + colorAttachmentCount = in_struct->colorAttachmentCount; + pColorAttachmentInputIndices = nullptr; + pDepthInputAttachmentIndex = nullptr; + pStencilInputAttachmentIndex = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pColorAttachmentInputIndices) { + pColorAttachmentInputIndices = new uint32_t[in_struct->colorAttachmentCount]; + memcpy((void*)pColorAttachmentInputIndices, (void*)in_struct->pColorAttachmentInputIndices, + sizeof(uint32_t) * in_struct->colorAttachmentCount); + } + + if (in_struct->pDepthInputAttachmentIndex) { + pDepthInputAttachmentIndex = new uint32_t(*in_struct->pDepthInputAttachmentIndex); + } + + if (in_struct->pStencilInputAttachmentIndex) { + pStencilInputAttachmentIndex = new uint32_t(*in_struct->pStencilInputAttachmentIndex); + } +} + +void safe_VkRenderingInputAttachmentIndexInfo::initialize(const safe_VkRenderingInputAttachmentIndexInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + colorAttachmentCount = copy_src->colorAttachmentCount; + pColorAttachmentInputIndices = nullptr; + pDepthInputAttachmentIndex = nullptr; + pStencilInputAttachmentIndex = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pColorAttachmentInputIndices) { + pColorAttachmentInputIndices = new uint32_t[copy_src->colorAttachmentCount]; + memcpy((void*)pColorAttachmentInputIndices, (void*)copy_src->pColorAttachmentInputIndices, + sizeof(uint32_t) * copy_src->colorAttachmentCount); + } + + if (copy_src->pDepthInputAttachmentIndex) { + pDepthInputAttachmentIndex = new uint32_t(*copy_src->pDepthInputAttachmentIndex); + } + + if (copy_src->pStencilInputAttachmentIndex) { + pStencilInputAttachmentIndex = new uint32_t(*copy_src->pStencilInputAttachmentIndex); + } +} + +safe_VkPhysicalDeviceMaintenance6Features::safe_VkPhysicalDeviceMaintenance6Features( + const VkPhysicalDeviceMaintenance6Features* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), maintenance6(in_struct->maintenance6) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMaintenance6Features::safe_VkPhysicalDeviceMaintenance6Features() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES), pNext(nullptr), maintenance6() {} + +safe_VkPhysicalDeviceMaintenance6Features::safe_VkPhysicalDeviceMaintenance6Features( + const safe_VkPhysicalDeviceMaintenance6Features& copy_src) { + sType = copy_src.sType; + maintenance6 = copy_src.maintenance6; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMaintenance6Features& safe_VkPhysicalDeviceMaintenance6Features::operator=( + const safe_VkPhysicalDeviceMaintenance6Features& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maintenance6 = copy_src.maintenance6; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMaintenance6Features::~safe_VkPhysicalDeviceMaintenance6Features() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMaintenance6Features::initialize(const VkPhysicalDeviceMaintenance6Features* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maintenance6 = in_struct->maintenance6; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMaintenance6Features::initialize(const safe_VkPhysicalDeviceMaintenance6Features* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maintenance6 = copy_src->maintenance6; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMaintenance6Properties::safe_VkPhysicalDeviceMaintenance6Properties( + const VkPhysicalDeviceMaintenance6Properties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + blockTexelViewCompatibleMultipleLayers(in_struct->blockTexelViewCompatibleMultipleLayers), + maxCombinedImageSamplerDescriptorCount(in_struct->maxCombinedImageSamplerDescriptorCount), + fragmentShadingRateClampCombinerInputs(in_struct->fragmentShadingRateClampCombinerInputs) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMaintenance6Properties::safe_VkPhysicalDeviceMaintenance6Properties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES), + pNext(nullptr), + blockTexelViewCompatibleMultipleLayers(), + maxCombinedImageSamplerDescriptorCount(), + fragmentShadingRateClampCombinerInputs() {} + +safe_VkPhysicalDeviceMaintenance6Properties::safe_VkPhysicalDeviceMaintenance6Properties( + const safe_VkPhysicalDeviceMaintenance6Properties& copy_src) { + sType = copy_src.sType; + blockTexelViewCompatibleMultipleLayers = copy_src.blockTexelViewCompatibleMultipleLayers; + maxCombinedImageSamplerDescriptorCount = copy_src.maxCombinedImageSamplerDescriptorCount; + fragmentShadingRateClampCombinerInputs = copy_src.fragmentShadingRateClampCombinerInputs; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMaintenance6Properties& safe_VkPhysicalDeviceMaintenance6Properties::operator=( + const safe_VkPhysicalDeviceMaintenance6Properties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + blockTexelViewCompatibleMultipleLayers = copy_src.blockTexelViewCompatibleMultipleLayers; + maxCombinedImageSamplerDescriptorCount = copy_src.maxCombinedImageSamplerDescriptorCount; + fragmentShadingRateClampCombinerInputs = copy_src.fragmentShadingRateClampCombinerInputs; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMaintenance6Properties::~safe_VkPhysicalDeviceMaintenance6Properties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMaintenance6Properties::initialize(const VkPhysicalDeviceMaintenance6Properties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + blockTexelViewCompatibleMultipleLayers = in_struct->blockTexelViewCompatibleMultipleLayers; + maxCombinedImageSamplerDescriptorCount = in_struct->maxCombinedImageSamplerDescriptorCount; + fragmentShadingRateClampCombinerInputs = in_struct->fragmentShadingRateClampCombinerInputs; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMaintenance6Properties::initialize(const safe_VkPhysicalDeviceMaintenance6Properties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + blockTexelViewCompatibleMultipleLayers = copy_src->blockTexelViewCompatibleMultipleLayers; + maxCombinedImageSamplerDescriptorCount = copy_src->maxCombinedImageSamplerDescriptorCount; + fragmentShadingRateClampCombinerInputs = copy_src->fragmentShadingRateClampCombinerInputs; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBindMemoryStatus::safe_VkBindMemoryStatus(const VkBindMemoryStatus* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), pResult(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pResult) { + pResult = new VkResult(*in_struct->pResult); + } +} + +safe_VkBindMemoryStatus::safe_VkBindMemoryStatus() + : sType(VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS), pNext(nullptr), pResult(nullptr) {} + +safe_VkBindMemoryStatus::safe_VkBindMemoryStatus(const safe_VkBindMemoryStatus& copy_src) { + sType = copy_src.sType; + pResult = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pResult) { + pResult = new VkResult(*copy_src.pResult); + } +} + +safe_VkBindMemoryStatus& safe_VkBindMemoryStatus::operator=(const safe_VkBindMemoryStatus& copy_src) { + if (©_src == this) return *this; + + if (pResult) delete pResult; + FreePnextChain(pNext); + + sType = copy_src.sType; + pResult = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pResult) { + pResult = new VkResult(*copy_src.pResult); + } + + return *this; +} + +safe_VkBindMemoryStatus::~safe_VkBindMemoryStatus() { + if (pResult) delete pResult; + FreePnextChain(pNext); +} + +void safe_VkBindMemoryStatus::initialize(const VkBindMemoryStatus* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pResult) delete pResult; + FreePnextChain(pNext); + sType = in_struct->sType; + pResult = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pResult) { + pResult = new VkResult(*in_struct->pResult); + } +} + +void safe_VkBindMemoryStatus::initialize(const safe_VkBindMemoryStatus* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pResult = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pResult) { + pResult = new VkResult(*copy_src->pResult); + } +} + +safe_VkBindDescriptorSetsInfo::safe_VkBindDescriptorSetsInfo(const VkBindDescriptorSetsInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + stageFlags(in_struct->stageFlags), + layout(in_struct->layout), + firstSet(in_struct->firstSet), + descriptorSetCount(in_struct->descriptorSetCount), + pDescriptorSets(nullptr), + dynamicOffsetCount(in_struct->dynamicOffsetCount), + pDynamicOffsets(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (descriptorSetCount && in_struct->pDescriptorSets) { + pDescriptorSets = new VkDescriptorSet[descriptorSetCount]; + for (uint32_t i = 0; i < descriptorSetCount; ++i) { + pDescriptorSets[i] = in_struct->pDescriptorSets[i]; + } + } + + if (in_struct->pDynamicOffsets) { + pDynamicOffsets = new uint32_t[in_struct->dynamicOffsetCount]; + memcpy((void*)pDynamicOffsets, (void*)in_struct->pDynamicOffsets, sizeof(uint32_t) * in_struct->dynamicOffsetCount); + } +} + +safe_VkBindDescriptorSetsInfo::safe_VkBindDescriptorSetsInfo() + : sType(VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO), + pNext(nullptr), + stageFlags(), + layout(), + firstSet(), + descriptorSetCount(), + pDescriptorSets(nullptr), + dynamicOffsetCount(), + pDynamicOffsets(nullptr) {} + +safe_VkBindDescriptorSetsInfo::safe_VkBindDescriptorSetsInfo(const safe_VkBindDescriptorSetsInfo& copy_src) { + sType = copy_src.sType; + stageFlags = copy_src.stageFlags; + layout = copy_src.layout; + firstSet = copy_src.firstSet; + descriptorSetCount = copy_src.descriptorSetCount; + pDescriptorSets = nullptr; + dynamicOffsetCount = copy_src.dynamicOffsetCount; + pDynamicOffsets = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (descriptorSetCount && copy_src.pDescriptorSets) { + pDescriptorSets = new VkDescriptorSet[descriptorSetCount]; + for (uint32_t i = 0; i < descriptorSetCount; ++i) { + pDescriptorSets[i] = copy_src.pDescriptorSets[i]; + } + } + + if (copy_src.pDynamicOffsets) { + pDynamicOffsets = new uint32_t[copy_src.dynamicOffsetCount]; + memcpy((void*)pDynamicOffsets, (void*)copy_src.pDynamicOffsets, sizeof(uint32_t) * copy_src.dynamicOffsetCount); + } +} + +safe_VkBindDescriptorSetsInfo& safe_VkBindDescriptorSetsInfo::operator=(const safe_VkBindDescriptorSetsInfo& copy_src) { + if (©_src == this) return *this; + + if (pDescriptorSets) delete[] pDescriptorSets; + if (pDynamicOffsets) delete[] pDynamicOffsets; + FreePnextChain(pNext); + + sType = copy_src.sType; + stageFlags = copy_src.stageFlags; + layout = copy_src.layout; + firstSet = copy_src.firstSet; + descriptorSetCount = copy_src.descriptorSetCount; + pDescriptorSets = nullptr; + dynamicOffsetCount = copy_src.dynamicOffsetCount; + pDynamicOffsets = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (descriptorSetCount && copy_src.pDescriptorSets) { + pDescriptorSets = new VkDescriptorSet[descriptorSetCount]; + for (uint32_t i = 0; i < descriptorSetCount; ++i) { + pDescriptorSets[i] = copy_src.pDescriptorSets[i]; + } + } + + if (copy_src.pDynamicOffsets) { + pDynamicOffsets = new uint32_t[copy_src.dynamicOffsetCount]; + memcpy((void*)pDynamicOffsets, (void*)copy_src.pDynamicOffsets, sizeof(uint32_t) * copy_src.dynamicOffsetCount); + } + + return *this; +} + +safe_VkBindDescriptorSetsInfo::~safe_VkBindDescriptorSetsInfo() { + if (pDescriptorSets) delete[] pDescriptorSets; + if (pDynamicOffsets) delete[] pDynamicOffsets; + FreePnextChain(pNext); +} + +void safe_VkBindDescriptorSetsInfo::initialize(const VkBindDescriptorSetsInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDescriptorSets) delete[] pDescriptorSets; + if (pDynamicOffsets) delete[] pDynamicOffsets; + FreePnextChain(pNext); + sType = in_struct->sType; + stageFlags = in_struct->stageFlags; + layout = in_struct->layout; + firstSet = in_struct->firstSet; + descriptorSetCount = in_struct->descriptorSetCount; + pDescriptorSets = nullptr; + dynamicOffsetCount = in_struct->dynamicOffsetCount; + pDynamicOffsets = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (descriptorSetCount && in_struct->pDescriptorSets) { + pDescriptorSets = new VkDescriptorSet[descriptorSetCount]; + for (uint32_t i = 0; i < descriptorSetCount; ++i) { + pDescriptorSets[i] = in_struct->pDescriptorSets[i]; + } + } + + if (in_struct->pDynamicOffsets) { + pDynamicOffsets = new uint32_t[in_struct->dynamicOffsetCount]; + memcpy((void*)pDynamicOffsets, (void*)in_struct->pDynamicOffsets, sizeof(uint32_t) * in_struct->dynamicOffsetCount); + } +} + +void safe_VkBindDescriptorSetsInfo::initialize(const safe_VkBindDescriptorSetsInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stageFlags = copy_src->stageFlags; + layout = copy_src->layout; + firstSet = copy_src->firstSet; + descriptorSetCount = copy_src->descriptorSetCount; + pDescriptorSets = nullptr; + dynamicOffsetCount = copy_src->dynamicOffsetCount; + pDynamicOffsets = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (descriptorSetCount && copy_src->pDescriptorSets) { + pDescriptorSets = new VkDescriptorSet[descriptorSetCount]; + for (uint32_t i = 0; i < descriptorSetCount; ++i) { + pDescriptorSets[i] = copy_src->pDescriptorSets[i]; + } + } + + if (copy_src->pDynamicOffsets) { + pDynamicOffsets = new uint32_t[copy_src->dynamicOffsetCount]; + memcpy((void*)pDynamicOffsets, (void*)copy_src->pDynamicOffsets, sizeof(uint32_t) * copy_src->dynamicOffsetCount); + } +} + +safe_VkPushConstantsInfo::safe_VkPushConstantsInfo(const VkPushConstantsInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + layout(in_struct->layout), + stageFlags(in_struct->stageFlags), + offset(in_struct->offset), + size(in_struct->size), + pValues(in_struct->pValues) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPushConstantsInfo::safe_VkPushConstantsInfo() + : sType(VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO), pNext(nullptr), layout(), stageFlags(), offset(), size(), pValues(nullptr) {} + +safe_VkPushConstantsInfo::safe_VkPushConstantsInfo(const safe_VkPushConstantsInfo& copy_src) { + sType = copy_src.sType; + layout = copy_src.layout; + stageFlags = copy_src.stageFlags; + offset = copy_src.offset; + size = copy_src.size; + pValues = copy_src.pValues; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPushConstantsInfo& safe_VkPushConstantsInfo::operator=(const safe_VkPushConstantsInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + layout = copy_src.layout; + stageFlags = copy_src.stageFlags; + offset = copy_src.offset; + size = copy_src.size; + pValues = copy_src.pValues; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPushConstantsInfo::~safe_VkPushConstantsInfo() { FreePnextChain(pNext); } + +void safe_VkPushConstantsInfo::initialize(const VkPushConstantsInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + layout = in_struct->layout; + stageFlags = in_struct->stageFlags; + offset = in_struct->offset; + size = in_struct->size; + pValues = in_struct->pValues; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPushConstantsInfo::initialize(const safe_VkPushConstantsInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + layout = copy_src->layout; + stageFlags = copy_src->stageFlags; + offset = copy_src->offset; + size = copy_src->size; + pValues = copy_src->pValues; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPushDescriptorSetInfo::safe_VkPushDescriptorSetInfo(const VkPushDescriptorSetInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + stageFlags(in_struct->stageFlags), + layout(in_struct->layout), + set(in_struct->set), + descriptorWriteCount(in_struct->descriptorWriteCount), + pDescriptorWrites(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (descriptorWriteCount && in_struct->pDescriptorWrites) { + pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount]; + for (uint32_t i = 0; i < descriptorWriteCount; ++i) { + pDescriptorWrites[i].initialize(&in_struct->pDescriptorWrites[i]); + } + } +} + +safe_VkPushDescriptorSetInfo::safe_VkPushDescriptorSetInfo() + : sType(VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO), + pNext(nullptr), + stageFlags(), + layout(), + set(), + descriptorWriteCount(), + pDescriptorWrites(nullptr) {} + +safe_VkPushDescriptorSetInfo::safe_VkPushDescriptorSetInfo(const safe_VkPushDescriptorSetInfo& copy_src) { + sType = copy_src.sType; + stageFlags = copy_src.stageFlags; + layout = copy_src.layout; + set = copy_src.set; + descriptorWriteCount = copy_src.descriptorWriteCount; + pDescriptorWrites = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (descriptorWriteCount && copy_src.pDescriptorWrites) { + pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount]; + for (uint32_t i = 0; i < descriptorWriteCount; ++i) { + pDescriptorWrites[i].initialize(©_src.pDescriptorWrites[i]); + } + } +} + +safe_VkPushDescriptorSetInfo& safe_VkPushDescriptorSetInfo::operator=(const safe_VkPushDescriptorSetInfo& copy_src) { + if (©_src == this) return *this; + + if (pDescriptorWrites) delete[] pDescriptorWrites; + FreePnextChain(pNext); + + sType = copy_src.sType; + stageFlags = copy_src.stageFlags; + layout = copy_src.layout; + set = copy_src.set; + descriptorWriteCount = copy_src.descriptorWriteCount; + pDescriptorWrites = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (descriptorWriteCount && copy_src.pDescriptorWrites) { + pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount]; + for (uint32_t i = 0; i < descriptorWriteCount; ++i) { + pDescriptorWrites[i].initialize(©_src.pDescriptorWrites[i]); + } + } + + return *this; +} + +safe_VkPushDescriptorSetInfo::~safe_VkPushDescriptorSetInfo() { + if (pDescriptorWrites) delete[] pDescriptorWrites; + FreePnextChain(pNext); +} + +void safe_VkPushDescriptorSetInfo::initialize(const VkPushDescriptorSetInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDescriptorWrites) delete[] pDescriptorWrites; + FreePnextChain(pNext); + sType = in_struct->sType; + stageFlags = in_struct->stageFlags; + layout = in_struct->layout; + set = in_struct->set; + descriptorWriteCount = in_struct->descriptorWriteCount; + pDescriptorWrites = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (descriptorWriteCount && in_struct->pDescriptorWrites) { + pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount]; + for (uint32_t i = 0; i < descriptorWriteCount; ++i) { + pDescriptorWrites[i].initialize(&in_struct->pDescriptorWrites[i]); + } + } +} + +void safe_VkPushDescriptorSetInfo::initialize(const safe_VkPushDescriptorSetInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stageFlags = copy_src->stageFlags; + layout = copy_src->layout; + set = copy_src->set; + descriptorWriteCount = copy_src->descriptorWriteCount; + pDescriptorWrites = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (descriptorWriteCount && copy_src->pDescriptorWrites) { + pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount]; + for (uint32_t i = 0; i < descriptorWriteCount; ++i) { + pDescriptorWrites[i].initialize(©_src->pDescriptorWrites[i]); + } + } +} + +safe_VkPushDescriptorSetWithTemplateInfo::safe_VkPushDescriptorSetWithTemplateInfo( + const VkPushDescriptorSetWithTemplateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + descriptorUpdateTemplate(in_struct->descriptorUpdateTemplate), + layout(in_struct->layout), + set(in_struct->set), + pData(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPushDescriptorSetWithTemplateInfo::safe_VkPushDescriptorSetWithTemplateInfo() + : sType(VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO), + pNext(nullptr), + descriptorUpdateTemplate(), + layout(), + set(), + pData(nullptr) {} + +safe_VkPushDescriptorSetWithTemplateInfo::safe_VkPushDescriptorSetWithTemplateInfo( + const safe_VkPushDescriptorSetWithTemplateInfo& copy_src) { + sType = copy_src.sType; + descriptorUpdateTemplate = copy_src.descriptorUpdateTemplate; + layout = copy_src.layout; + set = copy_src.set; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPushDescriptorSetWithTemplateInfo& safe_VkPushDescriptorSetWithTemplateInfo::operator=( + const safe_VkPushDescriptorSetWithTemplateInfo& copy_src) { + if (©_src == this) return *this; + + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + FreePnextChain(pNext); + + sType = copy_src.sType; + descriptorUpdateTemplate = copy_src.descriptorUpdateTemplate; + layout = copy_src.layout; + set = copy_src.set; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPushDescriptorSetWithTemplateInfo::~safe_VkPushDescriptorSetWithTemplateInfo() { + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + FreePnextChain(pNext); +} + +void safe_VkPushDescriptorSetWithTemplateInfo::initialize(const VkPushDescriptorSetWithTemplateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + FreePnextChain(pNext); + sType = in_struct->sType; + descriptorUpdateTemplate = in_struct->descriptorUpdateTemplate; + layout = in_struct->layout; + set = in_struct->set; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPushDescriptorSetWithTemplateInfo::initialize(const safe_VkPushDescriptorSetWithTemplateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + descriptorUpdateTemplate = copy_src->descriptorUpdateTemplate; + layout = copy_src->layout; + set = copy_src->set; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePipelineProtectedAccessFeatures::safe_VkPhysicalDevicePipelineProtectedAccessFeatures( + const VkPhysicalDevicePipelineProtectedAccessFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pipelineProtectedAccess(in_struct->pipelineProtectedAccess) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePipelineProtectedAccessFeatures::safe_VkPhysicalDevicePipelineProtectedAccessFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES), pNext(nullptr), pipelineProtectedAccess() {} + +safe_VkPhysicalDevicePipelineProtectedAccessFeatures::safe_VkPhysicalDevicePipelineProtectedAccessFeatures( + const safe_VkPhysicalDevicePipelineProtectedAccessFeatures& copy_src) { + sType = copy_src.sType; + pipelineProtectedAccess = copy_src.pipelineProtectedAccess; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePipelineProtectedAccessFeatures& safe_VkPhysicalDevicePipelineProtectedAccessFeatures::operator=( + const safe_VkPhysicalDevicePipelineProtectedAccessFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pipelineProtectedAccess = copy_src.pipelineProtectedAccess; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePipelineProtectedAccessFeatures::~safe_VkPhysicalDevicePipelineProtectedAccessFeatures() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDevicePipelineProtectedAccessFeatures::initialize( + const VkPhysicalDevicePipelineProtectedAccessFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pipelineProtectedAccess = in_struct->pipelineProtectedAccess; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePipelineProtectedAccessFeatures::initialize( + const safe_VkPhysicalDevicePipelineProtectedAccessFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipelineProtectedAccess = copy_src->pipelineProtectedAccess; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePipelineRobustnessFeatures::safe_VkPhysicalDevicePipelineRobustnessFeatures( + const VkPhysicalDevicePipelineRobustnessFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pipelineRobustness(in_struct->pipelineRobustness) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePipelineRobustnessFeatures::safe_VkPhysicalDevicePipelineRobustnessFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES), pNext(nullptr), pipelineRobustness() {} + +safe_VkPhysicalDevicePipelineRobustnessFeatures::safe_VkPhysicalDevicePipelineRobustnessFeatures( + const safe_VkPhysicalDevicePipelineRobustnessFeatures& copy_src) { + sType = copy_src.sType; + pipelineRobustness = copy_src.pipelineRobustness; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePipelineRobustnessFeatures& safe_VkPhysicalDevicePipelineRobustnessFeatures::operator=( + const safe_VkPhysicalDevicePipelineRobustnessFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pipelineRobustness = copy_src.pipelineRobustness; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePipelineRobustnessFeatures::~safe_VkPhysicalDevicePipelineRobustnessFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePipelineRobustnessFeatures::initialize(const VkPhysicalDevicePipelineRobustnessFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pipelineRobustness = in_struct->pipelineRobustness; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePipelineRobustnessFeatures::initialize(const safe_VkPhysicalDevicePipelineRobustnessFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipelineRobustness = copy_src->pipelineRobustness; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePipelineRobustnessProperties::safe_VkPhysicalDevicePipelineRobustnessProperties( + const VkPhysicalDevicePipelineRobustnessProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + defaultRobustnessStorageBuffers(in_struct->defaultRobustnessStorageBuffers), + defaultRobustnessUniformBuffers(in_struct->defaultRobustnessUniformBuffers), + defaultRobustnessVertexInputs(in_struct->defaultRobustnessVertexInputs), + defaultRobustnessImages(in_struct->defaultRobustnessImages) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePipelineRobustnessProperties::safe_VkPhysicalDevicePipelineRobustnessProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES), + pNext(nullptr), + defaultRobustnessStorageBuffers(), + defaultRobustnessUniformBuffers(), + defaultRobustnessVertexInputs(), + defaultRobustnessImages() {} + +safe_VkPhysicalDevicePipelineRobustnessProperties::safe_VkPhysicalDevicePipelineRobustnessProperties( + const safe_VkPhysicalDevicePipelineRobustnessProperties& copy_src) { + sType = copy_src.sType; + defaultRobustnessStorageBuffers = copy_src.defaultRobustnessStorageBuffers; + defaultRobustnessUniformBuffers = copy_src.defaultRobustnessUniformBuffers; + defaultRobustnessVertexInputs = copy_src.defaultRobustnessVertexInputs; + defaultRobustnessImages = copy_src.defaultRobustnessImages; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePipelineRobustnessProperties& safe_VkPhysicalDevicePipelineRobustnessProperties::operator=( + const safe_VkPhysicalDevicePipelineRobustnessProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + defaultRobustnessStorageBuffers = copy_src.defaultRobustnessStorageBuffers; + defaultRobustnessUniformBuffers = copy_src.defaultRobustnessUniformBuffers; + defaultRobustnessVertexInputs = copy_src.defaultRobustnessVertexInputs; + defaultRobustnessImages = copy_src.defaultRobustnessImages; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePipelineRobustnessProperties::~safe_VkPhysicalDevicePipelineRobustnessProperties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePipelineRobustnessProperties::initialize(const VkPhysicalDevicePipelineRobustnessProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + defaultRobustnessStorageBuffers = in_struct->defaultRobustnessStorageBuffers; + defaultRobustnessUniformBuffers = in_struct->defaultRobustnessUniformBuffers; + defaultRobustnessVertexInputs = in_struct->defaultRobustnessVertexInputs; + defaultRobustnessImages = in_struct->defaultRobustnessImages; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePipelineRobustnessProperties::initialize( + const safe_VkPhysicalDevicePipelineRobustnessProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + defaultRobustnessStorageBuffers = copy_src->defaultRobustnessStorageBuffers; + defaultRobustnessUniformBuffers = copy_src->defaultRobustnessUniformBuffers; + defaultRobustnessVertexInputs = copy_src->defaultRobustnessVertexInputs; + defaultRobustnessImages = copy_src->defaultRobustnessImages; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineRobustnessCreateInfo::safe_VkPipelineRobustnessCreateInfo(const VkPipelineRobustnessCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + storageBuffers(in_struct->storageBuffers), + uniformBuffers(in_struct->uniformBuffers), + vertexInputs(in_struct->vertexInputs), + images(in_struct->images) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineRobustnessCreateInfo::safe_VkPipelineRobustnessCreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO), + pNext(nullptr), + storageBuffers(), + uniformBuffers(), + vertexInputs(), + images() {} + +safe_VkPipelineRobustnessCreateInfo::safe_VkPipelineRobustnessCreateInfo(const safe_VkPipelineRobustnessCreateInfo& copy_src) { + sType = copy_src.sType; + storageBuffers = copy_src.storageBuffers; + uniformBuffers = copy_src.uniformBuffers; + vertexInputs = copy_src.vertexInputs; + images = copy_src.images; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineRobustnessCreateInfo& safe_VkPipelineRobustnessCreateInfo::operator=( + const safe_VkPipelineRobustnessCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + storageBuffers = copy_src.storageBuffers; + uniformBuffers = copy_src.uniformBuffers; + vertexInputs = copy_src.vertexInputs; + images = copy_src.images; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineRobustnessCreateInfo::~safe_VkPipelineRobustnessCreateInfo() { FreePnextChain(pNext); } + +void safe_VkPipelineRobustnessCreateInfo::initialize(const VkPipelineRobustnessCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + storageBuffers = in_struct->storageBuffers; + uniformBuffers = in_struct->uniformBuffers; + vertexInputs = in_struct->vertexInputs; + images = in_struct->images; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineRobustnessCreateInfo::initialize(const safe_VkPipelineRobustnessCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + storageBuffers = copy_src->storageBuffers; + uniformBuffers = copy_src->uniformBuffers; + vertexInputs = copy_src->vertexInputs; + images = copy_src->images; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceHostImageCopyFeatures::safe_VkPhysicalDeviceHostImageCopyFeatures( + const VkPhysicalDeviceHostImageCopyFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), hostImageCopy(in_struct->hostImageCopy) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceHostImageCopyFeatures::safe_VkPhysicalDeviceHostImageCopyFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES), pNext(nullptr), hostImageCopy() {} + +safe_VkPhysicalDeviceHostImageCopyFeatures::safe_VkPhysicalDeviceHostImageCopyFeatures( + const safe_VkPhysicalDeviceHostImageCopyFeatures& copy_src) { + sType = copy_src.sType; + hostImageCopy = copy_src.hostImageCopy; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceHostImageCopyFeatures& safe_VkPhysicalDeviceHostImageCopyFeatures::operator=( + const safe_VkPhysicalDeviceHostImageCopyFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + hostImageCopy = copy_src.hostImageCopy; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceHostImageCopyFeatures::~safe_VkPhysicalDeviceHostImageCopyFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceHostImageCopyFeatures::initialize(const VkPhysicalDeviceHostImageCopyFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + hostImageCopy = in_struct->hostImageCopy; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceHostImageCopyFeatures::initialize(const safe_VkPhysicalDeviceHostImageCopyFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + hostImageCopy = copy_src->hostImageCopy; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceHostImageCopyProperties::safe_VkPhysicalDeviceHostImageCopyProperties( + const VkPhysicalDeviceHostImageCopyProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + copySrcLayoutCount(in_struct->copySrcLayoutCount), + pCopySrcLayouts(nullptr), + copyDstLayoutCount(in_struct->copyDstLayoutCount), + pCopyDstLayouts(nullptr), + identicalMemoryTypeRequirements(in_struct->identicalMemoryTypeRequirements) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pCopySrcLayouts) { + pCopySrcLayouts = new VkImageLayout[in_struct->copySrcLayoutCount]; + memcpy((void*)pCopySrcLayouts, (void*)in_struct->pCopySrcLayouts, sizeof(VkImageLayout) * in_struct->copySrcLayoutCount); + } + + if (in_struct->pCopyDstLayouts) { + pCopyDstLayouts = new VkImageLayout[in_struct->copyDstLayoutCount]; + memcpy((void*)pCopyDstLayouts, (void*)in_struct->pCopyDstLayouts, sizeof(VkImageLayout) * in_struct->copyDstLayoutCount); + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + optimalTilingLayoutUUID[i] = in_struct->optimalTilingLayoutUUID[i]; + } +} + +safe_VkPhysicalDeviceHostImageCopyProperties::safe_VkPhysicalDeviceHostImageCopyProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES), + pNext(nullptr), + copySrcLayoutCount(), + pCopySrcLayouts(nullptr), + copyDstLayoutCount(), + pCopyDstLayouts(nullptr), + identicalMemoryTypeRequirements() {} + +safe_VkPhysicalDeviceHostImageCopyProperties::safe_VkPhysicalDeviceHostImageCopyProperties( + const safe_VkPhysicalDeviceHostImageCopyProperties& copy_src) { + sType = copy_src.sType; + copySrcLayoutCount = copy_src.copySrcLayoutCount; + pCopySrcLayouts = nullptr; + copyDstLayoutCount = copy_src.copyDstLayoutCount; + pCopyDstLayouts = nullptr; + identicalMemoryTypeRequirements = copy_src.identicalMemoryTypeRequirements; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pCopySrcLayouts) { + pCopySrcLayouts = new VkImageLayout[copy_src.copySrcLayoutCount]; + memcpy((void*)pCopySrcLayouts, (void*)copy_src.pCopySrcLayouts, sizeof(VkImageLayout) * copy_src.copySrcLayoutCount); + } + + if (copy_src.pCopyDstLayouts) { + pCopyDstLayouts = new VkImageLayout[copy_src.copyDstLayoutCount]; + memcpy((void*)pCopyDstLayouts, (void*)copy_src.pCopyDstLayouts, sizeof(VkImageLayout) * copy_src.copyDstLayoutCount); + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + optimalTilingLayoutUUID[i] = copy_src.optimalTilingLayoutUUID[i]; + } +} + +safe_VkPhysicalDeviceHostImageCopyProperties& safe_VkPhysicalDeviceHostImageCopyProperties::operator=( + const safe_VkPhysicalDeviceHostImageCopyProperties& copy_src) { + if (©_src == this) return *this; + + if (pCopySrcLayouts) delete[] pCopySrcLayouts; + if (pCopyDstLayouts) delete[] pCopyDstLayouts; + FreePnextChain(pNext); + + sType = copy_src.sType; + copySrcLayoutCount = copy_src.copySrcLayoutCount; + pCopySrcLayouts = nullptr; + copyDstLayoutCount = copy_src.copyDstLayoutCount; + pCopyDstLayouts = nullptr; + identicalMemoryTypeRequirements = copy_src.identicalMemoryTypeRequirements; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pCopySrcLayouts) { + pCopySrcLayouts = new VkImageLayout[copy_src.copySrcLayoutCount]; + memcpy((void*)pCopySrcLayouts, (void*)copy_src.pCopySrcLayouts, sizeof(VkImageLayout) * copy_src.copySrcLayoutCount); + } + + if (copy_src.pCopyDstLayouts) { + pCopyDstLayouts = new VkImageLayout[copy_src.copyDstLayoutCount]; + memcpy((void*)pCopyDstLayouts, (void*)copy_src.pCopyDstLayouts, sizeof(VkImageLayout) * copy_src.copyDstLayoutCount); + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + optimalTilingLayoutUUID[i] = copy_src.optimalTilingLayoutUUID[i]; + } + + return *this; +} + +safe_VkPhysicalDeviceHostImageCopyProperties::~safe_VkPhysicalDeviceHostImageCopyProperties() { + if (pCopySrcLayouts) delete[] pCopySrcLayouts; + if (pCopyDstLayouts) delete[] pCopyDstLayouts; + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceHostImageCopyProperties::initialize(const VkPhysicalDeviceHostImageCopyProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pCopySrcLayouts) delete[] pCopySrcLayouts; + if (pCopyDstLayouts) delete[] pCopyDstLayouts; + FreePnextChain(pNext); + sType = in_struct->sType; + copySrcLayoutCount = in_struct->copySrcLayoutCount; + pCopySrcLayouts = nullptr; + copyDstLayoutCount = in_struct->copyDstLayoutCount; + pCopyDstLayouts = nullptr; + identicalMemoryTypeRequirements = in_struct->identicalMemoryTypeRequirements; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pCopySrcLayouts) { + pCopySrcLayouts = new VkImageLayout[in_struct->copySrcLayoutCount]; + memcpy((void*)pCopySrcLayouts, (void*)in_struct->pCopySrcLayouts, sizeof(VkImageLayout) * in_struct->copySrcLayoutCount); + } + + if (in_struct->pCopyDstLayouts) { + pCopyDstLayouts = new VkImageLayout[in_struct->copyDstLayoutCount]; + memcpy((void*)pCopyDstLayouts, (void*)in_struct->pCopyDstLayouts, sizeof(VkImageLayout) * in_struct->copyDstLayoutCount); + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + optimalTilingLayoutUUID[i] = in_struct->optimalTilingLayoutUUID[i]; + } +} + +void safe_VkPhysicalDeviceHostImageCopyProperties::initialize(const safe_VkPhysicalDeviceHostImageCopyProperties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + copySrcLayoutCount = copy_src->copySrcLayoutCount; + pCopySrcLayouts = nullptr; + copyDstLayoutCount = copy_src->copyDstLayoutCount; + pCopyDstLayouts = nullptr; + identicalMemoryTypeRequirements = copy_src->identicalMemoryTypeRequirements; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pCopySrcLayouts) { + pCopySrcLayouts = new VkImageLayout[copy_src->copySrcLayoutCount]; + memcpy((void*)pCopySrcLayouts, (void*)copy_src->pCopySrcLayouts, sizeof(VkImageLayout) * copy_src->copySrcLayoutCount); + } + + if (copy_src->pCopyDstLayouts) { + pCopyDstLayouts = new VkImageLayout[copy_src->copyDstLayoutCount]; + memcpy((void*)pCopyDstLayouts, (void*)copy_src->pCopyDstLayouts, sizeof(VkImageLayout) * copy_src->copyDstLayoutCount); + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + optimalTilingLayoutUUID[i] = copy_src->optimalTilingLayoutUUID[i]; + } +} + +safe_VkMemoryToImageCopy::safe_VkMemoryToImageCopy(const VkMemoryToImageCopy* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + pHostPointer(in_struct->pHostPointer), + memoryRowLength(in_struct->memoryRowLength), + memoryImageHeight(in_struct->memoryImageHeight), + imageSubresource(in_struct->imageSubresource), + imageOffset(in_struct->imageOffset), + imageExtent(in_struct->imageExtent) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMemoryToImageCopy::safe_VkMemoryToImageCopy() + : sType(VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY), + pNext(nullptr), + pHostPointer(nullptr), + memoryRowLength(), + memoryImageHeight(), + imageSubresource(), + imageOffset(), + imageExtent() {} + +safe_VkMemoryToImageCopy::safe_VkMemoryToImageCopy(const safe_VkMemoryToImageCopy& copy_src) { + sType = copy_src.sType; + pHostPointer = copy_src.pHostPointer; + memoryRowLength = copy_src.memoryRowLength; + memoryImageHeight = copy_src.memoryImageHeight; + imageSubresource = copy_src.imageSubresource; + imageOffset = copy_src.imageOffset; + imageExtent = copy_src.imageExtent; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryToImageCopy& safe_VkMemoryToImageCopy::operator=(const safe_VkMemoryToImageCopy& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pHostPointer = copy_src.pHostPointer; + memoryRowLength = copy_src.memoryRowLength; + memoryImageHeight = copy_src.memoryImageHeight; + imageSubresource = copy_src.imageSubresource; + imageOffset = copy_src.imageOffset; + imageExtent = copy_src.imageExtent; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryToImageCopy::~safe_VkMemoryToImageCopy() { FreePnextChain(pNext); } + +void safe_VkMemoryToImageCopy::initialize(const VkMemoryToImageCopy* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pHostPointer = in_struct->pHostPointer; + memoryRowLength = in_struct->memoryRowLength; + memoryImageHeight = in_struct->memoryImageHeight; + imageSubresource = in_struct->imageSubresource; + imageOffset = in_struct->imageOffset; + imageExtent = in_struct->imageExtent; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryToImageCopy::initialize(const safe_VkMemoryToImageCopy* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pHostPointer = copy_src->pHostPointer; + memoryRowLength = copy_src->memoryRowLength; + memoryImageHeight = copy_src->memoryImageHeight; + imageSubresource = copy_src->imageSubresource; + imageOffset = copy_src->imageOffset; + imageExtent = copy_src->imageExtent; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImageToMemoryCopy::safe_VkImageToMemoryCopy(const VkImageToMemoryCopy* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + pHostPointer(in_struct->pHostPointer), + memoryRowLength(in_struct->memoryRowLength), + memoryImageHeight(in_struct->memoryImageHeight), + imageSubresource(in_struct->imageSubresource), + imageOffset(in_struct->imageOffset), + imageExtent(in_struct->imageExtent) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageToMemoryCopy::safe_VkImageToMemoryCopy() + : sType(VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY), + pNext(nullptr), + pHostPointer(nullptr), + memoryRowLength(), + memoryImageHeight(), + imageSubresource(), + imageOffset(), + imageExtent() {} + +safe_VkImageToMemoryCopy::safe_VkImageToMemoryCopy(const safe_VkImageToMemoryCopy& copy_src) { + sType = copy_src.sType; + pHostPointer = copy_src.pHostPointer; + memoryRowLength = copy_src.memoryRowLength; + memoryImageHeight = copy_src.memoryImageHeight; + imageSubresource = copy_src.imageSubresource; + imageOffset = copy_src.imageOffset; + imageExtent = copy_src.imageExtent; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageToMemoryCopy& safe_VkImageToMemoryCopy::operator=(const safe_VkImageToMemoryCopy& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pHostPointer = copy_src.pHostPointer; + memoryRowLength = copy_src.memoryRowLength; + memoryImageHeight = copy_src.memoryImageHeight; + imageSubresource = copy_src.imageSubresource; + imageOffset = copy_src.imageOffset; + imageExtent = copy_src.imageExtent; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageToMemoryCopy::~safe_VkImageToMemoryCopy() { FreePnextChain(pNext); } + +void safe_VkImageToMemoryCopy::initialize(const VkImageToMemoryCopy* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pHostPointer = in_struct->pHostPointer; + memoryRowLength = in_struct->memoryRowLength; + memoryImageHeight = in_struct->memoryImageHeight; + imageSubresource = in_struct->imageSubresource; + imageOffset = in_struct->imageOffset; + imageExtent = in_struct->imageExtent; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageToMemoryCopy::initialize(const safe_VkImageToMemoryCopy* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pHostPointer = copy_src->pHostPointer; + memoryRowLength = copy_src->memoryRowLength; + memoryImageHeight = copy_src->memoryImageHeight; + imageSubresource = copy_src->imageSubresource; + imageOffset = copy_src->imageOffset; + imageExtent = copy_src->imageExtent; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCopyMemoryToImageInfo::safe_VkCopyMemoryToImageInfo(const VkCopyMemoryToImageInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + dstImage(in_struct->dstImage), + dstImageLayout(in_struct->dstImageLayout), + regionCount(in_struct->regionCount), + pRegions(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkMemoryToImageCopy[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +safe_VkCopyMemoryToImageInfo::safe_VkCopyMemoryToImageInfo() + : sType(VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO), + pNext(nullptr), + flags(), + dstImage(), + dstImageLayout(), + regionCount(), + pRegions(nullptr) {} + +safe_VkCopyMemoryToImageInfo::safe_VkCopyMemoryToImageInfo(const safe_VkCopyMemoryToImageInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + dstImage = copy_src.dstImage; + dstImageLayout = copy_src.dstImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkMemoryToImageCopy[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } +} + +safe_VkCopyMemoryToImageInfo& safe_VkCopyMemoryToImageInfo::operator=(const safe_VkCopyMemoryToImageInfo& copy_src) { + if (©_src == this) return *this; + + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + dstImage = copy_src.dstImage; + dstImageLayout = copy_src.dstImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkMemoryToImageCopy[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } + + return *this; +} + +safe_VkCopyMemoryToImageInfo::~safe_VkCopyMemoryToImageInfo() { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); +} + +void safe_VkCopyMemoryToImageInfo::initialize(const VkCopyMemoryToImageInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + dstImage = in_struct->dstImage; + dstImageLayout = in_struct->dstImageLayout; + regionCount = in_struct->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkMemoryToImageCopy[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +void safe_VkCopyMemoryToImageInfo::initialize(const safe_VkCopyMemoryToImageInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + dstImage = copy_src->dstImage; + dstImageLayout = copy_src->dstImageLayout; + regionCount = copy_src->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (regionCount && copy_src->pRegions) { + pRegions = new safe_VkMemoryToImageCopy[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src->pRegions[i]); + } + } +} + +safe_VkCopyImageToMemoryInfo::safe_VkCopyImageToMemoryInfo(const VkCopyImageToMemoryInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + srcImage(in_struct->srcImage), + srcImageLayout(in_struct->srcImageLayout), + regionCount(in_struct->regionCount), + pRegions(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkImageToMemoryCopy[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +safe_VkCopyImageToMemoryInfo::safe_VkCopyImageToMemoryInfo() + : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO), + pNext(nullptr), + flags(), + srcImage(), + srcImageLayout(), + regionCount(), + pRegions(nullptr) {} + +safe_VkCopyImageToMemoryInfo::safe_VkCopyImageToMemoryInfo(const safe_VkCopyImageToMemoryInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + srcImage = copy_src.srcImage; + srcImageLayout = copy_src.srcImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkImageToMemoryCopy[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } +} + +safe_VkCopyImageToMemoryInfo& safe_VkCopyImageToMemoryInfo::operator=(const safe_VkCopyImageToMemoryInfo& copy_src) { + if (©_src == this) return *this; + + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + srcImage = copy_src.srcImage; + srcImageLayout = copy_src.srcImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkImageToMemoryCopy[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } + + return *this; +} + +safe_VkCopyImageToMemoryInfo::~safe_VkCopyImageToMemoryInfo() { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); +} + +void safe_VkCopyImageToMemoryInfo::initialize(const VkCopyImageToMemoryInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + srcImage = in_struct->srcImage; + srcImageLayout = in_struct->srcImageLayout; + regionCount = in_struct->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkImageToMemoryCopy[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +void safe_VkCopyImageToMemoryInfo::initialize(const safe_VkCopyImageToMemoryInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + srcImage = copy_src->srcImage; + srcImageLayout = copy_src->srcImageLayout; + regionCount = copy_src->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (regionCount && copy_src->pRegions) { + pRegions = new safe_VkImageToMemoryCopy[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src->pRegions[i]); + } + } +} + +safe_VkCopyImageToImageInfo::safe_VkCopyImageToImageInfo(const VkCopyImageToImageInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + srcImage(in_struct->srcImage), + srcImageLayout(in_struct->srcImageLayout), + dstImage(in_struct->dstImage), + dstImageLayout(in_struct->dstImageLayout), + regionCount(in_struct->regionCount), + pRegions(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +safe_VkCopyImageToImageInfo::safe_VkCopyImageToImageInfo() + : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO), + pNext(nullptr), + flags(), + srcImage(), + srcImageLayout(), + dstImage(), + dstImageLayout(), + regionCount(), + pRegions(nullptr) {} + +safe_VkCopyImageToImageInfo::safe_VkCopyImageToImageInfo(const safe_VkCopyImageToImageInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + srcImage = copy_src.srcImage; + srcImageLayout = copy_src.srcImageLayout; + dstImage = copy_src.dstImage; + dstImageLayout = copy_src.dstImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } +} + +safe_VkCopyImageToImageInfo& safe_VkCopyImageToImageInfo::operator=(const safe_VkCopyImageToImageInfo& copy_src) { + if (©_src == this) return *this; + + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + srcImage = copy_src.srcImage; + srcImageLayout = copy_src.srcImageLayout; + dstImage = copy_src.dstImage; + dstImageLayout = copy_src.dstImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } + + return *this; +} + +safe_VkCopyImageToImageInfo::~safe_VkCopyImageToImageInfo() { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); +} + +void safe_VkCopyImageToImageInfo::initialize(const VkCopyImageToImageInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + srcImage = in_struct->srcImage; + srcImageLayout = in_struct->srcImageLayout; + dstImage = in_struct->dstImage; + dstImageLayout = in_struct->dstImageLayout; + regionCount = in_struct->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +void safe_VkCopyImageToImageInfo::initialize(const safe_VkCopyImageToImageInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + srcImage = copy_src->srcImage; + srcImageLayout = copy_src->srcImageLayout; + dstImage = copy_src->dstImage; + dstImageLayout = copy_src->dstImageLayout; + regionCount = copy_src->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (regionCount && copy_src->pRegions) { + pRegions = new safe_VkImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src->pRegions[i]); + } + } +} + +safe_VkHostImageLayoutTransitionInfo::safe_VkHostImageLayoutTransitionInfo(const VkHostImageLayoutTransitionInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + image(in_struct->image), + oldLayout(in_struct->oldLayout), + newLayout(in_struct->newLayout), + subresourceRange(in_struct->subresourceRange) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkHostImageLayoutTransitionInfo::safe_VkHostImageLayoutTransitionInfo() + : sType(VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO), + pNext(nullptr), + image(), + oldLayout(), + newLayout(), + subresourceRange() {} + +safe_VkHostImageLayoutTransitionInfo::safe_VkHostImageLayoutTransitionInfo(const safe_VkHostImageLayoutTransitionInfo& copy_src) { + sType = copy_src.sType; + image = copy_src.image; + oldLayout = copy_src.oldLayout; + newLayout = copy_src.newLayout; + subresourceRange = copy_src.subresourceRange; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkHostImageLayoutTransitionInfo& safe_VkHostImageLayoutTransitionInfo::operator=( + const safe_VkHostImageLayoutTransitionInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + image = copy_src.image; + oldLayout = copy_src.oldLayout; + newLayout = copy_src.newLayout; + subresourceRange = copy_src.subresourceRange; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkHostImageLayoutTransitionInfo::~safe_VkHostImageLayoutTransitionInfo() { FreePnextChain(pNext); } + +void safe_VkHostImageLayoutTransitionInfo::initialize(const VkHostImageLayoutTransitionInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + image = in_struct->image; + oldLayout = in_struct->oldLayout; + newLayout = in_struct->newLayout; + subresourceRange = in_struct->subresourceRange; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkHostImageLayoutTransitionInfo::initialize(const safe_VkHostImageLayoutTransitionInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + image = copy_src->image; + oldLayout = copy_src->oldLayout; + newLayout = copy_src->newLayout; + subresourceRange = copy_src->subresourceRange; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSubresourceHostMemcpySize::safe_VkSubresourceHostMemcpySize(const VkSubresourceHostMemcpySize* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), size(in_struct->size) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSubresourceHostMemcpySize::safe_VkSubresourceHostMemcpySize() + : sType(VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE), pNext(nullptr), size() {} + +safe_VkSubresourceHostMemcpySize::safe_VkSubresourceHostMemcpySize(const safe_VkSubresourceHostMemcpySize& copy_src) { + sType = copy_src.sType; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSubresourceHostMemcpySize& safe_VkSubresourceHostMemcpySize::operator=(const safe_VkSubresourceHostMemcpySize& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSubresourceHostMemcpySize::~safe_VkSubresourceHostMemcpySize() { FreePnextChain(pNext); } + +void safe_VkSubresourceHostMemcpySize::initialize(const VkSubresourceHostMemcpySize* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + size = in_struct->size; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSubresourceHostMemcpySize::initialize(const safe_VkSubresourceHostMemcpySize* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + size = copy_src->size; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkHostImageCopyDevicePerformanceQuery::safe_VkHostImageCopyDevicePerformanceQuery( + const VkHostImageCopyDevicePerformanceQuery* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + optimalDeviceAccess(in_struct->optimalDeviceAccess), + identicalMemoryLayout(in_struct->identicalMemoryLayout) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkHostImageCopyDevicePerformanceQuery::safe_VkHostImageCopyDevicePerformanceQuery() + : sType(VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY), + pNext(nullptr), + optimalDeviceAccess(), + identicalMemoryLayout() {} + +safe_VkHostImageCopyDevicePerformanceQuery::safe_VkHostImageCopyDevicePerformanceQuery( + const safe_VkHostImageCopyDevicePerformanceQuery& copy_src) { + sType = copy_src.sType; + optimalDeviceAccess = copy_src.optimalDeviceAccess; + identicalMemoryLayout = copy_src.identicalMemoryLayout; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkHostImageCopyDevicePerformanceQuery& safe_VkHostImageCopyDevicePerformanceQuery::operator=( + const safe_VkHostImageCopyDevicePerformanceQuery& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + optimalDeviceAccess = copy_src.optimalDeviceAccess; + identicalMemoryLayout = copy_src.identicalMemoryLayout; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkHostImageCopyDevicePerformanceQuery::~safe_VkHostImageCopyDevicePerformanceQuery() { FreePnextChain(pNext); } + +void safe_VkHostImageCopyDevicePerformanceQuery::initialize(const VkHostImageCopyDevicePerformanceQuery* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + optimalDeviceAccess = in_struct->optimalDeviceAccess; + identicalMemoryLayout = in_struct->identicalMemoryLayout; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkHostImageCopyDevicePerformanceQuery::initialize(const safe_VkHostImageCopyDevicePerformanceQuery* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + optimalDeviceAccess = copy_src->optimalDeviceAccess; + identicalMemoryLayout = copy_src->identicalMemoryLayout; + pNext = SafePnextCopy(copy_src->pNext); +} + } // namespace vku // NOLINTEND diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp index 6ee2038..08abcf0 100644 --- a/src/vulkan/vk_safe_struct_ext.cpp +++ b/src/vulkan/vk_safe_struct_ext.cpp @@ -879,195 +879,6 @@ void safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::initialize(const safe_VkPhysica pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT( - const VkPhysicalDevicePipelineRobustnessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), pipelineRobustness(in_struct->pipelineRobustness) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT), pNext(nullptr), pipelineRobustness() {} - -safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT( - const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& copy_src) { - sType = copy_src.sType; - pipelineRobustness = copy_src.pipelineRobustness; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::operator=( - const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - pipelineRobustness = copy_src.pipelineRobustness; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::~safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT() { FreePnextChain(pNext); } - -void safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::initialize(const VkPhysicalDevicePipelineRobustnessFeaturesEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - pipelineRobustness = in_struct->pipelineRobustness; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::initialize( - const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - pipelineRobustness = copy_src->pipelineRobustness; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT( - const VkPhysicalDevicePipelineRobustnessPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - defaultRobustnessStorageBuffers(in_struct->defaultRobustnessStorageBuffers), - defaultRobustnessUniformBuffers(in_struct->defaultRobustnessUniformBuffers), - defaultRobustnessVertexInputs(in_struct->defaultRobustnessVertexInputs), - defaultRobustnessImages(in_struct->defaultRobustnessImages) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT), - pNext(nullptr), - defaultRobustnessStorageBuffers(), - defaultRobustnessUniformBuffers(), - defaultRobustnessVertexInputs(), - defaultRobustnessImages() {} - -safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT( - const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& copy_src) { - sType = copy_src.sType; - defaultRobustnessStorageBuffers = copy_src.defaultRobustnessStorageBuffers; - defaultRobustnessUniformBuffers = copy_src.defaultRobustnessUniformBuffers; - defaultRobustnessVertexInputs = copy_src.defaultRobustnessVertexInputs; - defaultRobustnessImages = copy_src.defaultRobustnessImages; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::operator=( - const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - defaultRobustnessStorageBuffers = copy_src.defaultRobustnessStorageBuffers; - defaultRobustnessUniformBuffers = copy_src.defaultRobustnessUniformBuffers; - defaultRobustnessVertexInputs = copy_src.defaultRobustnessVertexInputs; - defaultRobustnessImages = copy_src.defaultRobustnessImages; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::~safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT() { - FreePnextChain(pNext); -} - -void safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::initialize( - const VkPhysicalDevicePipelineRobustnessPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - defaultRobustnessStorageBuffers = in_struct->defaultRobustnessStorageBuffers; - defaultRobustnessUniformBuffers = in_struct->defaultRobustnessUniformBuffers; - defaultRobustnessVertexInputs = in_struct->defaultRobustnessVertexInputs; - defaultRobustnessImages = in_struct->defaultRobustnessImages; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::initialize( - const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - defaultRobustnessStorageBuffers = copy_src->defaultRobustnessStorageBuffers; - defaultRobustnessUniformBuffers = copy_src->defaultRobustnessUniformBuffers; - defaultRobustnessVertexInputs = copy_src->defaultRobustnessVertexInputs; - defaultRobustnessImages = copy_src->defaultRobustnessImages; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkPipelineRobustnessCreateInfoEXT::safe_VkPipelineRobustnessCreateInfoEXT(const VkPipelineRobustnessCreateInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), - storageBuffers(in_struct->storageBuffers), - uniformBuffers(in_struct->uniformBuffers), - vertexInputs(in_struct->vertexInputs), - images(in_struct->images) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkPipelineRobustnessCreateInfoEXT::safe_VkPipelineRobustnessCreateInfoEXT() - : sType(VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT), - pNext(nullptr), - storageBuffers(), - uniformBuffers(), - vertexInputs(), - images() {} - -safe_VkPipelineRobustnessCreateInfoEXT::safe_VkPipelineRobustnessCreateInfoEXT( - const safe_VkPipelineRobustnessCreateInfoEXT& copy_src) { - sType = copy_src.sType; - storageBuffers = copy_src.storageBuffers; - uniformBuffers = copy_src.uniformBuffers; - vertexInputs = copy_src.vertexInputs; - images = copy_src.images; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkPipelineRobustnessCreateInfoEXT& safe_VkPipelineRobustnessCreateInfoEXT::operator=( - const safe_VkPipelineRobustnessCreateInfoEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - storageBuffers = copy_src.storageBuffers; - uniformBuffers = copy_src.uniformBuffers; - vertexInputs = copy_src.vertexInputs; - images = copy_src.images; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkPipelineRobustnessCreateInfoEXT::~safe_VkPipelineRobustnessCreateInfoEXT() { FreePnextChain(pNext); } - -void safe_VkPipelineRobustnessCreateInfoEXT::initialize(const VkPipelineRobustnessCreateInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - storageBuffers = in_struct->storageBuffers; - uniformBuffers = in_struct->uniformBuffers; - vertexInputs = in_struct->vertexInputs; - images = in_struct->images; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPipelineRobustnessCreateInfoEXT::initialize(const safe_VkPipelineRobustnessCreateInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - storageBuffers = copy_src->storageBuffers; - uniformBuffers = copy_src->uniformBuffers; - vertexInputs = copy_src->vertexInputs; - images = copy_src->images; - pNext = SafePnextCopy(copy_src->pNext); -} - safe_VkConditionalRenderingBeginInfoEXT::safe_VkConditionalRenderingBeginInfoEXT( const VkConditionalRenderingBeginInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), buffer(in_struct->buffer), offset(in_struct->offset), flags(in_struct->flags) { @@ -5298,1172 +5109,306 @@ safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::safe_VkSurfaceCapabilitiesFull } safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT() - : sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT), pNext(nullptr), fullScreenExclusiveSupported() {} - -safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT( - const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& copy_src) { - sType = copy_src.sType; - fullScreenExclusiveSupported = copy_src.fullScreenExclusiveSupported; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::operator=( - const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - fullScreenExclusiveSupported = copy_src.fullScreenExclusiveSupported; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::~safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT() { FreePnextChain(pNext); } - -void safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::initialize(const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - fullScreenExclusiveSupported = in_struct->fullScreenExclusiveSupported; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::initialize(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - fullScreenExclusiveSupported = copy_src->fullScreenExclusiveSupported; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::safe_VkSurfaceFullScreenExclusiveWin32InfoEXT( - const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), hmonitor(in_struct->hmonitor) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::safe_VkSurfaceFullScreenExclusiveWin32InfoEXT() - : sType(VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT), pNext(nullptr), hmonitor() {} - -safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::safe_VkSurfaceFullScreenExclusiveWin32InfoEXT( - const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& copy_src) { - sType = copy_src.sType; - hmonitor = copy_src.hmonitor; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::operator=( - const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - hmonitor = copy_src.hmonitor; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::~safe_VkSurfaceFullScreenExclusiveWin32InfoEXT() { FreePnextChain(pNext); } - -void safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::initialize(const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - hmonitor = in_struct->hmonitor; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::initialize(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - hmonitor = copy_src->hmonitor; - pNext = SafePnextCopy(copy_src->pNext); -} -#endif // VK_USE_PLATFORM_WIN32_KHR - -safe_VkHeadlessSurfaceCreateInfoEXT::safe_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), flags(in_struct->flags) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkHeadlessSurfaceCreateInfoEXT::safe_VkHeadlessSurfaceCreateInfoEXT() - : sType(VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT), pNext(nullptr), flags() {} - -safe_VkHeadlessSurfaceCreateInfoEXT::safe_VkHeadlessSurfaceCreateInfoEXT(const safe_VkHeadlessSurfaceCreateInfoEXT& copy_src) { - sType = copy_src.sType; - flags = copy_src.flags; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkHeadlessSurfaceCreateInfoEXT& safe_VkHeadlessSurfaceCreateInfoEXT::operator=( - const safe_VkHeadlessSurfaceCreateInfoEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - flags = copy_src.flags; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkHeadlessSurfaceCreateInfoEXT::~safe_VkHeadlessSurfaceCreateInfoEXT() { FreePnextChain(pNext); } - -void safe_VkHeadlessSurfaceCreateInfoEXT::initialize(const VkHeadlessSurfaceCreateInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - flags = in_struct->flags; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkHeadlessSurfaceCreateInfoEXT::initialize(const safe_VkHeadlessSurfaceCreateInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - flags = copy_src->flags; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT( - const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - shaderBufferFloat32Atomics(in_struct->shaderBufferFloat32Atomics), - shaderBufferFloat32AtomicAdd(in_struct->shaderBufferFloat32AtomicAdd), - shaderBufferFloat64Atomics(in_struct->shaderBufferFloat64Atomics), - shaderBufferFloat64AtomicAdd(in_struct->shaderBufferFloat64AtomicAdd), - shaderSharedFloat32Atomics(in_struct->shaderSharedFloat32Atomics), - shaderSharedFloat32AtomicAdd(in_struct->shaderSharedFloat32AtomicAdd), - shaderSharedFloat64Atomics(in_struct->shaderSharedFloat64Atomics), - shaderSharedFloat64AtomicAdd(in_struct->shaderSharedFloat64AtomicAdd), - shaderImageFloat32Atomics(in_struct->shaderImageFloat32Atomics), - shaderImageFloat32AtomicAdd(in_struct->shaderImageFloat32AtomicAdd), - sparseImageFloat32Atomics(in_struct->sparseImageFloat32Atomics), - sparseImageFloat32AtomicAdd(in_struct->sparseImageFloat32AtomicAdd) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT), - pNext(nullptr), - shaderBufferFloat32Atomics(), - shaderBufferFloat32AtomicAdd(), - shaderBufferFloat64Atomics(), - shaderBufferFloat64AtomicAdd(), - shaderSharedFloat32Atomics(), - shaderSharedFloat32AtomicAdd(), - shaderSharedFloat64Atomics(), - shaderSharedFloat64AtomicAdd(), - shaderImageFloat32Atomics(), - shaderImageFloat32AtomicAdd(), - sparseImageFloat32Atomics(), - sparseImageFloat32AtomicAdd() {} - -safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT( - const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& copy_src) { - sType = copy_src.sType; - shaderBufferFloat32Atomics = copy_src.shaderBufferFloat32Atomics; - shaderBufferFloat32AtomicAdd = copy_src.shaderBufferFloat32AtomicAdd; - shaderBufferFloat64Atomics = copy_src.shaderBufferFloat64Atomics; - shaderBufferFloat64AtomicAdd = copy_src.shaderBufferFloat64AtomicAdd; - shaderSharedFloat32Atomics = copy_src.shaderSharedFloat32Atomics; - shaderSharedFloat32AtomicAdd = copy_src.shaderSharedFloat32AtomicAdd; - shaderSharedFloat64Atomics = copy_src.shaderSharedFloat64Atomics; - shaderSharedFloat64AtomicAdd = copy_src.shaderSharedFloat64AtomicAdd; - shaderImageFloat32Atomics = copy_src.shaderImageFloat32Atomics; - shaderImageFloat32AtomicAdd = copy_src.shaderImageFloat32AtomicAdd; - sparseImageFloat32Atomics = copy_src.sparseImageFloat32Atomics; - sparseImageFloat32AtomicAdd = copy_src.sparseImageFloat32AtomicAdd; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::operator=( - const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - shaderBufferFloat32Atomics = copy_src.shaderBufferFloat32Atomics; - shaderBufferFloat32AtomicAdd = copy_src.shaderBufferFloat32AtomicAdd; - shaderBufferFloat64Atomics = copy_src.shaderBufferFloat64Atomics; - shaderBufferFloat64AtomicAdd = copy_src.shaderBufferFloat64AtomicAdd; - shaderSharedFloat32Atomics = copy_src.shaderSharedFloat32Atomics; - shaderSharedFloat32AtomicAdd = copy_src.shaderSharedFloat32AtomicAdd; - shaderSharedFloat64Atomics = copy_src.shaderSharedFloat64Atomics; - shaderSharedFloat64AtomicAdd = copy_src.shaderSharedFloat64AtomicAdd; - shaderImageFloat32Atomics = copy_src.shaderImageFloat32Atomics; - shaderImageFloat32AtomicAdd = copy_src.shaderImageFloat32AtomicAdd; - sparseImageFloat32Atomics = copy_src.sparseImageFloat32Atomics; - sparseImageFloat32AtomicAdd = copy_src.sparseImageFloat32AtomicAdd; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::~safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT() { FreePnextChain(pNext); } - -void safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::initialize(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - shaderBufferFloat32Atomics = in_struct->shaderBufferFloat32Atomics; - shaderBufferFloat32AtomicAdd = in_struct->shaderBufferFloat32AtomicAdd; - shaderBufferFloat64Atomics = in_struct->shaderBufferFloat64Atomics; - shaderBufferFloat64AtomicAdd = in_struct->shaderBufferFloat64AtomicAdd; - shaderSharedFloat32Atomics = in_struct->shaderSharedFloat32Atomics; - shaderSharedFloat32AtomicAdd = in_struct->shaderSharedFloat32AtomicAdd; - shaderSharedFloat64Atomics = in_struct->shaderSharedFloat64Atomics; - shaderSharedFloat64AtomicAdd = in_struct->shaderSharedFloat64AtomicAdd; - shaderImageFloat32Atomics = in_struct->shaderImageFloat32Atomics; - shaderImageFloat32AtomicAdd = in_struct->shaderImageFloat32AtomicAdd; - sparseImageFloat32Atomics = in_struct->sparseImageFloat32Atomics; - sparseImageFloat32AtomicAdd = in_struct->sparseImageFloat32AtomicAdd; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::initialize( - const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - shaderBufferFloat32Atomics = copy_src->shaderBufferFloat32Atomics; - shaderBufferFloat32AtomicAdd = copy_src->shaderBufferFloat32AtomicAdd; - shaderBufferFloat64Atomics = copy_src->shaderBufferFloat64Atomics; - shaderBufferFloat64AtomicAdd = copy_src->shaderBufferFloat64AtomicAdd; - shaderSharedFloat32Atomics = copy_src->shaderSharedFloat32Atomics; - shaderSharedFloat32AtomicAdd = copy_src->shaderSharedFloat32AtomicAdd; - shaderSharedFloat64Atomics = copy_src->shaderSharedFloat64Atomics; - shaderSharedFloat64AtomicAdd = copy_src->shaderSharedFloat64AtomicAdd; - shaderImageFloat32Atomics = copy_src->shaderImageFloat32Atomics; - shaderImageFloat32AtomicAdd = copy_src->shaderImageFloat32AtomicAdd; - sparseImageFloat32Atomics = copy_src->sparseImageFloat32Atomics; - sparseImageFloat32AtomicAdd = copy_src->sparseImageFloat32AtomicAdd; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT( - const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), extendedDynamicState(in_struct->extendedDynamicState) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT), pNext(nullptr), extendedDynamicState() {} - -safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT( - const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& copy_src) { - sType = copy_src.sType; - extendedDynamicState = copy_src.extendedDynamicState; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::operator=( - const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - extendedDynamicState = copy_src.extendedDynamicState; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::~safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT() { - FreePnextChain(pNext); -} - -void safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::initialize( - const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - extendedDynamicState = in_struct->extendedDynamicState; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::initialize( - const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - extendedDynamicState = copy_src->extendedDynamicState; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::safe_VkPhysicalDeviceHostImageCopyFeaturesEXT( - const VkPhysicalDeviceHostImageCopyFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), hostImageCopy(in_struct->hostImageCopy) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::safe_VkPhysicalDeviceHostImageCopyFeaturesEXT() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT), pNext(nullptr), hostImageCopy() {} - -safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::safe_VkPhysicalDeviceHostImageCopyFeaturesEXT( - const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& copy_src) { - sType = copy_src.sType; - hostImageCopy = copy_src.hostImageCopy; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::operator=( - const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - hostImageCopy = copy_src.hostImageCopy; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::~safe_VkPhysicalDeviceHostImageCopyFeaturesEXT() { FreePnextChain(pNext); } - -void safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::initialize(const VkPhysicalDeviceHostImageCopyFeaturesEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - hostImageCopy = in_struct->hostImageCopy; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::initialize(const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - hostImageCopy = copy_src->hostImageCopy; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::safe_VkPhysicalDeviceHostImageCopyPropertiesEXT( - const VkPhysicalDeviceHostImageCopyPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - copySrcLayoutCount(in_struct->copySrcLayoutCount), - pCopySrcLayouts(nullptr), - copyDstLayoutCount(in_struct->copyDstLayoutCount), - pCopyDstLayouts(nullptr), - identicalMemoryTypeRequirements(in_struct->identicalMemoryTypeRequirements) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } - if (in_struct->pCopySrcLayouts) { - pCopySrcLayouts = new VkImageLayout[in_struct->copySrcLayoutCount]; - memcpy((void*)pCopySrcLayouts, (void*)in_struct->pCopySrcLayouts, sizeof(VkImageLayout) * in_struct->copySrcLayoutCount); - } - - if (in_struct->pCopyDstLayouts) { - pCopyDstLayouts = new VkImageLayout[in_struct->copyDstLayoutCount]; - memcpy((void*)pCopyDstLayouts, (void*)in_struct->pCopyDstLayouts, sizeof(VkImageLayout) * in_struct->copyDstLayoutCount); - } - - for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { - optimalTilingLayoutUUID[i] = in_struct->optimalTilingLayoutUUID[i]; - } -} - -safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::safe_VkPhysicalDeviceHostImageCopyPropertiesEXT() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT), - pNext(nullptr), - copySrcLayoutCount(), - pCopySrcLayouts(nullptr), - copyDstLayoutCount(), - pCopyDstLayouts(nullptr), - identicalMemoryTypeRequirements() {} - -safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::safe_VkPhysicalDeviceHostImageCopyPropertiesEXT( - const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& copy_src) { - sType = copy_src.sType; - copySrcLayoutCount = copy_src.copySrcLayoutCount; - pCopySrcLayouts = nullptr; - copyDstLayoutCount = copy_src.copyDstLayoutCount; - pCopyDstLayouts = nullptr; - identicalMemoryTypeRequirements = copy_src.identicalMemoryTypeRequirements; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pCopySrcLayouts) { - pCopySrcLayouts = new VkImageLayout[copy_src.copySrcLayoutCount]; - memcpy((void*)pCopySrcLayouts, (void*)copy_src.pCopySrcLayouts, sizeof(VkImageLayout) * copy_src.copySrcLayoutCount); - } - - if (copy_src.pCopyDstLayouts) { - pCopyDstLayouts = new VkImageLayout[copy_src.copyDstLayoutCount]; - memcpy((void*)pCopyDstLayouts, (void*)copy_src.pCopyDstLayouts, sizeof(VkImageLayout) * copy_src.copyDstLayoutCount); - } - - for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { - optimalTilingLayoutUUID[i] = copy_src.optimalTilingLayoutUUID[i]; - } -} - -safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::operator=( - const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& copy_src) { - if (©_src == this) return *this; - - if (pCopySrcLayouts) delete[] pCopySrcLayouts; - if (pCopyDstLayouts) delete[] pCopyDstLayouts; - FreePnextChain(pNext); - - sType = copy_src.sType; - copySrcLayoutCount = copy_src.copySrcLayoutCount; - pCopySrcLayouts = nullptr; - copyDstLayoutCount = copy_src.copyDstLayoutCount; - pCopyDstLayouts = nullptr; - identicalMemoryTypeRequirements = copy_src.identicalMemoryTypeRequirements; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pCopySrcLayouts) { - pCopySrcLayouts = new VkImageLayout[copy_src.copySrcLayoutCount]; - memcpy((void*)pCopySrcLayouts, (void*)copy_src.pCopySrcLayouts, sizeof(VkImageLayout) * copy_src.copySrcLayoutCount); - } - - if (copy_src.pCopyDstLayouts) { - pCopyDstLayouts = new VkImageLayout[copy_src.copyDstLayoutCount]; - memcpy((void*)pCopyDstLayouts, (void*)copy_src.pCopyDstLayouts, sizeof(VkImageLayout) * copy_src.copyDstLayoutCount); - } - - for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { - optimalTilingLayoutUUID[i] = copy_src.optimalTilingLayoutUUID[i]; - } - - return *this; -} - -safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::~safe_VkPhysicalDeviceHostImageCopyPropertiesEXT() { - if (pCopySrcLayouts) delete[] pCopySrcLayouts; - if (pCopyDstLayouts) delete[] pCopyDstLayouts; - FreePnextChain(pNext); -} - -void safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::initialize(const VkPhysicalDeviceHostImageCopyPropertiesEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pCopySrcLayouts) delete[] pCopySrcLayouts; - if (pCopyDstLayouts) delete[] pCopyDstLayouts; - FreePnextChain(pNext); - sType = in_struct->sType; - copySrcLayoutCount = in_struct->copySrcLayoutCount; - pCopySrcLayouts = nullptr; - copyDstLayoutCount = in_struct->copyDstLayoutCount; - pCopyDstLayouts = nullptr; - identicalMemoryTypeRequirements = in_struct->identicalMemoryTypeRequirements; - pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pCopySrcLayouts) { - pCopySrcLayouts = new VkImageLayout[in_struct->copySrcLayoutCount]; - memcpy((void*)pCopySrcLayouts, (void*)in_struct->pCopySrcLayouts, sizeof(VkImageLayout) * in_struct->copySrcLayoutCount); - } - - if (in_struct->pCopyDstLayouts) { - pCopyDstLayouts = new VkImageLayout[in_struct->copyDstLayoutCount]; - memcpy((void*)pCopyDstLayouts, (void*)in_struct->pCopyDstLayouts, sizeof(VkImageLayout) * in_struct->copyDstLayoutCount); - } - - for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { - optimalTilingLayoutUUID[i] = in_struct->optimalTilingLayoutUUID[i]; - } -} - -void safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::initialize(const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - copySrcLayoutCount = copy_src->copySrcLayoutCount; - pCopySrcLayouts = nullptr; - copyDstLayoutCount = copy_src->copyDstLayoutCount; - pCopyDstLayouts = nullptr; - identicalMemoryTypeRequirements = copy_src->identicalMemoryTypeRequirements; - pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pCopySrcLayouts) { - pCopySrcLayouts = new VkImageLayout[copy_src->copySrcLayoutCount]; - memcpy((void*)pCopySrcLayouts, (void*)copy_src->pCopySrcLayouts, sizeof(VkImageLayout) * copy_src->copySrcLayoutCount); - } - - if (copy_src->pCopyDstLayouts) { - pCopyDstLayouts = new VkImageLayout[copy_src->copyDstLayoutCount]; - memcpy((void*)pCopyDstLayouts, (void*)copy_src->pCopyDstLayouts, sizeof(VkImageLayout) * copy_src->copyDstLayoutCount); - } - - for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { - optimalTilingLayoutUUID[i] = copy_src->optimalTilingLayoutUUID[i]; - } -} - -safe_VkMemoryToImageCopyEXT::safe_VkMemoryToImageCopyEXT(const VkMemoryToImageCopyEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - pHostPointer(in_struct->pHostPointer), - memoryRowLength(in_struct->memoryRowLength), - memoryImageHeight(in_struct->memoryImageHeight), - imageSubresource(in_struct->imageSubresource), - imageOffset(in_struct->imageOffset), - imageExtent(in_struct->imageExtent) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkMemoryToImageCopyEXT::safe_VkMemoryToImageCopyEXT() - : sType(VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT), - pNext(nullptr), - pHostPointer(nullptr), - memoryRowLength(), - memoryImageHeight(), - imageSubresource(), - imageOffset(), - imageExtent() {} - -safe_VkMemoryToImageCopyEXT::safe_VkMemoryToImageCopyEXT(const safe_VkMemoryToImageCopyEXT& copy_src) { - sType = copy_src.sType; - pHostPointer = copy_src.pHostPointer; - memoryRowLength = copy_src.memoryRowLength; - memoryImageHeight = copy_src.memoryImageHeight; - imageSubresource = copy_src.imageSubresource; - imageOffset = copy_src.imageOffset; - imageExtent = copy_src.imageExtent; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkMemoryToImageCopyEXT& safe_VkMemoryToImageCopyEXT::operator=(const safe_VkMemoryToImageCopyEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - pHostPointer = copy_src.pHostPointer; - memoryRowLength = copy_src.memoryRowLength; - memoryImageHeight = copy_src.memoryImageHeight; - imageSubresource = copy_src.imageSubresource; - imageOffset = copy_src.imageOffset; - imageExtent = copy_src.imageExtent; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkMemoryToImageCopyEXT::~safe_VkMemoryToImageCopyEXT() { FreePnextChain(pNext); } - -void safe_VkMemoryToImageCopyEXT::initialize(const VkMemoryToImageCopyEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - pHostPointer = in_struct->pHostPointer; - memoryRowLength = in_struct->memoryRowLength; - memoryImageHeight = in_struct->memoryImageHeight; - imageSubresource = in_struct->imageSubresource; - imageOffset = in_struct->imageOffset; - imageExtent = in_struct->imageExtent; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkMemoryToImageCopyEXT::initialize(const safe_VkMemoryToImageCopyEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - pHostPointer = copy_src->pHostPointer; - memoryRowLength = copy_src->memoryRowLength; - memoryImageHeight = copy_src->memoryImageHeight; - imageSubresource = copy_src->imageSubresource; - imageOffset = copy_src->imageOffset; - imageExtent = copy_src->imageExtent; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkImageToMemoryCopyEXT::safe_VkImageToMemoryCopyEXT(const VkImageToMemoryCopyEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - pHostPointer(in_struct->pHostPointer), - memoryRowLength(in_struct->memoryRowLength), - memoryImageHeight(in_struct->memoryImageHeight), - imageSubresource(in_struct->imageSubresource), - imageOffset(in_struct->imageOffset), - imageExtent(in_struct->imageExtent) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkImageToMemoryCopyEXT::safe_VkImageToMemoryCopyEXT() - : sType(VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT), - pNext(nullptr), - pHostPointer(nullptr), - memoryRowLength(), - memoryImageHeight(), - imageSubresource(), - imageOffset(), - imageExtent() {} - -safe_VkImageToMemoryCopyEXT::safe_VkImageToMemoryCopyEXT(const safe_VkImageToMemoryCopyEXT& copy_src) { - sType = copy_src.sType; - pHostPointer = copy_src.pHostPointer; - memoryRowLength = copy_src.memoryRowLength; - memoryImageHeight = copy_src.memoryImageHeight; - imageSubresource = copy_src.imageSubresource; - imageOffset = copy_src.imageOffset; - imageExtent = copy_src.imageExtent; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkImageToMemoryCopyEXT& safe_VkImageToMemoryCopyEXT::operator=(const safe_VkImageToMemoryCopyEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - pHostPointer = copy_src.pHostPointer; - memoryRowLength = copy_src.memoryRowLength; - memoryImageHeight = copy_src.memoryImageHeight; - imageSubresource = copy_src.imageSubresource; - imageOffset = copy_src.imageOffset; - imageExtent = copy_src.imageExtent; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkImageToMemoryCopyEXT::~safe_VkImageToMemoryCopyEXT() { FreePnextChain(pNext); } - -void safe_VkImageToMemoryCopyEXT::initialize(const VkImageToMemoryCopyEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - pHostPointer = in_struct->pHostPointer; - memoryRowLength = in_struct->memoryRowLength; - memoryImageHeight = in_struct->memoryImageHeight; - imageSubresource = in_struct->imageSubresource; - imageOffset = in_struct->imageOffset; - imageExtent = in_struct->imageExtent; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkImageToMemoryCopyEXT::initialize(const safe_VkImageToMemoryCopyEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - pHostPointer = copy_src->pHostPointer; - memoryRowLength = copy_src->memoryRowLength; - memoryImageHeight = copy_src->memoryImageHeight; - imageSubresource = copy_src->imageSubresource; - imageOffset = copy_src->imageOffset; - imageExtent = copy_src->imageExtent; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkCopyMemoryToImageInfoEXT::safe_VkCopyMemoryToImageInfoEXT(const VkCopyMemoryToImageInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - flags(in_struct->flags), - dstImage(in_struct->dstImage), - dstImageLayout(in_struct->dstImageLayout), - regionCount(in_struct->regionCount), - pRegions(nullptr) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } - if (regionCount && in_struct->pRegions) { - pRegions = new safe_VkMemoryToImageCopyEXT[regionCount]; - for (uint32_t i = 0; i < regionCount; ++i) { - pRegions[i].initialize(&in_struct->pRegions[i]); - } - } -} - -safe_VkCopyMemoryToImageInfoEXT::safe_VkCopyMemoryToImageInfoEXT() - : sType(VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT), - pNext(nullptr), - flags(), - dstImage(), - dstImageLayout(), - regionCount(), - pRegions(nullptr) {} - -safe_VkCopyMemoryToImageInfoEXT::safe_VkCopyMemoryToImageInfoEXT(const safe_VkCopyMemoryToImageInfoEXT& copy_src) { - sType = copy_src.sType; - flags = copy_src.flags; - dstImage = copy_src.dstImage; - dstImageLayout = copy_src.dstImageLayout; - regionCount = copy_src.regionCount; - pRegions = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (regionCount && copy_src.pRegions) { - pRegions = new safe_VkMemoryToImageCopyEXT[regionCount]; - for (uint32_t i = 0; i < regionCount; ++i) { - pRegions[i].initialize(©_src.pRegions[i]); - } - } -} - -safe_VkCopyMemoryToImageInfoEXT& safe_VkCopyMemoryToImageInfoEXT::operator=(const safe_VkCopyMemoryToImageInfoEXT& copy_src) { - if (©_src == this) return *this; - - if (pRegions) delete[] pRegions; - FreePnextChain(pNext); - - sType = copy_src.sType; - flags = copy_src.flags; - dstImage = copy_src.dstImage; - dstImageLayout = copy_src.dstImageLayout; - regionCount = copy_src.regionCount; - pRegions = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (regionCount && copy_src.pRegions) { - pRegions = new safe_VkMemoryToImageCopyEXT[regionCount]; - for (uint32_t i = 0; i < regionCount; ++i) { - pRegions[i].initialize(©_src.pRegions[i]); - } - } - - return *this; -} - -safe_VkCopyMemoryToImageInfoEXT::~safe_VkCopyMemoryToImageInfoEXT() { - if (pRegions) delete[] pRegions; - FreePnextChain(pNext); -} - -void safe_VkCopyMemoryToImageInfoEXT::initialize(const VkCopyMemoryToImageInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pRegions) delete[] pRegions; - FreePnextChain(pNext); - sType = in_struct->sType; - flags = in_struct->flags; - dstImage = in_struct->dstImage; - dstImageLayout = in_struct->dstImageLayout; - regionCount = in_struct->regionCount; - pRegions = nullptr; - pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (regionCount && in_struct->pRegions) { - pRegions = new safe_VkMemoryToImageCopyEXT[regionCount]; - for (uint32_t i = 0; i < regionCount; ++i) { - pRegions[i].initialize(&in_struct->pRegions[i]); - } - } -} - -void safe_VkCopyMemoryToImageInfoEXT::initialize(const safe_VkCopyMemoryToImageInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - flags = copy_src->flags; - dstImage = copy_src->dstImage; - dstImageLayout = copy_src->dstImageLayout; - regionCount = copy_src->regionCount; - pRegions = nullptr; - pNext = SafePnextCopy(copy_src->pNext); - if (regionCount && copy_src->pRegions) { - pRegions = new safe_VkMemoryToImageCopyEXT[regionCount]; - for (uint32_t i = 0; i < regionCount; ++i) { - pRegions[i].initialize(©_src->pRegions[i]); - } - } -} - -safe_VkCopyImageToMemoryInfoEXT::safe_VkCopyImageToMemoryInfoEXT(const VkCopyImageToMemoryInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - flags(in_struct->flags), - srcImage(in_struct->srcImage), - srcImageLayout(in_struct->srcImageLayout), - regionCount(in_struct->regionCount), - pRegions(nullptr) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } - if (regionCount && in_struct->pRegions) { - pRegions = new safe_VkImageToMemoryCopyEXT[regionCount]; - for (uint32_t i = 0; i < regionCount; ++i) { - pRegions[i].initialize(&in_struct->pRegions[i]); - } - } -} - -safe_VkCopyImageToMemoryInfoEXT::safe_VkCopyImageToMemoryInfoEXT() - : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT), - pNext(nullptr), - flags(), - srcImage(), - srcImageLayout(), - regionCount(), - pRegions(nullptr) {} + : sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT), pNext(nullptr), fullScreenExclusiveSupported() {} -safe_VkCopyImageToMemoryInfoEXT::safe_VkCopyImageToMemoryInfoEXT(const safe_VkCopyImageToMemoryInfoEXT& copy_src) { +safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT( + const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& copy_src) { sType = copy_src.sType; - flags = copy_src.flags; - srcImage = copy_src.srcImage; - srcImageLayout = copy_src.srcImageLayout; - regionCount = copy_src.regionCount; - pRegions = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (regionCount && copy_src.pRegions) { - pRegions = new safe_VkImageToMemoryCopyEXT[regionCount]; - for (uint32_t i = 0; i < regionCount; ++i) { - pRegions[i].initialize(©_src.pRegions[i]); - } - } + fullScreenExclusiveSupported = copy_src.fullScreenExclusiveSupported; + pNext = SafePnextCopy(copy_src.pNext); } -safe_VkCopyImageToMemoryInfoEXT& safe_VkCopyImageToMemoryInfoEXT::operator=(const safe_VkCopyImageToMemoryInfoEXT& copy_src) { +safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::operator=( + const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& copy_src) { if (©_src == this) return *this; - if (pRegions) delete[] pRegions; FreePnextChain(pNext); sType = copy_src.sType; - flags = copy_src.flags; - srcImage = copy_src.srcImage; - srcImageLayout = copy_src.srcImageLayout; - regionCount = copy_src.regionCount; - pRegions = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (regionCount && copy_src.pRegions) { - pRegions = new safe_VkImageToMemoryCopyEXT[regionCount]; - for (uint32_t i = 0; i < regionCount; ++i) { - pRegions[i].initialize(©_src.pRegions[i]); - } - } + fullScreenExclusiveSupported = copy_src.fullScreenExclusiveSupported; + pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkCopyImageToMemoryInfoEXT::~safe_VkCopyImageToMemoryInfoEXT() { - if (pRegions) delete[] pRegions; - FreePnextChain(pNext); -} +safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::~safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT() { FreePnextChain(pNext); } -void safe_VkCopyImageToMemoryInfoEXT::initialize(const VkCopyImageToMemoryInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pRegions) delete[] pRegions; +void safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::initialize(const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - flags = in_struct->flags; - srcImage = in_struct->srcImage; - srcImageLayout = in_struct->srcImageLayout; - regionCount = in_struct->regionCount; - pRegions = nullptr; + fullScreenExclusiveSupported = in_struct->fullScreenExclusiveSupported; pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (regionCount && in_struct->pRegions) { - pRegions = new safe_VkImageToMemoryCopyEXT[regionCount]; - for (uint32_t i = 0; i < regionCount; ++i) { - pRegions[i].initialize(&in_struct->pRegions[i]); - } - } } -void safe_VkCopyImageToMemoryInfoEXT::initialize(const safe_VkCopyImageToMemoryInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::initialize(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - flags = copy_src->flags; - srcImage = copy_src->srcImage; - srcImageLayout = copy_src->srcImageLayout; - regionCount = copy_src->regionCount; - pRegions = nullptr; + fullScreenExclusiveSupported = copy_src->fullScreenExclusiveSupported; pNext = SafePnextCopy(copy_src->pNext); - if (regionCount && copy_src->pRegions) { - pRegions = new safe_VkImageToMemoryCopyEXT[regionCount]; - for (uint32_t i = 0; i < regionCount; ++i) { - pRegions[i].initialize(©_src->pRegions[i]); - } - } } -safe_VkCopyImageToImageInfoEXT::safe_VkCopyImageToImageInfoEXT(const VkCopyImageToImageInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - flags(in_struct->flags), - srcImage(in_struct->srcImage), - srcImageLayout(in_struct->srcImageLayout), - dstImage(in_struct->dstImage), - dstImageLayout(in_struct->dstImageLayout), - regionCount(in_struct->regionCount), - pRegions(nullptr) { +safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::safe_VkSurfaceFullScreenExclusiveWin32InfoEXT( + const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), hmonitor(in_struct->hmonitor) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (regionCount && in_struct->pRegions) { - pRegions = new safe_VkImageCopy2[regionCount]; - for (uint32_t i = 0; i < regionCount; ++i) { - pRegions[i].initialize(&in_struct->pRegions[i]); - } - } } -safe_VkCopyImageToImageInfoEXT::safe_VkCopyImageToImageInfoEXT() - : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT), - pNext(nullptr), - flags(), - srcImage(), - srcImageLayout(), - dstImage(), - dstImageLayout(), - regionCount(), - pRegions(nullptr) {} +safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::safe_VkSurfaceFullScreenExclusiveWin32InfoEXT() + : sType(VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT), pNext(nullptr), hmonitor() {} -safe_VkCopyImageToImageInfoEXT::safe_VkCopyImageToImageInfoEXT(const safe_VkCopyImageToImageInfoEXT& copy_src) { +safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::safe_VkSurfaceFullScreenExclusiveWin32InfoEXT( + const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& copy_src) { sType = copy_src.sType; - flags = copy_src.flags; - srcImage = copy_src.srcImage; - srcImageLayout = copy_src.srcImageLayout; - dstImage = copy_src.dstImage; - dstImageLayout = copy_src.dstImageLayout; - regionCount = copy_src.regionCount; - pRegions = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (regionCount && copy_src.pRegions) { - pRegions = new safe_VkImageCopy2[regionCount]; - for (uint32_t i = 0; i < regionCount; ++i) { - pRegions[i].initialize(©_src.pRegions[i]); - } - } + hmonitor = copy_src.hmonitor; + pNext = SafePnextCopy(copy_src.pNext); } -safe_VkCopyImageToImageInfoEXT& safe_VkCopyImageToImageInfoEXT::operator=(const safe_VkCopyImageToImageInfoEXT& copy_src) { +safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::operator=( + const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& copy_src) { if (©_src == this) return *this; - if (pRegions) delete[] pRegions; FreePnextChain(pNext); sType = copy_src.sType; - flags = copy_src.flags; - srcImage = copy_src.srcImage; - srcImageLayout = copy_src.srcImageLayout; - dstImage = copy_src.dstImage; - dstImageLayout = copy_src.dstImageLayout; - regionCount = copy_src.regionCount; - pRegions = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (regionCount && copy_src.pRegions) { - pRegions = new safe_VkImageCopy2[regionCount]; - for (uint32_t i = 0; i < regionCount; ++i) { - pRegions[i].initialize(©_src.pRegions[i]); - } - } + hmonitor = copy_src.hmonitor; + pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkCopyImageToImageInfoEXT::~safe_VkCopyImageToImageInfoEXT() { - if (pRegions) delete[] pRegions; - FreePnextChain(pNext); -} +safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::~safe_VkSurfaceFullScreenExclusiveWin32InfoEXT() { FreePnextChain(pNext); } -void safe_VkCopyImageToImageInfoEXT::initialize(const VkCopyImageToImageInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pRegions) delete[] pRegions; +void safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::initialize(const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - flags = in_struct->flags; - srcImage = in_struct->srcImage; - srcImageLayout = in_struct->srcImageLayout; - dstImage = in_struct->dstImage; - dstImageLayout = in_struct->dstImageLayout; - regionCount = in_struct->regionCount; - pRegions = nullptr; + hmonitor = in_struct->hmonitor; pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (regionCount && in_struct->pRegions) { - pRegions = new safe_VkImageCopy2[regionCount]; - for (uint32_t i = 0; i < regionCount; ++i) { - pRegions[i].initialize(&in_struct->pRegions[i]); - } - } } -void safe_VkCopyImageToImageInfoEXT::initialize(const safe_VkCopyImageToImageInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::initialize(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - flags = copy_src->flags; - srcImage = copy_src->srcImage; - srcImageLayout = copy_src->srcImageLayout; - dstImage = copy_src->dstImage; - dstImageLayout = copy_src->dstImageLayout; - regionCount = copy_src->regionCount; - pRegions = nullptr; + hmonitor = copy_src->hmonitor; pNext = SafePnextCopy(copy_src->pNext); - if (regionCount && copy_src->pRegions) { - pRegions = new safe_VkImageCopy2[regionCount]; - for (uint32_t i = 0; i < regionCount; ++i) { - pRegions[i].initialize(©_src->pRegions[i]); - } - } } +#endif // VK_USE_PLATFORM_WIN32_KHR -safe_VkHostImageLayoutTransitionInfoEXT::safe_VkHostImageLayoutTransitionInfoEXT( - const VkHostImageLayoutTransitionInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - image(in_struct->image), - oldLayout(in_struct->oldLayout), - newLayout(in_struct->newLayout), - subresourceRange(in_struct->subresourceRange) { +safe_VkHeadlessSurfaceCreateInfoEXT::safe_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkHostImageLayoutTransitionInfoEXT::safe_VkHostImageLayoutTransitionInfoEXT() - : sType(VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT), - pNext(nullptr), - image(), - oldLayout(), - newLayout(), - subresourceRange() {} +safe_VkHeadlessSurfaceCreateInfoEXT::safe_VkHeadlessSurfaceCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT), pNext(nullptr), flags() {} -safe_VkHostImageLayoutTransitionInfoEXT::safe_VkHostImageLayoutTransitionInfoEXT( - const safe_VkHostImageLayoutTransitionInfoEXT& copy_src) { +safe_VkHeadlessSurfaceCreateInfoEXT::safe_VkHeadlessSurfaceCreateInfoEXT(const safe_VkHeadlessSurfaceCreateInfoEXT& copy_src) { sType = copy_src.sType; - image = copy_src.image; - oldLayout = copy_src.oldLayout; - newLayout = copy_src.newLayout; - subresourceRange = copy_src.subresourceRange; + flags = copy_src.flags; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkHostImageLayoutTransitionInfoEXT& safe_VkHostImageLayoutTransitionInfoEXT::operator=( - const safe_VkHostImageLayoutTransitionInfoEXT& copy_src) { +safe_VkHeadlessSurfaceCreateInfoEXT& safe_VkHeadlessSurfaceCreateInfoEXT::operator=( + const safe_VkHeadlessSurfaceCreateInfoEXT& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - image = copy_src.image; - oldLayout = copy_src.oldLayout; - newLayout = copy_src.newLayout; - subresourceRange = copy_src.subresourceRange; + flags = copy_src.flags; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkHostImageLayoutTransitionInfoEXT::~safe_VkHostImageLayoutTransitionInfoEXT() { FreePnextChain(pNext); } +safe_VkHeadlessSurfaceCreateInfoEXT::~safe_VkHeadlessSurfaceCreateInfoEXT() { FreePnextChain(pNext); } -void safe_VkHostImageLayoutTransitionInfoEXT::initialize(const VkHostImageLayoutTransitionInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkHeadlessSurfaceCreateInfoEXT::initialize(const VkHeadlessSurfaceCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - image = in_struct->image; - oldLayout = in_struct->oldLayout; - newLayout = in_struct->newLayout; - subresourceRange = in_struct->subresourceRange; + flags = in_struct->flags; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkHostImageLayoutTransitionInfoEXT::initialize(const safe_VkHostImageLayoutTransitionInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkHeadlessSurfaceCreateInfoEXT::initialize(const safe_VkHeadlessSurfaceCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - image = copy_src->image; - oldLayout = copy_src->oldLayout; - newLayout = copy_src->newLayout; - subresourceRange = copy_src->subresourceRange; + flags = copy_src->flags; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkSubresourceHostMemcpySizeEXT::safe_VkSubresourceHostMemcpySizeEXT(const VkSubresourceHostMemcpySizeEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), size(in_struct->size) { +safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT( + const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shaderBufferFloat32Atomics(in_struct->shaderBufferFloat32Atomics), + shaderBufferFloat32AtomicAdd(in_struct->shaderBufferFloat32AtomicAdd), + shaderBufferFloat64Atomics(in_struct->shaderBufferFloat64Atomics), + shaderBufferFloat64AtomicAdd(in_struct->shaderBufferFloat64AtomicAdd), + shaderSharedFloat32Atomics(in_struct->shaderSharedFloat32Atomics), + shaderSharedFloat32AtomicAdd(in_struct->shaderSharedFloat32AtomicAdd), + shaderSharedFloat64Atomics(in_struct->shaderSharedFloat64Atomics), + shaderSharedFloat64AtomicAdd(in_struct->shaderSharedFloat64AtomicAdd), + shaderImageFloat32Atomics(in_struct->shaderImageFloat32Atomics), + shaderImageFloat32AtomicAdd(in_struct->shaderImageFloat32AtomicAdd), + sparseImageFloat32Atomics(in_struct->sparseImageFloat32Atomics), + sparseImageFloat32AtomicAdd(in_struct->sparseImageFloat32AtomicAdd) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkSubresourceHostMemcpySizeEXT::safe_VkSubresourceHostMemcpySizeEXT() - : sType(VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT), pNext(nullptr), size() {} +safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT), + pNext(nullptr), + shaderBufferFloat32Atomics(), + shaderBufferFloat32AtomicAdd(), + shaderBufferFloat64Atomics(), + shaderBufferFloat64AtomicAdd(), + shaderSharedFloat32Atomics(), + shaderSharedFloat32AtomicAdd(), + shaderSharedFloat64Atomics(), + shaderSharedFloat64AtomicAdd(), + shaderImageFloat32Atomics(), + shaderImageFloat32AtomicAdd(), + sparseImageFloat32Atomics(), + sparseImageFloat32AtomicAdd() {} -safe_VkSubresourceHostMemcpySizeEXT::safe_VkSubresourceHostMemcpySizeEXT(const safe_VkSubresourceHostMemcpySizeEXT& copy_src) { +safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT( + const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& copy_src) { sType = copy_src.sType; - size = copy_src.size; + shaderBufferFloat32Atomics = copy_src.shaderBufferFloat32Atomics; + shaderBufferFloat32AtomicAdd = copy_src.shaderBufferFloat32AtomicAdd; + shaderBufferFloat64Atomics = copy_src.shaderBufferFloat64Atomics; + shaderBufferFloat64AtomicAdd = copy_src.shaderBufferFloat64AtomicAdd; + shaderSharedFloat32Atomics = copy_src.shaderSharedFloat32Atomics; + shaderSharedFloat32AtomicAdd = copy_src.shaderSharedFloat32AtomicAdd; + shaderSharedFloat64Atomics = copy_src.shaderSharedFloat64Atomics; + shaderSharedFloat64AtomicAdd = copy_src.shaderSharedFloat64AtomicAdd; + shaderImageFloat32Atomics = copy_src.shaderImageFloat32Atomics; + shaderImageFloat32AtomicAdd = copy_src.shaderImageFloat32AtomicAdd; + sparseImageFloat32Atomics = copy_src.sparseImageFloat32Atomics; + sparseImageFloat32AtomicAdd = copy_src.sparseImageFloat32AtomicAdd; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkSubresourceHostMemcpySizeEXT& safe_VkSubresourceHostMemcpySizeEXT::operator=( - const safe_VkSubresourceHostMemcpySizeEXT& copy_src) { +safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::operator=( + const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - size = copy_src.size; + shaderBufferFloat32Atomics = copy_src.shaderBufferFloat32Atomics; + shaderBufferFloat32AtomicAdd = copy_src.shaderBufferFloat32AtomicAdd; + shaderBufferFloat64Atomics = copy_src.shaderBufferFloat64Atomics; + shaderBufferFloat64AtomicAdd = copy_src.shaderBufferFloat64AtomicAdd; + shaderSharedFloat32Atomics = copy_src.shaderSharedFloat32Atomics; + shaderSharedFloat32AtomicAdd = copy_src.shaderSharedFloat32AtomicAdd; + shaderSharedFloat64Atomics = copy_src.shaderSharedFloat64Atomics; + shaderSharedFloat64AtomicAdd = copy_src.shaderSharedFloat64AtomicAdd; + shaderImageFloat32Atomics = copy_src.shaderImageFloat32Atomics; + shaderImageFloat32AtomicAdd = copy_src.shaderImageFloat32AtomicAdd; + sparseImageFloat32Atomics = copy_src.sparseImageFloat32Atomics; + sparseImageFloat32AtomicAdd = copy_src.sparseImageFloat32AtomicAdd; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkSubresourceHostMemcpySizeEXT::~safe_VkSubresourceHostMemcpySizeEXT() { FreePnextChain(pNext); } +safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::~safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT() { FreePnextChain(pNext); } -void safe_VkSubresourceHostMemcpySizeEXT::initialize(const VkSubresourceHostMemcpySizeEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::initialize(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - size = in_struct->size; + shaderBufferFloat32Atomics = in_struct->shaderBufferFloat32Atomics; + shaderBufferFloat32AtomicAdd = in_struct->shaderBufferFloat32AtomicAdd; + shaderBufferFloat64Atomics = in_struct->shaderBufferFloat64Atomics; + shaderBufferFloat64AtomicAdd = in_struct->shaderBufferFloat64AtomicAdd; + shaderSharedFloat32Atomics = in_struct->shaderSharedFloat32Atomics; + shaderSharedFloat32AtomicAdd = in_struct->shaderSharedFloat32AtomicAdd; + shaderSharedFloat64Atomics = in_struct->shaderSharedFloat64Atomics; + shaderSharedFloat64AtomicAdd = in_struct->shaderSharedFloat64AtomicAdd; + shaderImageFloat32Atomics = in_struct->shaderImageFloat32Atomics; + shaderImageFloat32AtomicAdd = in_struct->shaderImageFloat32AtomicAdd; + sparseImageFloat32Atomics = in_struct->sparseImageFloat32Atomics; + sparseImageFloat32AtomicAdd = in_struct->sparseImageFloat32AtomicAdd; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkSubresourceHostMemcpySizeEXT::initialize(const safe_VkSubresourceHostMemcpySizeEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::initialize( + const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - size = copy_src->size; + shaderBufferFloat32Atomics = copy_src->shaderBufferFloat32Atomics; + shaderBufferFloat32AtomicAdd = copy_src->shaderBufferFloat32AtomicAdd; + shaderBufferFloat64Atomics = copy_src->shaderBufferFloat64Atomics; + shaderBufferFloat64AtomicAdd = copy_src->shaderBufferFloat64AtomicAdd; + shaderSharedFloat32Atomics = copy_src->shaderSharedFloat32Atomics; + shaderSharedFloat32AtomicAdd = copy_src->shaderSharedFloat32AtomicAdd; + shaderSharedFloat64Atomics = copy_src->shaderSharedFloat64Atomics; + shaderSharedFloat64AtomicAdd = copy_src->shaderSharedFloat64AtomicAdd; + shaderImageFloat32Atomics = copy_src->shaderImageFloat32Atomics; + shaderImageFloat32AtomicAdd = copy_src->shaderImageFloat32AtomicAdd; + sparseImageFloat32Atomics = copy_src->sparseImageFloat32Atomics; + sparseImageFloat32AtomicAdd = copy_src->sparseImageFloat32AtomicAdd; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkHostImageCopyDevicePerformanceQueryEXT::safe_VkHostImageCopyDevicePerformanceQueryEXT( - const VkHostImageCopyDevicePerformanceQueryEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - optimalDeviceAccess(in_struct->optimalDeviceAccess), - identicalMemoryLayout(in_struct->identicalMemoryLayout) { +safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT( + const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), extendedDynamicState(in_struct->extendedDynamicState) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkHostImageCopyDevicePerformanceQueryEXT::safe_VkHostImageCopyDevicePerformanceQueryEXT() - : sType(VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT), - pNext(nullptr), - optimalDeviceAccess(), - identicalMemoryLayout() {} +safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT), pNext(nullptr), extendedDynamicState() {} -safe_VkHostImageCopyDevicePerformanceQueryEXT::safe_VkHostImageCopyDevicePerformanceQueryEXT( - const safe_VkHostImageCopyDevicePerformanceQueryEXT& copy_src) { +safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT( + const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& copy_src) { sType = copy_src.sType; - optimalDeviceAccess = copy_src.optimalDeviceAccess; - identicalMemoryLayout = copy_src.identicalMemoryLayout; + extendedDynamicState = copy_src.extendedDynamicState; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkHostImageCopyDevicePerformanceQueryEXT& safe_VkHostImageCopyDevicePerformanceQueryEXT::operator=( - const safe_VkHostImageCopyDevicePerformanceQueryEXT& copy_src) { +safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::operator=( + const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - optimalDeviceAccess = copy_src.optimalDeviceAccess; - identicalMemoryLayout = copy_src.identicalMemoryLayout; + extendedDynamicState = copy_src.extendedDynamicState; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkHostImageCopyDevicePerformanceQueryEXT::~safe_VkHostImageCopyDevicePerformanceQueryEXT() { FreePnextChain(pNext); } +safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::~safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT() { + FreePnextChain(pNext); +} -void safe_VkHostImageCopyDevicePerformanceQueryEXT::initialize(const VkHostImageCopyDevicePerformanceQueryEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::initialize( + const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - optimalDeviceAccess = in_struct->optimalDeviceAccess; - identicalMemoryLayout = in_struct->identicalMemoryLayout; + extendedDynamicState = in_struct->extendedDynamicState; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkHostImageCopyDevicePerformanceQueryEXT::initialize(const safe_VkHostImageCopyDevicePerformanceQueryEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::initialize( + const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - optimalDeviceAccess = copy_src->optimalDeviceAccess; - identicalMemoryLayout = copy_src->identicalMemoryLayout; + extendedDynamicState = copy_src->extendedDynamicState; pNext = SafePnextCopy(copy_src->pNext); } @@ -14552,57 +13497,6 @@ void safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT::initialize(const safe_VkPh pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT( - const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), pipelineProtectedAccess(in_struct->pipelineProtectedAccess) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT), pNext(nullptr), pipelineProtectedAccess() {} - -safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT( - const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& copy_src) { - sType = copy_src.sType; - pipelineProtectedAccess = copy_src.pipelineProtectedAccess; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::operator=( - const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - pipelineProtectedAccess = copy_src.pipelineProtectedAccess; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::~safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT() { - FreePnextChain(pNext); -} - -void safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::initialize( - const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - pipelineProtectedAccess = in_struct->pipelineProtectedAccess; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::initialize( - const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - pipelineProtectedAccess = copy_src->pipelineProtectedAccess; - pNext = SafePnextCopy(copy_src->pNext); -} - safe_VkPhysicalDeviceShaderObjectFeaturesEXT::safe_VkPhysicalDeviceShaderObjectFeaturesEXT( const VkPhysicalDeviceShaderObjectFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), shaderObject(in_struct->shaderObject) { diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp index 735e5d8..bde9965 100644 --- a/src/vulkan/vk_safe_struct_khr.cpp +++ b/src/vulkan/vk_safe_struct_khr.cpp @@ -6384,54 +6384,6 @@ void safe_VkSemaphoreGetFdInfoKHR::initialize(const safe_VkSemaphoreGetFdInfoKHR pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR( - const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), maxPushDescriptors(in_struct->maxPushDescriptors) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR), pNext(nullptr), maxPushDescriptors() {} - -safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR( - const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src) { - sType = copy_src.sType; - maxPushDescriptors = copy_src.maxPushDescriptors; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkPhysicalDevicePushDescriptorPropertiesKHR& safe_VkPhysicalDevicePushDescriptorPropertiesKHR::operator=( - const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - maxPushDescriptors = copy_src.maxPushDescriptors; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkPhysicalDevicePushDescriptorPropertiesKHR::~safe_VkPhysicalDevicePushDescriptorPropertiesKHR() { FreePnextChain(pNext); } - -void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - maxPushDescriptors = in_struct->maxPushDescriptors; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - maxPushDescriptors = copy_src->maxPushDescriptors; - pNext = SafePnextCopy(copy_src->pNext); -} - safe_VkPresentRegionKHR::safe_VkPresentRegionKHR(const VkPresentRegionKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) : rectangleCount(in_struct->rectangleCount), pRectangles(nullptr) { if (in_struct->pRectangles) { @@ -8570,171 +8522,6 @@ void safe_VkVideoDecodeH265DpbSlotInfoKHR::initialize(const safe_VkVideoDecodeH2 } } -safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::safe_VkDeviceQueueGlobalPriorityCreateInfoKHR( - const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), globalPriority(in_struct->globalPriority) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::safe_VkDeviceQueueGlobalPriorityCreateInfoKHR() - : sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR), pNext(nullptr), globalPriority() {} - -safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::safe_VkDeviceQueueGlobalPriorityCreateInfoKHR( - const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& copy_src) { - sType = copy_src.sType; - globalPriority = copy_src.globalPriority; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::operator=( - const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - globalPriority = copy_src.globalPriority; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::~safe_VkDeviceQueueGlobalPriorityCreateInfoKHR() { FreePnextChain(pNext); } - -void safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::initialize(const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - globalPriority = in_struct->globalPriority; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::initialize(const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - globalPriority = copy_src->globalPriority; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR( - const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), globalPriorityQuery(in_struct->globalPriorityQuery) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR), pNext(nullptr), globalPriorityQuery() {} - -safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR( - const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src) { - sType = copy_src.sType; - globalPriorityQuery = copy_src.globalPriorityQuery; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::operator=( - const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - globalPriorityQuery = copy_src.globalPriorityQuery; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::~safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR() { - FreePnextChain(pNext); -} - -void safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::initialize( - const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - globalPriorityQuery = in_struct->globalPriorityQuery; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::initialize( - const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - globalPriorityQuery = copy_src->globalPriorityQuery; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkQueueFamilyGlobalPriorityPropertiesKHR::safe_VkQueueFamilyGlobalPriorityPropertiesKHR( - const VkQueueFamilyGlobalPriorityPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), priorityCount(in_struct->priorityCount) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } - for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i) { - priorities[i] = in_struct->priorities[i]; - } -} - -safe_VkQueueFamilyGlobalPriorityPropertiesKHR::safe_VkQueueFamilyGlobalPriorityPropertiesKHR() - : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR), pNext(nullptr), priorityCount() {} - -safe_VkQueueFamilyGlobalPriorityPropertiesKHR::safe_VkQueueFamilyGlobalPriorityPropertiesKHR( - const safe_VkQueueFamilyGlobalPriorityPropertiesKHR& copy_src) { - sType = copy_src.sType; - priorityCount = copy_src.priorityCount; - pNext = SafePnextCopy(copy_src.pNext); - - for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i) { - priorities[i] = copy_src.priorities[i]; - } -} - -safe_VkQueueFamilyGlobalPriorityPropertiesKHR& safe_VkQueueFamilyGlobalPriorityPropertiesKHR::operator=( - const safe_VkQueueFamilyGlobalPriorityPropertiesKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - priorityCount = copy_src.priorityCount; - pNext = SafePnextCopy(copy_src.pNext); - - for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i) { - priorities[i] = copy_src.priorities[i]; - } - - return *this; -} - -safe_VkQueueFamilyGlobalPriorityPropertiesKHR::~safe_VkQueueFamilyGlobalPriorityPropertiesKHR() { FreePnextChain(pNext); } - -void safe_VkQueueFamilyGlobalPriorityPropertiesKHR::initialize(const VkQueueFamilyGlobalPriorityPropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - priorityCount = in_struct->priorityCount; - pNext = SafePnextCopy(in_struct->pNext, copy_state); - - for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i) { - priorities[i] = in_struct->priorities[i]; - } -} - -void safe_VkQueueFamilyGlobalPriorityPropertiesKHR::initialize(const safe_VkQueueFamilyGlobalPriorityPropertiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - priorityCount = copy_src->priorityCount; - pNext = SafePnextCopy(copy_src->pNext); - - for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i) { - priorities[i] = copy_src->priorities[i]; - } -} - safe_VkFragmentShadingRateAttachmentInfoKHR::safe_VkFragmentShadingRateAttachmentInfoKHR( const VkFragmentShadingRateAttachmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), @@ -9207,455 +8994,164 @@ void safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::initialize( pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR( - const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), dynamicRenderingLocalRead(in_struct->dynamicRenderingLocalRead) { +safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR( + const VkPhysicalDeviceShaderQuadControlFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), shaderQuadControl(in_struct->shaderQuadControl) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR), - pNext(nullptr), - dynamicRenderingLocalRead() {} +safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR), pNext(nullptr), shaderQuadControl() {} -safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR( - const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src) { +safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR( + const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& copy_src) { sType = copy_src.sType; - dynamicRenderingLocalRead = copy_src.dynamicRenderingLocalRead; + shaderQuadControl = copy_src.shaderQuadControl; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::operator=( - const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src) { +safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::operator=( + const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - dynamicRenderingLocalRead = copy_src.dynamicRenderingLocalRead; + shaderQuadControl = copy_src.shaderQuadControl; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::~safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR() { - FreePnextChain(pNext); -} +safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::~safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::initialize( - const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::initialize(const VkPhysicalDeviceShaderQuadControlFeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - dynamicRenderingLocalRead = in_struct->dynamicRenderingLocalRead; + shaderQuadControl = in_struct->shaderQuadControl; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::initialize( - const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::initialize( + const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - dynamicRenderingLocalRead = copy_src->dynamicRenderingLocalRead; + shaderQuadControl = copy_src->shaderQuadControl; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkRenderingAttachmentLocationInfoKHR::safe_VkRenderingAttachmentLocationInfoKHR( - const VkRenderingAttachmentLocationInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), colorAttachmentCount(in_struct->colorAttachmentCount), pColorAttachmentLocations(nullptr) { +safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), supportsProtected(in_struct->supportsProtected) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pColorAttachmentLocations) { - pColorAttachmentLocations = new uint32_t[in_struct->colorAttachmentCount]; - memcpy((void*)pColorAttachmentLocations, (void*)in_struct->pColorAttachmentLocations, - sizeof(uint32_t) * in_struct->colorAttachmentCount); - } } -safe_VkRenderingAttachmentLocationInfoKHR::safe_VkRenderingAttachmentLocationInfoKHR() - : sType(VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR), - pNext(nullptr), - colorAttachmentCount(), - pColorAttachmentLocations(nullptr) {} +safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR() + : sType(VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR), pNext(nullptr), supportsProtected() {} -safe_VkRenderingAttachmentLocationInfoKHR::safe_VkRenderingAttachmentLocationInfoKHR( - const safe_VkRenderingAttachmentLocationInfoKHR& copy_src) { +safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR( + const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src) { sType = copy_src.sType; - colorAttachmentCount = copy_src.colorAttachmentCount; - pColorAttachmentLocations = nullptr; + supportsProtected = copy_src.supportsProtected; pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pColorAttachmentLocations) { - pColorAttachmentLocations = new uint32_t[copy_src.colorAttachmentCount]; - memcpy((void*)pColorAttachmentLocations, (void*)copy_src.pColorAttachmentLocations, - sizeof(uint32_t) * copy_src.colorAttachmentCount); - } } -safe_VkRenderingAttachmentLocationInfoKHR& safe_VkRenderingAttachmentLocationInfoKHR::operator=( - const safe_VkRenderingAttachmentLocationInfoKHR& copy_src) { +safe_VkSurfaceProtectedCapabilitiesKHR& safe_VkSurfaceProtectedCapabilitiesKHR::operator=( + const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src) { if (©_src == this) return *this; - if (pColorAttachmentLocations) delete[] pColorAttachmentLocations; FreePnextChain(pNext); sType = copy_src.sType; - colorAttachmentCount = copy_src.colorAttachmentCount; - pColorAttachmentLocations = nullptr; + supportsProtected = copy_src.supportsProtected; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pColorAttachmentLocations) { - pColorAttachmentLocations = new uint32_t[copy_src.colorAttachmentCount]; - memcpy((void*)pColorAttachmentLocations, (void*)copy_src.pColorAttachmentLocations, - sizeof(uint32_t) * copy_src.colorAttachmentCount); - } - return *this; } -safe_VkRenderingAttachmentLocationInfoKHR::~safe_VkRenderingAttachmentLocationInfoKHR() { - if (pColorAttachmentLocations) delete[] pColorAttachmentLocations; - FreePnextChain(pNext); -} +safe_VkSurfaceProtectedCapabilitiesKHR::~safe_VkSurfaceProtectedCapabilitiesKHR() { FreePnextChain(pNext); } -void safe_VkRenderingAttachmentLocationInfoKHR::initialize(const VkRenderingAttachmentLocationInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pColorAttachmentLocations) delete[] pColorAttachmentLocations; +void safe_VkSurfaceProtectedCapabilitiesKHR::initialize(const VkSurfaceProtectedCapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - colorAttachmentCount = in_struct->colorAttachmentCount; - pColorAttachmentLocations = nullptr; + supportsProtected = in_struct->supportsProtected; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pColorAttachmentLocations) { - pColorAttachmentLocations = new uint32_t[in_struct->colorAttachmentCount]; - memcpy((void*)pColorAttachmentLocations, (void*)in_struct->pColorAttachmentLocations, - sizeof(uint32_t) * in_struct->colorAttachmentCount); - } } -void safe_VkRenderingAttachmentLocationInfoKHR::initialize(const safe_VkRenderingAttachmentLocationInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkSurfaceProtectedCapabilitiesKHR::initialize(const safe_VkSurfaceProtectedCapabilitiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - colorAttachmentCount = copy_src->colorAttachmentCount; - pColorAttachmentLocations = nullptr; + supportsProtected = copy_src->supportsProtected; pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pColorAttachmentLocations) { - pColorAttachmentLocations = new uint32_t[copy_src->colorAttachmentCount]; - memcpy((void*)pColorAttachmentLocations, (void*)copy_src->pColorAttachmentLocations, - sizeof(uint32_t) * copy_src->colorAttachmentCount); - } } -safe_VkRenderingInputAttachmentIndexInfoKHR::safe_VkRenderingInputAttachmentIndexInfoKHR( - const VkRenderingInputAttachmentIndexInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - colorAttachmentCount(in_struct->colorAttachmentCount), - pColorAttachmentInputIndices(nullptr), - pDepthInputAttachmentIndex(nullptr), - pStencilInputAttachmentIndex(nullptr) { +safe_VkPhysicalDevicePresentWaitFeaturesKHR::safe_VkPhysicalDevicePresentWaitFeaturesKHR( + const VkPhysicalDevicePresentWaitFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), presentWait(in_struct->presentWait) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pColorAttachmentInputIndices) { - pColorAttachmentInputIndices = new uint32_t[in_struct->colorAttachmentCount]; - memcpy((void*)pColorAttachmentInputIndices, (void*)in_struct->pColorAttachmentInputIndices, - sizeof(uint32_t) * in_struct->colorAttachmentCount); - } - - if (in_struct->pDepthInputAttachmentIndex) { - pDepthInputAttachmentIndex = new uint32_t(*in_struct->pDepthInputAttachmentIndex); - } - - if (in_struct->pStencilInputAttachmentIndex) { - pStencilInputAttachmentIndex = new uint32_t(*in_struct->pStencilInputAttachmentIndex); - } } -safe_VkRenderingInputAttachmentIndexInfoKHR::safe_VkRenderingInputAttachmentIndexInfoKHR() - : sType(VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR), - pNext(nullptr), - colorAttachmentCount(), - pColorAttachmentInputIndices(nullptr), - pDepthInputAttachmentIndex(nullptr), - pStencilInputAttachmentIndex(nullptr) {} +safe_VkPhysicalDevicePresentWaitFeaturesKHR::safe_VkPhysicalDevicePresentWaitFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR), pNext(nullptr), presentWait() {} -safe_VkRenderingInputAttachmentIndexInfoKHR::safe_VkRenderingInputAttachmentIndexInfoKHR( - const safe_VkRenderingInputAttachmentIndexInfoKHR& copy_src) { +safe_VkPhysicalDevicePresentWaitFeaturesKHR::safe_VkPhysicalDevicePresentWaitFeaturesKHR( + const safe_VkPhysicalDevicePresentWaitFeaturesKHR& copy_src) { sType = copy_src.sType; - colorAttachmentCount = copy_src.colorAttachmentCount; - pColorAttachmentInputIndices = nullptr; - pDepthInputAttachmentIndex = nullptr; - pStencilInputAttachmentIndex = nullptr; + presentWait = copy_src.presentWait; pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pColorAttachmentInputIndices) { - pColorAttachmentInputIndices = new uint32_t[copy_src.colorAttachmentCount]; - memcpy((void*)pColorAttachmentInputIndices, (void*)copy_src.pColorAttachmentInputIndices, - sizeof(uint32_t) * copy_src.colorAttachmentCount); - } - - if (copy_src.pDepthInputAttachmentIndex) { - pDepthInputAttachmentIndex = new uint32_t(*copy_src.pDepthInputAttachmentIndex); - } - - if (copy_src.pStencilInputAttachmentIndex) { - pStencilInputAttachmentIndex = new uint32_t(*copy_src.pStencilInputAttachmentIndex); - } } -safe_VkRenderingInputAttachmentIndexInfoKHR& safe_VkRenderingInputAttachmentIndexInfoKHR::operator=( - const safe_VkRenderingInputAttachmentIndexInfoKHR& copy_src) { +safe_VkPhysicalDevicePresentWaitFeaturesKHR& safe_VkPhysicalDevicePresentWaitFeaturesKHR::operator=( + const safe_VkPhysicalDevicePresentWaitFeaturesKHR& copy_src) { if (©_src == this) return *this; - if (pColorAttachmentInputIndices) delete[] pColorAttachmentInputIndices; - if (pDepthInputAttachmentIndex) delete pDepthInputAttachmentIndex; - if (pStencilInputAttachmentIndex) delete pStencilInputAttachmentIndex; FreePnextChain(pNext); sType = copy_src.sType; - colorAttachmentCount = copy_src.colorAttachmentCount; - pColorAttachmentInputIndices = nullptr; - pDepthInputAttachmentIndex = nullptr; - pStencilInputAttachmentIndex = nullptr; + presentWait = copy_src.presentWait; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pColorAttachmentInputIndices) { - pColorAttachmentInputIndices = new uint32_t[copy_src.colorAttachmentCount]; - memcpy((void*)pColorAttachmentInputIndices, (void*)copy_src.pColorAttachmentInputIndices, - sizeof(uint32_t) * copy_src.colorAttachmentCount); - } - - if (copy_src.pDepthInputAttachmentIndex) { - pDepthInputAttachmentIndex = new uint32_t(*copy_src.pDepthInputAttachmentIndex); - } - - if (copy_src.pStencilInputAttachmentIndex) { - pStencilInputAttachmentIndex = new uint32_t(*copy_src.pStencilInputAttachmentIndex); - } - return *this; } -safe_VkRenderingInputAttachmentIndexInfoKHR::~safe_VkRenderingInputAttachmentIndexInfoKHR() { - if (pColorAttachmentInputIndices) delete[] pColorAttachmentInputIndices; - if (pDepthInputAttachmentIndex) delete pDepthInputAttachmentIndex; - if (pStencilInputAttachmentIndex) delete pStencilInputAttachmentIndex; - FreePnextChain(pNext); -} +safe_VkPhysicalDevicePresentWaitFeaturesKHR::~safe_VkPhysicalDevicePresentWaitFeaturesKHR() { FreePnextChain(pNext); } -void safe_VkRenderingInputAttachmentIndexInfoKHR::initialize(const VkRenderingInputAttachmentIndexInfoKHR* in_struct, +void safe_VkPhysicalDevicePresentWaitFeaturesKHR::initialize(const VkPhysicalDevicePresentWaitFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - if (pColorAttachmentInputIndices) delete[] pColorAttachmentInputIndices; - if (pDepthInputAttachmentIndex) delete pDepthInputAttachmentIndex; - if (pStencilInputAttachmentIndex) delete pStencilInputAttachmentIndex; FreePnextChain(pNext); sType = in_struct->sType; - colorAttachmentCount = in_struct->colorAttachmentCount; - pColorAttachmentInputIndices = nullptr; - pDepthInputAttachmentIndex = nullptr; - pStencilInputAttachmentIndex = nullptr; + presentWait = in_struct->presentWait; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pColorAttachmentInputIndices) { - pColorAttachmentInputIndices = new uint32_t[in_struct->colorAttachmentCount]; - memcpy((void*)pColorAttachmentInputIndices, (void*)in_struct->pColorAttachmentInputIndices, - sizeof(uint32_t) * in_struct->colorAttachmentCount); - } - - if (in_struct->pDepthInputAttachmentIndex) { - pDepthInputAttachmentIndex = new uint32_t(*in_struct->pDepthInputAttachmentIndex); - } - - if (in_struct->pStencilInputAttachmentIndex) { - pStencilInputAttachmentIndex = new uint32_t(*in_struct->pStencilInputAttachmentIndex); - } } -void safe_VkRenderingInputAttachmentIndexInfoKHR::initialize(const safe_VkRenderingInputAttachmentIndexInfoKHR* copy_src, +void safe_VkPhysicalDevicePresentWaitFeaturesKHR::initialize(const safe_VkPhysicalDevicePresentWaitFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - colorAttachmentCount = copy_src->colorAttachmentCount; - pColorAttachmentInputIndices = nullptr; - pDepthInputAttachmentIndex = nullptr; - pStencilInputAttachmentIndex = nullptr; + presentWait = copy_src->presentWait; pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pColorAttachmentInputIndices) { - pColorAttachmentInputIndices = new uint32_t[copy_src->colorAttachmentCount]; - memcpy((void*)pColorAttachmentInputIndices, (void*)copy_src->pColorAttachmentInputIndices, - sizeof(uint32_t) * copy_src->colorAttachmentCount); - } - - if (copy_src->pDepthInputAttachmentIndex) { - pDepthInputAttachmentIndex = new uint32_t(*copy_src->pDepthInputAttachmentIndex); - } - - if (copy_src->pStencilInputAttachmentIndex) { - pStencilInputAttachmentIndex = new uint32_t(*copy_src->pStencilInputAttachmentIndex); - } } -safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR( - const VkPhysicalDeviceShaderQuadControlFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), shaderQuadControl(in_struct->shaderQuadControl) { +safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR( + const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), pipelineExecutableInfo(in_struct->pipelineExecutableInfo) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR), pNext(nullptr), shaderQuadControl() {} - -safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR( - const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& copy_src) { - sType = copy_src.sType; - shaderQuadControl = copy_src.shaderQuadControl; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::operator=( - const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - shaderQuadControl = copy_src.shaderQuadControl; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::~safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR() { FreePnextChain(pNext); } - -void safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::initialize(const VkPhysicalDeviceShaderQuadControlFeaturesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - shaderQuadControl = in_struct->shaderQuadControl; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::initialize( - const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - shaderQuadControl = copy_src->shaderQuadControl; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), supportsProtected(in_struct->supportsProtected) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR() - : sType(VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR), pNext(nullptr), supportsProtected() {} - -safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR( - const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src) { - sType = copy_src.sType; - supportsProtected = copy_src.supportsProtected; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkSurfaceProtectedCapabilitiesKHR& safe_VkSurfaceProtectedCapabilitiesKHR::operator=( - const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - supportsProtected = copy_src.supportsProtected; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkSurfaceProtectedCapabilitiesKHR::~safe_VkSurfaceProtectedCapabilitiesKHR() { FreePnextChain(pNext); } - -void safe_VkSurfaceProtectedCapabilitiesKHR::initialize(const VkSurfaceProtectedCapabilitiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - supportsProtected = in_struct->supportsProtected; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkSurfaceProtectedCapabilitiesKHR::initialize(const safe_VkSurfaceProtectedCapabilitiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - supportsProtected = copy_src->supportsProtected; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkPhysicalDevicePresentWaitFeaturesKHR::safe_VkPhysicalDevicePresentWaitFeaturesKHR( - const VkPhysicalDevicePresentWaitFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), presentWait(in_struct->presentWait) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkPhysicalDevicePresentWaitFeaturesKHR::safe_VkPhysicalDevicePresentWaitFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR), pNext(nullptr), presentWait() {} - -safe_VkPhysicalDevicePresentWaitFeaturesKHR::safe_VkPhysicalDevicePresentWaitFeaturesKHR( - const safe_VkPhysicalDevicePresentWaitFeaturesKHR& copy_src) { - sType = copy_src.sType; - presentWait = copy_src.presentWait; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkPhysicalDevicePresentWaitFeaturesKHR& safe_VkPhysicalDevicePresentWaitFeaturesKHR::operator=( - const safe_VkPhysicalDevicePresentWaitFeaturesKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - presentWait = copy_src.presentWait; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkPhysicalDevicePresentWaitFeaturesKHR::~safe_VkPhysicalDevicePresentWaitFeaturesKHR() { FreePnextChain(pNext); } - -void safe_VkPhysicalDevicePresentWaitFeaturesKHR::initialize(const VkPhysicalDevicePresentWaitFeaturesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - presentWait = in_struct->presentWait; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPhysicalDevicePresentWaitFeaturesKHR::initialize(const safe_VkPhysicalDevicePresentWaitFeaturesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - presentWait = copy_src->presentWait; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR( - const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), pipelineExecutableInfo(in_struct->pipelineExecutableInfo) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR), - pNext(nullptr), - pipelineExecutableInfo() {} +safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR), + pNext(nullptr), + pipelineExecutableInfo() {} safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR( const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src) { @@ -10113,114 +9609,6 @@ void safe_VkPipelineExecutableInternalRepresentationKHR::initialize( } } -safe_VkMemoryMapInfoKHR::safe_VkMemoryMapInfoKHR(const VkMemoryMapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), - flags(in_struct->flags), - memory(in_struct->memory), - offset(in_struct->offset), - size(in_struct->size) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkMemoryMapInfoKHR::safe_VkMemoryMapInfoKHR() - : sType(VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR), pNext(nullptr), flags(), memory(), offset(), size() {} - -safe_VkMemoryMapInfoKHR::safe_VkMemoryMapInfoKHR(const safe_VkMemoryMapInfoKHR& copy_src) { - sType = copy_src.sType; - flags = copy_src.flags; - memory = copy_src.memory; - offset = copy_src.offset; - size = copy_src.size; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkMemoryMapInfoKHR& safe_VkMemoryMapInfoKHR::operator=(const safe_VkMemoryMapInfoKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - flags = copy_src.flags; - memory = copy_src.memory; - offset = copy_src.offset; - size = copy_src.size; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkMemoryMapInfoKHR::~safe_VkMemoryMapInfoKHR() { FreePnextChain(pNext); } - -void safe_VkMemoryMapInfoKHR::initialize(const VkMemoryMapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - flags = in_struct->flags; - memory = in_struct->memory; - offset = in_struct->offset; - size = in_struct->size; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkMemoryMapInfoKHR::initialize(const safe_VkMemoryMapInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - flags = copy_src->flags; - memory = copy_src->memory; - offset = copy_src->offset; - size = copy_src->size; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkMemoryUnmapInfoKHR::safe_VkMemoryUnmapInfoKHR(const VkMemoryUnmapInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), flags(in_struct->flags), memory(in_struct->memory) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkMemoryUnmapInfoKHR::safe_VkMemoryUnmapInfoKHR() - : sType(VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR), pNext(nullptr), flags(), memory() {} - -safe_VkMemoryUnmapInfoKHR::safe_VkMemoryUnmapInfoKHR(const safe_VkMemoryUnmapInfoKHR& copy_src) { - sType = copy_src.sType; - flags = copy_src.flags; - memory = copy_src.memory; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkMemoryUnmapInfoKHR& safe_VkMemoryUnmapInfoKHR::operator=(const safe_VkMemoryUnmapInfoKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - flags = copy_src.flags; - memory = copy_src.memory; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkMemoryUnmapInfoKHR::~safe_VkMemoryUnmapInfoKHR() { FreePnextChain(pNext); } - -void safe_VkMemoryUnmapInfoKHR::initialize(const VkMemoryUnmapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - flags = in_struct->flags; - memory = in_struct->memory; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkMemoryUnmapInfoKHR::initialize(const safe_VkMemoryUnmapInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - flags = copy_src->flags; - memory = copy_src->memory; - pNext = SafePnextCopy(copy_src->pNext); -} - safe_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) @@ -11507,4541 +10895,2847 @@ void safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::initialize( pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR( - const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - shaderSubgroupRotate(in_struct->shaderSubgroupRotate), - shaderSubgroupRotateClustered(in_struct->shaderSubgroupRotateClustered) { +safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( + const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), shaderMaximalReconvergence(in_struct->shaderMaximalReconvergence) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR), +safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR), pNext(nullptr), - shaderSubgroupRotate(), - shaderSubgroupRotateClustered() {} + shaderMaximalReconvergence() {} -safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR( - const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src) { +safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( + const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& copy_src) { sType = copy_src.sType; - shaderSubgroupRotate = copy_src.shaderSubgroupRotate; - shaderSubgroupRotateClustered = copy_src.shaderSubgroupRotateClustered; + shaderMaximalReconvergence = copy_src.shaderMaximalReconvergence; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::operator=( - const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src) { +safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::operator=( + const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - shaderSubgroupRotate = copy_src.shaderSubgroupRotate; - shaderSubgroupRotateClustered = copy_src.shaderSubgroupRotateClustered; + shaderMaximalReconvergence = copy_src.shaderMaximalReconvergence; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::~safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR() { +safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::~safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::initialize( - const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::initialize( + const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - shaderSubgroupRotate = in_struct->shaderSubgroupRotate; - shaderSubgroupRotateClustered = in_struct->shaderSubgroupRotateClustered; + shaderMaximalReconvergence = in_struct->shaderMaximalReconvergence; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::initialize( - const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::initialize( + const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - shaderSubgroupRotate = copy_src->shaderSubgroupRotate; - shaderSubgroupRotateClustered = copy_src->shaderSubgroupRotateClustered; + shaderMaximalReconvergence = copy_src->shaderMaximalReconvergence; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( - const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, +safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR( + const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), shaderMaximalReconvergence(in_struct->shaderMaximalReconvergence) { + : sType(in_struct->sType), rayTracingPositionFetch(in_struct->rayTracingPositionFetch) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR), - pNext(nullptr), - shaderMaximalReconvergence() {} +safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR), pNext(nullptr), rayTracingPositionFetch() {} -safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( - const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& copy_src) { +safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR( + const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src) { sType = copy_src.sType; - shaderMaximalReconvergence = copy_src.shaderMaximalReconvergence; + rayTracingPositionFetch = copy_src.rayTracingPositionFetch; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::operator=( - const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& copy_src) { +safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::operator=( + const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - shaderMaximalReconvergence = copy_src.shaderMaximalReconvergence; + rayTracingPositionFetch = copy_src.rayTracingPositionFetch; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::~safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR() { +safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::~safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::initialize( - const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::initialize( + const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - shaderMaximalReconvergence = in_struct->shaderMaximalReconvergence; + rayTracingPositionFetch = in_struct->rayTracingPositionFetch; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::initialize( - const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::initialize( + const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - shaderMaximalReconvergence = copy_src->shaderMaximalReconvergence; + rayTracingPositionFetch = copy_src->rayTracingPositionFetch; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDeviceMaintenance5FeaturesKHR::safe_VkPhysicalDeviceMaintenance5FeaturesKHR( - const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), maintenance5(in_struct->maintenance5) { +safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::safe_VkPhysicalDevicePipelineBinaryFeaturesKHR( + const VkPhysicalDevicePipelineBinaryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pipelineBinaries(in_struct->pipelineBinaries) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDeviceMaintenance5FeaturesKHR::safe_VkPhysicalDeviceMaintenance5FeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR), pNext(nullptr), maintenance5() {} +safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::safe_VkPhysicalDevicePipelineBinaryFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR), pNext(nullptr), pipelineBinaries() {} -safe_VkPhysicalDeviceMaintenance5FeaturesKHR::safe_VkPhysicalDeviceMaintenance5FeaturesKHR( - const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src) { +safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::safe_VkPhysicalDevicePipelineBinaryFeaturesKHR( + const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& copy_src) { sType = copy_src.sType; - maintenance5 = copy_src.maintenance5; + pipelineBinaries = copy_src.pipelineBinaries; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceMaintenance5FeaturesKHR& safe_VkPhysicalDeviceMaintenance5FeaturesKHR::operator=( - const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src) { +safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::operator=( + const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - maintenance5 = copy_src.maintenance5; + pipelineBinaries = copy_src.pipelineBinaries; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceMaintenance5FeaturesKHR::~safe_VkPhysicalDeviceMaintenance5FeaturesKHR() { FreePnextChain(pNext); } +safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::~safe_VkPhysicalDevicePipelineBinaryFeaturesKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceMaintenance5FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::initialize(const VkPhysicalDevicePipelineBinaryFeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - maintenance5 = in_struct->maintenance5; + pipelineBinaries = in_struct->pipelineBinaries; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceMaintenance5FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance5FeaturesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::initialize(const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - maintenance5 = copy_src->maintenance5; + pipelineBinaries = copy_src->pipelineBinaries; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDeviceMaintenance5PropertiesKHR::safe_VkPhysicalDeviceMaintenance5PropertiesKHR( - const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::safe_VkPhysicalDevicePipelineBinaryPropertiesKHR( + const VkPhysicalDevicePipelineBinaryPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), - earlyFragmentMultisampleCoverageAfterSampleCounting(in_struct->earlyFragmentMultisampleCoverageAfterSampleCounting), - earlyFragmentSampleMaskTestBeforeSampleCounting(in_struct->earlyFragmentSampleMaskTestBeforeSampleCounting), - depthStencilSwizzleOneSupport(in_struct->depthStencilSwizzleOneSupport), - polygonModePointSize(in_struct->polygonModePointSize), - nonStrictSinglePixelWideLinesUseParallelogram(in_struct->nonStrictSinglePixelWideLinesUseParallelogram), - nonStrictWideLinesUseParallelogram(in_struct->nonStrictWideLinesUseParallelogram) { + pipelineBinaryInternalCache(in_struct->pipelineBinaryInternalCache), + pipelineBinaryInternalCacheControl(in_struct->pipelineBinaryInternalCacheControl), + pipelineBinaryPrefersInternalCache(in_struct->pipelineBinaryPrefersInternalCache), + pipelineBinaryPrecompiledInternalCache(in_struct->pipelineBinaryPrecompiledInternalCache), + pipelineBinaryCompressedData(in_struct->pipelineBinaryCompressedData) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDeviceMaintenance5PropertiesKHR::safe_VkPhysicalDeviceMaintenance5PropertiesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR), +safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::safe_VkPhysicalDevicePipelineBinaryPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR), pNext(nullptr), - earlyFragmentMultisampleCoverageAfterSampleCounting(), - earlyFragmentSampleMaskTestBeforeSampleCounting(), - depthStencilSwizzleOneSupport(), - polygonModePointSize(), - nonStrictSinglePixelWideLinesUseParallelogram(), - nonStrictWideLinesUseParallelogram() {} + pipelineBinaryInternalCache(), + pipelineBinaryInternalCacheControl(), + pipelineBinaryPrefersInternalCache(), + pipelineBinaryPrecompiledInternalCache(), + pipelineBinaryCompressedData() {} -safe_VkPhysicalDeviceMaintenance5PropertiesKHR::safe_VkPhysicalDeviceMaintenance5PropertiesKHR( - const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src) { +safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::safe_VkPhysicalDevicePipelineBinaryPropertiesKHR( + const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& copy_src) { sType = copy_src.sType; - earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src.earlyFragmentMultisampleCoverageAfterSampleCounting; - earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src.earlyFragmentSampleMaskTestBeforeSampleCounting; - depthStencilSwizzleOneSupport = copy_src.depthStencilSwizzleOneSupport; - polygonModePointSize = copy_src.polygonModePointSize; - nonStrictSinglePixelWideLinesUseParallelogram = copy_src.nonStrictSinglePixelWideLinesUseParallelogram; - nonStrictWideLinesUseParallelogram = copy_src.nonStrictWideLinesUseParallelogram; + pipelineBinaryInternalCache = copy_src.pipelineBinaryInternalCache; + pipelineBinaryInternalCacheControl = copy_src.pipelineBinaryInternalCacheControl; + pipelineBinaryPrefersInternalCache = copy_src.pipelineBinaryPrefersInternalCache; + pipelineBinaryPrecompiledInternalCache = copy_src.pipelineBinaryPrecompiledInternalCache; + pipelineBinaryCompressedData = copy_src.pipelineBinaryCompressedData; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceMaintenance5PropertiesKHR& safe_VkPhysicalDeviceMaintenance5PropertiesKHR::operator=( - const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src) { +safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::operator=( + const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src.earlyFragmentMultisampleCoverageAfterSampleCounting; - earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src.earlyFragmentSampleMaskTestBeforeSampleCounting; - depthStencilSwizzleOneSupport = copy_src.depthStencilSwizzleOneSupport; - polygonModePointSize = copy_src.polygonModePointSize; - nonStrictSinglePixelWideLinesUseParallelogram = copy_src.nonStrictSinglePixelWideLinesUseParallelogram; - nonStrictWideLinesUseParallelogram = copy_src.nonStrictWideLinesUseParallelogram; + pipelineBinaryInternalCache = copy_src.pipelineBinaryInternalCache; + pipelineBinaryInternalCacheControl = copy_src.pipelineBinaryInternalCacheControl; + pipelineBinaryPrefersInternalCache = copy_src.pipelineBinaryPrefersInternalCache; + pipelineBinaryPrecompiledInternalCache = copy_src.pipelineBinaryPrecompiledInternalCache; + pipelineBinaryCompressedData = copy_src.pipelineBinaryCompressedData; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceMaintenance5PropertiesKHR::~safe_VkPhysicalDeviceMaintenance5PropertiesKHR() { FreePnextChain(pNext); } +safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::~safe_VkPhysicalDevicePipelineBinaryPropertiesKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceMaintenance5PropertiesKHR::initialize(const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::initialize(const VkPhysicalDevicePipelineBinaryPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - earlyFragmentMultisampleCoverageAfterSampleCounting = in_struct->earlyFragmentMultisampleCoverageAfterSampleCounting; - earlyFragmentSampleMaskTestBeforeSampleCounting = in_struct->earlyFragmentSampleMaskTestBeforeSampleCounting; - depthStencilSwizzleOneSupport = in_struct->depthStencilSwizzleOneSupport; - polygonModePointSize = in_struct->polygonModePointSize; - nonStrictSinglePixelWideLinesUseParallelogram = in_struct->nonStrictSinglePixelWideLinesUseParallelogram; - nonStrictWideLinesUseParallelogram = in_struct->nonStrictWideLinesUseParallelogram; + pipelineBinaryInternalCache = in_struct->pipelineBinaryInternalCache; + pipelineBinaryInternalCacheControl = in_struct->pipelineBinaryInternalCacheControl; + pipelineBinaryPrefersInternalCache = in_struct->pipelineBinaryPrefersInternalCache; + pipelineBinaryPrecompiledInternalCache = in_struct->pipelineBinaryPrecompiledInternalCache; + pipelineBinaryCompressedData = in_struct->pipelineBinaryCompressedData; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceMaintenance5PropertiesKHR::initialize(const safe_VkPhysicalDeviceMaintenance5PropertiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::initialize(const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src->earlyFragmentMultisampleCoverageAfterSampleCounting; - earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src->earlyFragmentSampleMaskTestBeforeSampleCounting; - depthStencilSwizzleOneSupport = copy_src->depthStencilSwizzleOneSupport; - polygonModePointSize = copy_src->polygonModePointSize; - nonStrictSinglePixelWideLinesUseParallelogram = copy_src->nonStrictSinglePixelWideLinesUseParallelogram; - nonStrictWideLinesUseParallelogram = copy_src->nonStrictWideLinesUseParallelogram; + pipelineBinaryInternalCache = copy_src->pipelineBinaryInternalCache; + pipelineBinaryInternalCacheControl = copy_src->pipelineBinaryInternalCacheControl; + pipelineBinaryPrefersInternalCache = copy_src->pipelineBinaryPrefersInternalCache; + pipelineBinaryPrecompiledInternalCache = copy_src->pipelineBinaryPrecompiledInternalCache; + pipelineBinaryCompressedData = copy_src->pipelineBinaryCompressedData; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkRenderingAreaInfoKHR::safe_VkRenderingAreaInfoKHR(const VkRenderingAreaInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - viewMask(in_struct->viewMask), - colorAttachmentCount(in_struct->colorAttachmentCount), - pColorAttachmentFormats(nullptr), - depthAttachmentFormat(in_struct->depthAttachmentFormat), - stencilAttachmentFormat(in_struct->stencilAttachmentFormat) { +safe_VkDevicePipelineBinaryInternalCacheControlKHR::safe_VkDevicePipelineBinaryInternalCacheControlKHR( + const VkDevicePipelineBinaryInternalCacheControlKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), disableInternalCache(in_struct->disableInternalCache) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pColorAttachmentFormats) { - pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount]; - memcpy((void*)pColorAttachmentFormats, (void*)in_struct->pColorAttachmentFormats, - sizeof(VkFormat) * in_struct->colorAttachmentCount); - } } -safe_VkRenderingAreaInfoKHR::safe_VkRenderingAreaInfoKHR() - : sType(VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR), - pNext(nullptr), - viewMask(), - colorAttachmentCount(), - pColorAttachmentFormats(nullptr), - depthAttachmentFormat(), - stencilAttachmentFormat() {} +safe_VkDevicePipelineBinaryInternalCacheControlKHR::safe_VkDevicePipelineBinaryInternalCacheControlKHR() + : sType(VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR), pNext(nullptr), disableInternalCache() {} -safe_VkRenderingAreaInfoKHR::safe_VkRenderingAreaInfoKHR(const safe_VkRenderingAreaInfoKHR& copy_src) { +safe_VkDevicePipelineBinaryInternalCacheControlKHR::safe_VkDevicePipelineBinaryInternalCacheControlKHR( + const safe_VkDevicePipelineBinaryInternalCacheControlKHR& copy_src) { sType = copy_src.sType; - viewMask = copy_src.viewMask; - colorAttachmentCount = copy_src.colorAttachmentCount; - pColorAttachmentFormats = nullptr; - depthAttachmentFormat = copy_src.depthAttachmentFormat; - stencilAttachmentFormat = copy_src.stencilAttachmentFormat; + disableInternalCache = copy_src.disableInternalCache; pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pColorAttachmentFormats) { - pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount]; - memcpy((void*)pColorAttachmentFormats, (void*)copy_src.pColorAttachmentFormats, - sizeof(VkFormat) * copy_src.colorAttachmentCount); - } } -safe_VkRenderingAreaInfoKHR& safe_VkRenderingAreaInfoKHR::operator=(const safe_VkRenderingAreaInfoKHR& copy_src) { +safe_VkDevicePipelineBinaryInternalCacheControlKHR& safe_VkDevicePipelineBinaryInternalCacheControlKHR::operator=( + const safe_VkDevicePipelineBinaryInternalCacheControlKHR& copy_src) { if (©_src == this) return *this; - if (pColorAttachmentFormats) delete[] pColorAttachmentFormats; FreePnextChain(pNext); sType = copy_src.sType; - viewMask = copy_src.viewMask; - colorAttachmentCount = copy_src.colorAttachmentCount; - pColorAttachmentFormats = nullptr; - depthAttachmentFormat = copy_src.depthAttachmentFormat; - stencilAttachmentFormat = copy_src.stencilAttachmentFormat; + disableInternalCache = copy_src.disableInternalCache; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pColorAttachmentFormats) { - pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount]; - memcpy((void*)pColorAttachmentFormats, (void*)copy_src.pColorAttachmentFormats, - sizeof(VkFormat) * copy_src.colorAttachmentCount); - } - return *this; } -safe_VkRenderingAreaInfoKHR::~safe_VkRenderingAreaInfoKHR() { - if (pColorAttachmentFormats) delete[] pColorAttachmentFormats; - FreePnextChain(pNext); -} +safe_VkDevicePipelineBinaryInternalCacheControlKHR::~safe_VkDevicePipelineBinaryInternalCacheControlKHR() { FreePnextChain(pNext); } -void safe_VkRenderingAreaInfoKHR::initialize(const VkRenderingAreaInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - if (pColorAttachmentFormats) delete[] pColorAttachmentFormats; +void safe_VkDevicePipelineBinaryInternalCacheControlKHR::initialize(const VkDevicePipelineBinaryInternalCacheControlKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - viewMask = in_struct->viewMask; - colorAttachmentCount = in_struct->colorAttachmentCount; - pColorAttachmentFormats = nullptr; - depthAttachmentFormat = in_struct->depthAttachmentFormat; - stencilAttachmentFormat = in_struct->stencilAttachmentFormat; + disableInternalCache = in_struct->disableInternalCache; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pColorAttachmentFormats) { - pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount]; - memcpy((void*)pColorAttachmentFormats, (void*)in_struct->pColorAttachmentFormats, - sizeof(VkFormat) * in_struct->colorAttachmentCount); - } } -void safe_VkRenderingAreaInfoKHR::initialize(const safe_VkRenderingAreaInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkDevicePipelineBinaryInternalCacheControlKHR::initialize( + const safe_VkDevicePipelineBinaryInternalCacheControlKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - viewMask = copy_src->viewMask; - colorAttachmentCount = copy_src->colorAttachmentCount; - pColorAttachmentFormats = nullptr; - depthAttachmentFormat = copy_src->depthAttachmentFormat; - stencilAttachmentFormat = copy_src->stencilAttachmentFormat; + disableInternalCache = copy_src->disableInternalCache; pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pColorAttachmentFormats) { - pColorAttachmentFormats = new VkFormat[copy_src->colorAttachmentCount]; - memcpy((void*)pColorAttachmentFormats, (void*)copy_src->pColorAttachmentFormats, - sizeof(VkFormat) * copy_src->colorAttachmentCount); - } } -safe_VkImageSubresource2KHR::safe_VkImageSubresource2KHR(const VkImageSubresource2KHR* in_struct, +safe_VkPipelineBinaryKeyKHR::safe_VkPipelineBinaryKeyKHR(const VkPipelineBinaryKeyKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), imageSubresource(in_struct->imageSubresource) { + : sType(in_struct->sType), keySize(in_struct->keySize) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) { + key[i] = in_struct->key[i]; + } } -safe_VkImageSubresource2KHR::safe_VkImageSubresource2KHR() - : sType(VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR), pNext(nullptr), imageSubresource() {} +safe_VkPipelineBinaryKeyKHR::safe_VkPipelineBinaryKeyKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR), pNext(nullptr), keySize() {} -safe_VkImageSubresource2KHR::safe_VkImageSubresource2KHR(const safe_VkImageSubresource2KHR& copy_src) { +safe_VkPipelineBinaryKeyKHR::safe_VkPipelineBinaryKeyKHR(const safe_VkPipelineBinaryKeyKHR& copy_src) { sType = copy_src.sType; - imageSubresource = copy_src.imageSubresource; + keySize = copy_src.keySize; pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) { + key[i] = copy_src.key[i]; + } } -safe_VkImageSubresource2KHR& safe_VkImageSubresource2KHR::operator=(const safe_VkImageSubresource2KHR& copy_src) { +safe_VkPipelineBinaryKeyKHR& safe_VkPipelineBinaryKeyKHR::operator=(const safe_VkPipelineBinaryKeyKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - imageSubresource = copy_src.imageSubresource; + keySize = copy_src.keySize; pNext = SafePnextCopy(copy_src.pNext); + for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) { + key[i] = copy_src.key[i]; + } + return *this; } -safe_VkImageSubresource2KHR::~safe_VkImageSubresource2KHR() { FreePnextChain(pNext); } +safe_VkPipelineBinaryKeyKHR::~safe_VkPipelineBinaryKeyKHR() { FreePnextChain(pNext); } -void safe_VkImageSubresource2KHR::initialize(const VkImageSubresource2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPipelineBinaryKeyKHR::initialize(const VkPipelineBinaryKeyKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - imageSubresource = in_struct->imageSubresource; + keySize = in_struct->keySize; pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) { + key[i] = in_struct->key[i]; + } } -void safe_VkImageSubresource2KHR::initialize(const safe_VkImageSubresource2KHR* copy_src, +void safe_VkPipelineBinaryKeyKHR::initialize(const safe_VkPipelineBinaryKeyKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - imageSubresource = copy_src->imageSubresource; + keySize = copy_src->keySize; pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) { + key[i] = copy_src->key[i]; + } } -safe_VkDeviceImageSubresourceInfoKHR::safe_VkDeviceImageSubresourceInfoKHR(const VkDeviceImageSubresourceInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), pCreateInfo(nullptr), pSubresource(nullptr) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); +safe_VkPipelineBinaryDataKHR::safe_VkPipelineBinaryDataKHR(const VkPipelineBinaryDataKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) + : dataSize(in_struct->dataSize), pData(nullptr) { + if (in_struct->pData != nullptr) { + auto temp = new std::byte[in_struct->dataSize]; + std::memcpy(temp, in_struct->pData, in_struct->dataSize); + pData = temp; } - if (in_struct->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(in_struct->pCreateInfo); - if (in_struct->pSubresource) pSubresource = new safe_VkImageSubresource2KHR(in_struct->pSubresource); } -safe_VkDeviceImageSubresourceInfoKHR::safe_VkDeviceImageSubresourceInfoKHR() - : sType(VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR), pNext(nullptr), pCreateInfo(nullptr), pSubresource(nullptr) {} +safe_VkPipelineBinaryDataKHR::safe_VkPipelineBinaryDataKHR() : dataSize(), pData(nullptr) {} -safe_VkDeviceImageSubresourceInfoKHR::safe_VkDeviceImageSubresourceInfoKHR(const safe_VkDeviceImageSubresourceInfoKHR& copy_src) { - sType = copy_src.sType; - pCreateInfo = nullptr; - pSubresource = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src.pCreateInfo); - if (copy_src.pSubresource) pSubresource = new safe_VkImageSubresource2KHR(*copy_src.pSubresource); +safe_VkPipelineBinaryDataKHR::safe_VkPipelineBinaryDataKHR(const safe_VkPipelineBinaryDataKHR& copy_src) { + dataSize = copy_src.dataSize; + + if (copy_src.pData != nullptr) { + auto temp = new std::byte[copy_src.dataSize]; + std::memcpy(temp, copy_src.pData, copy_src.dataSize); + pData = temp; + } } -safe_VkDeviceImageSubresourceInfoKHR& safe_VkDeviceImageSubresourceInfoKHR::operator=( - const safe_VkDeviceImageSubresourceInfoKHR& copy_src) { +safe_VkPipelineBinaryDataKHR& safe_VkPipelineBinaryDataKHR::operator=(const safe_VkPipelineBinaryDataKHR& copy_src) { if (©_src == this) return *this; - if (pCreateInfo) delete pCreateInfo; - if (pSubresource) delete pSubresource; - FreePnextChain(pNext); - - sType = copy_src.sType; - pCreateInfo = nullptr; - pSubresource = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src.pCreateInfo); - if (copy_src.pSubresource) pSubresource = new safe_VkImageSubresource2KHR(*copy_src.pSubresource); - - return *this; -} + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } -safe_VkDeviceImageSubresourceInfoKHR::~safe_VkDeviceImageSubresourceInfoKHR() { - if (pCreateInfo) delete pCreateInfo; - if (pSubresource) delete pSubresource; - FreePnextChain(pNext); -} + dataSize = copy_src.dataSize; -void safe_VkDeviceImageSubresourceInfoKHR::initialize(const VkDeviceImageSubresourceInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pCreateInfo) delete pCreateInfo; - if (pSubresource) delete pSubresource; - FreePnextChain(pNext); - sType = in_struct->sType; - pCreateInfo = nullptr; - pSubresource = nullptr; - pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (in_struct->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(in_struct->pCreateInfo); - if (in_struct->pSubresource) pSubresource = new safe_VkImageSubresource2KHR(in_struct->pSubresource); -} + if (copy_src.pData != nullptr) { + auto temp = new std::byte[copy_src.dataSize]; + std::memcpy(temp, copy_src.pData, copy_src.dataSize); + pData = temp; + } -void safe_VkDeviceImageSubresourceInfoKHR::initialize(const safe_VkDeviceImageSubresourceInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - pCreateInfo = nullptr; - pSubresource = nullptr; - pNext = SafePnextCopy(copy_src->pNext); - if (copy_src->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src->pCreateInfo); - if (copy_src->pSubresource) pSubresource = new safe_VkImageSubresource2KHR(*copy_src->pSubresource); + return *this; } -safe_VkSubresourceLayout2KHR::safe_VkSubresourceLayout2KHR(const VkSubresourceLayout2KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), subresourceLayout(in_struct->subresourceLayout) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); +safe_VkPipelineBinaryDataKHR::~safe_VkPipelineBinaryDataKHR() { + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; } } -safe_VkSubresourceLayout2KHR::safe_VkSubresourceLayout2KHR() - : sType(VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR), pNext(nullptr), subresourceLayout() {} +void safe_VkPipelineBinaryDataKHR::initialize(const VkPipelineBinaryDataKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + dataSize = in_struct->dataSize; -safe_VkSubresourceLayout2KHR::safe_VkSubresourceLayout2KHR(const safe_VkSubresourceLayout2KHR& copy_src) { - sType = copy_src.sType; - subresourceLayout = copy_src.subresourceLayout; - pNext = SafePnextCopy(copy_src.pNext); + if (in_struct->pData != nullptr) { + auto temp = new std::byte[in_struct->dataSize]; + std::memcpy(temp, in_struct->pData, in_struct->dataSize); + pData = temp; + } } -safe_VkSubresourceLayout2KHR& safe_VkSubresourceLayout2KHR::operator=(const safe_VkSubresourceLayout2KHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - subresourceLayout = copy_src.subresourceLayout; - pNext = SafePnextCopy(copy_src.pNext); +void safe_VkPipelineBinaryDataKHR::initialize(const safe_VkPipelineBinaryDataKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + dataSize = copy_src->dataSize; - return *this; + if (copy_src->pData != nullptr) { + auto temp = new std::byte[copy_src->dataSize]; + std::memcpy(temp, copy_src->pData, copy_src->dataSize); + pData = temp; + } } -safe_VkSubresourceLayout2KHR::~safe_VkSubresourceLayout2KHR() { FreePnextChain(pNext); } - -void safe_VkSubresourceLayout2KHR::initialize(const VkSubresourceLayout2KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - subresourceLayout = in_struct->subresourceLayout; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkSubresourceLayout2KHR::initialize(const safe_VkSubresourceLayout2KHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - subresourceLayout = copy_src->subresourceLayout; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkPipelineCreateFlags2CreateInfoKHR::safe_VkPipelineCreateFlags2CreateInfoKHR( - const VkPipelineCreateFlags2CreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), flags(in_struct->flags) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); +safe_VkPipelineBinaryKeysAndDataKHR::safe_VkPipelineBinaryKeysAndDataKHR(const VkPipelineBinaryKeysAndDataKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) + : binaryCount(in_struct->binaryCount), pPipelineBinaryKeys(nullptr), pPipelineBinaryData(nullptr) { + if (binaryCount && in_struct->pPipelineBinaryKeys) { + pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryKeys[i].initialize(&in_struct->pPipelineBinaryKeys[i]); + } + } + if (binaryCount && in_struct->pPipelineBinaryData) { + pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryData[i].initialize(&in_struct->pPipelineBinaryData[i]); + } } } -safe_VkPipelineCreateFlags2CreateInfoKHR::safe_VkPipelineCreateFlags2CreateInfoKHR() - : sType(VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR), pNext(nullptr), flags() {} +safe_VkPipelineBinaryKeysAndDataKHR::safe_VkPipelineBinaryKeysAndDataKHR() + : binaryCount(), pPipelineBinaryKeys(nullptr), pPipelineBinaryData(nullptr) {} -safe_VkPipelineCreateFlags2CreateInfoKHR::safe_VkPipelineCreateFlags2CreateInfoKHR( - const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src) { - sType = copy_src.sType; - flags = copy_src.flags; - pNext = SafePnextCopy(copy_src.pNext); +safe_VkPipelineBinaryKeysAndDataKHR::safe_VkPipelineBinaryKeysAndDataKHR(const safe_VkPipelineBinaryKeysAndDataKHR& copy_src) { + binaryCount = copy_src.binaryCount; + pPipelineBinaryKeys = nullptr; + pPipelineBinaryData = nullptr; + if (binaryCount && copy_src.pPipelineBinaryKeys) { + pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryKeys[i].initialize(©_src.pPipelineBinaryKeys[i]); + } + } + if (binaryCount && copy_src.pPipelineBinaryData) { + pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryData[i].initialize(©_src.pPipelineBinaryData[i]); + } + } } -safe_VkPipelineCreateFlags2CreateInfoKHR& safe_VkPipelineCreateFlags2CreateInfoKHR::operator=( - const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src) { +safe_VkPipelineBinaryKeysAndDataKHR& safe_VkPipelineBinaryKeysAndDataKHR::operator=( + const safe_VkPipelineBinaryKeysAndDataKHR& copy_src) { if (©_src == this) return *this; - FreePnextChain(pNext); + if (pPipelineBinaryKeys) delete[] pPipelineBinaryKeys; + if (pPipelineBinaryData) delete[] pPipelineBinaryData; - sType = copy_src.sType; - flags = copy_src.flags; - pNext = SafePnextCopy(copy_src.pNext); + binaryCount = copy_src.binaryCount; + pPipelineBinaryKeys = nullptr; + pPipelineBinaryData = nullptr; + if (binaryCount && copy_src.pPipelineBinaryKeys) { + pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryKeys[i].initialize(©_src.pPipelineBinaryKeys[i]); + } + } + if (binaryCount && copy_src.pPipelineBinaryData) { + pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryData[i].initialize(©_src.pPipelineBinaryData[i]); + } + } return *this; } -safe_VkPipelineCreateFlags2CreateInfoKHR::~safe_VkPipelineCreateFlags2CreateInfoKHR() { FreePnextChain(pNext); } +safe_VkPipelineBinaryKeysAndDataKHR::~safe_VkPipelineBinaryKeysAndDataKHR() { + if (pPipelineBinaryKeys) delete[] pPipelineBinaryKeys; + if (pPipelineBinaryData) delete[] pPipelineBinaryData; +} -void safe_VkPipelineCreateFlags2CreateInfoKHR::initialize(const VkPipelineCreateFlags2CreateInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - flags = in_struct->flags; - pNext = SafePnextCopy(in_struct->pNext, copy_state); +void safe_VkPipelineBinaryKeysAndDataKHR::initialize(const VkPipelineBinaryKeysAndDataKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPipelineBinaryKeys) delete[] pPipelineBinaryKeys; + if (pPipelineBinaryData) delete[] pPipelineBinaryData; + binaryCount = in_struct->binaryCount; + pPipelineBinaryKeys = nullptr; + pPipelineBinaryData = nullptr; + if (binaryCount && in_struct->pPipelineBinaryKeys) { + pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryKeys[i].initialize(&in_struct->pPipelineBinaryKeys[i]); + } + } + if (binaryCount && in_struct->pPipelineBinaryData) { + pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryData[i].initialize(&in_struct->pPipelineBinaryData[i]); + } + } } -void safe_VkPipelineCreateFlags2CreateInfoKHR::initialize(const safe_VkPipelineCreateFlags2CreateInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - flags = copy_src->flags; - pNext = SafePnextCopy(copy_src->pNext); +void safe_VkPipelineBinaryKeysAndDataKHR::initialize(const safe_VkPipelineBinaryKeysAndDataKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + binaryCount = copy_src->binaryCount; + pPipelineBinaryKeys = nullptr; + pPipelineBinaryData = nullptr; + if (binaryCount && copy_src->pPipelineBinaryKeys) { + pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryKeys[i].initialize(©_src->pPipelineBinaryKeys[i]); + } + } + if (binaryCount && copy_src->pPipelineBinaryData) { + pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaryData[i].initialize(©_src->pPipelineBinaryData[i]); + } + } } -safe_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR(const VkBufferUsageFlags2CreateInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), usage(in_struct->usage) { +safe_VkPipelineCreateInfoKHR::safe_VkPipelineCreateInfoKHR(const VkPipelineCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR() - : sType(VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR), pNext(nullptr), usage() {} +safe_VkPipelineCreateInfoKHR::safe_VkPipelineCreateInfoKHR() : sType(VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR), pNext(nullptr) {} -safe_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR( - const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src) { +safe_VkPipelineCreateInfoKHR::safe_VkPipelineCreateInfoKHR(const safe_VkPipelineCreateInfoKHR& copy_src) { sType = copy_src.sType; - usage = copy_src.usage; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkBufferUsageFlags2CreateInfoKHR& safe_VkBufferUsageFlags2CreateInfoKHR::operator=( - const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src) { +safe_VkPipelineCreateInfoKHR& safe_VkPipelineCreateInfoKHR::operator=(const safe_VkPipelineCreateInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - usage = copy_src.usage; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkBufferUsageFlags2CreateInfoKHR::~safe_VkBufferUsageFlags2CreateInfoKHR() { FreePnextChain(pNext); } +safe_VkPipelineCreateInfoKHR::~safe_VkPipelineCreateInfoKHR() { FreePnextChain(pNext); } -void safe_VkBufferUsageFlags2CreateInfoKHR::initialize(const VkBufferUsageFlags2CreateInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPipelineCreateInfoKHR::initialize(const VkPipelineCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - usage = in_struct->usage; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkBufferUsageFlags2CreateInfoKHR::initialize(const safe_VkBufferUsageFlags2CreateInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPipelineCreateInfoKHR::initialize(const safe_VkPipelineCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - usage = copy_src->usage; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR( - const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), rayTracingPositionFetch(in_struct->rayTracingPositionFetch) { +safe_VkPipelineBinaryCreateInfoKHR::safe_VkPipelineBinaryCreateInfoKHR(const VkPipelineBinaryCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pKeysAndDataInfo(nullptr), pipeline(in_struct->pipeline), pPipelineCreateInfo(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + if (in_struct->pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(in_struct->pKeysAndDataInfo); + if (in_struct->pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(in_struct->pPipelineCreateInfo); } -safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR), pNext(nullptr), rayTracingPositionFetch() {} +safe_VkPipelineBinaryCreateInfoKHR::safe_VkPipelineBinaryCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR), + pNext(nullptr), + pKeysAndDataInfo(nullptr), + pipeline(), + pPipelineCreateInfo(nullptr) {} -safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR( - const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src) { +safe_VkPipelineBinaryCreateInfoKHR::safe_VkPipelineBinaryCreateInfoKHR(const safe_VkPipelineBinaryCreateInfoKHR& copy_src) { sType = copy_src.sType; - rayTracingPositionFetch = copy_src.rayTracingPositionFetch; + pKeysAndDataInfo = nullptr; + pipeline = copy_src.pipeline; + pPipelineCreateInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(*copy_src.pKeysAndDataInfo); + if (copy_src.pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(*copy_src.pPipelineCreateInfo); } -safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::operator=( - const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src) { +safe_VkPipelineBinaryCreateInfoKHR& safe_VkPipelineBinaryCreateInfoKHR::operator=( + const safe_VkPipelineBinaryCreateInfoKHR& copy_src) { if (©_src == this) return *this; + if (pKeysAndDataInfo) delete pKeysAndDataInfo; + if (pPipelineCreateInfo) delete pPipelineCreateInfo; FreePnextChain(pNext); sType = copy_src.sType; - rayTracingPositionFetch = copy_src.rayTracingPositionFetch; + pKeysAndDataInfo = nullptr; + pipeline = copy_src.pipeline; + pPipelineCreateInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(*copy_src.pKeysAndDataInfo); + if (copy_src.pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(*copy_src.pPipelineCreateInfo); return *this; } -safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::~safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR() { +safe_VkPipelineBinaryCreateInfoKHR::~safe_VkPipelineBinaryCreateInfoKHR() { + if (pKeysAndDataInfo) delete pKeysAndDataInfo; + if (pPipelineCreateInfo) delete pPipelineCreateInfo; FreePnextChain(pNext); } -void safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::initialize( - const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPipelineBinaryCreateInfoKHR::initialize(const VkPipelineBinaryCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pKeysAndDataInfo) delete pKeysAndDataInfo; + if (pPipelineCreateInfo) delete pPipelineCreateInfo; FreePnextChain(pNext); sType = in_struct->sType; - rayTracingPositionFetch = in_struct->rayTracingPositionFetch; + pKeysAndDataInfo = nullptr; + pipeline = in_struct->pipeline; + pPipelineCreateInfo = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (in_struct->pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(in_struct->pKeysAndDataInfo); + if (in_struct->pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(in_struct->pPipelineCreateInfo); } -void safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::initialize( - const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPipelineBinaryCreateInfoKHR::initialize(const safe_VkPipelineBinaryCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - rayTracingPositionFetch = copy_src->rayTracingPositionFetch; + pKeysAndDataInfo = nullptr; + pipeline = copy_src->pipeline; + pPipelineCreateInfo = nullptr; pNext = SafePnextCopy(copy_src->pNext); + if (copy_src->pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(*copy_src->pKeysAndDataInfo); + if (copy_src->pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(*copy_src->pPipelineCreateInfo); } -safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::safe_VkPhysicalDevicePipelineBinaryFeaturesKHR( - const VkPhysicalDevicePipelineBinaryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), pipelineBinaries(in_struct->pipelineBinaries) { +safe_VkPipelineBinaryInfoKHR::safe_VkPipelineBinaryInfoKHR(const VkPipelineBinaryInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), binaryCount(in_struct->binaryCount), pPipelineBinaries(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + if (binaryCount && in_struct->pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaries[i] = in_struct->pPipelineBinaries[i]; + } + } } -safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::safe_VkPhysicalDevicePipelineBinaryFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR), pNext(nullptr), pipelineBinaries() {} +safe_VkPipelineBinaryInfoKHR::safe_VkPipelineBinaryInfoKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR), pNext(nullptr), binaryCount(), pPipelineBinaries(nullptr) {} -safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::safe_VkPhysicalDevicePipelineBinaryFeaturesKHR( - const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& copy_src) { +safe_VkPipelineBinaryInfoKHR::safe_VkPipelineBinaryInfoKHR(const safe_VkPipelineBinaryInfoKHR& copy_src) { sType = copy_src.sType; - pipelineBinaries = copy_src.pipelineBinaries; + binaryCount = copy_src.binaryCount; + pPipelineBinaries = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (binaryCount && copy_src.pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaries[i] = copy_src.pPipelineBinaries[i]; + } + } } -safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::operator=( - const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& copy_src) { +safe_VkPipelineBinaryInfoKHR& safe_VkPipelineBinaryInfoKHR::operator=(const safe_VkPipelineBinaryInfoKHR& copy_src) { if (©_src == this) return *this; + if (pPipelineBinaries) delete[] pPipelineBinaries; FreePnextChain(pNext); sType = copy_src.sType; - pipelineBinaries = copy_src.pipelineBinaries; + binaryCount = copy_src.binaryCount; + pPipelineBinaries = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (binaryCount && copy_src.pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaries[i] = copy_src.pPipelineBinaries[i]; + } + } return *this; } -safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::~safe_VkPhysicalDevicePipelineBinaryFeaturesKHR() { FreePnextChain(pNext); } +safe_VkPipelineBinaryInfoKHR::~safe_VkPipelineBinaryInfoKHR() { + if (pPipelineBinaries) delete[] pPipelineBinaries; + FreePnextChain(pNext); +} -void safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::initialize(const VkPhysicalDevicePipelineBinaryFeaturesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPipelineBinaryInfoKHR::initialize(const VkPipelineBinaryInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPipelineBinaries) delete[] pPipelineBinaries; FreePnextChain(pNext); sType = in_struct->sType; - pipelineBinaries = in_struct->pipelineBinaries; + binaryCount = in_struct->binaryCount; + pPipelineBinaries = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::initialize(const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { + if (binaryCount && in_struct->pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaries[i] = in_struct->pPipelineBinaries[i]; + } + } +} + +void safe_VkPipelineBinaryInfoKHR::initialize(const safe_VkPipelineBinaryInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - pipelineBinaries = copy_src->pipelineBinaries; + binaryCount = copy_src->binaryCount; + pPipelineBinaries = nullptr; pNext = SafePnextCopy(copy_src->pNext); + if (binaryCount && copy_src->pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount]; + for (uint32_t i = 0; i < binaryCount; ++i) { + pPipelineBinaries[i] = copy_src->pPipelineBinaries[i]; + } + } } -safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::safe_VkPhysicalDevicePipelineBinaryPropertiesKHR( - const VkPhysicalDevicePipelineBinaryPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - pipelineBinaryInternalCache(in_struct->pipelineBinaryInternalCache), - pipelineBinaryInternalCacheControl(in_struct->pipelineBinaryInternalCacheControl), - pipelineBinaryPrefersInternalCache(in_struct->pipelineBinaryPrefersInternalCache), - pipelineBinaryPrecompiledInternalCache(in_struct->pipelineBinaryPrecompiledInternalCache), - pipelineBinaryCompressedData(in_struct->pipelineBinaryCompressedData) { +safe_VkReleaseCapturedPipelineDataInfoKHR::safe_VkReleaseCapturedPipelineDataInfoKHR( + const VkReleaseCapturedPipelineDataInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pipeline(in_struct->pipeline) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::safe_VkPhysicalDevicePipelineBinaryPropertiesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR), - pNext(nullptr), - pipelineBinaryInternalCache(), - pipelineBinaryInternalCacheControl(), - pipelineBinaryPrefersInternalCache(), - pipelineBinaryPrecompiledInternalCache(), - pipelineBinaryCompressedData() {} +safe_VkReleaseCapturedPipelineDataInfoKHR::safe_VkReleaseCapturedPipelineDataInfoKHR() + : sType(VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR), pNext(nullptr), pipeline() {} -safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::safe_VkPhysicalDevicePipelineBinaryPropertiesKHR( - const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& copy_src) { +safe_VkReleaseCapturedPipelineDataInfoKHR::safe_VkReleaseCapturedPipelineDataInfoKHR( + const safe_VkReleaseCapturedPipelineDataInfoKHR& copy_src) { sType = copy_src.sType; - pipelineBinaryInternalCache = copy_src.pipelineBinaryInternalCache; - pipelineBinaryInternalCacheControl = copy_src.pipelineBinaryInternalCacheControl; - pipelineBinaryPrefersInternalCache = copy_src.pipelineBinaryPrefersInternalCache; - pipelineBinaryPrecompiledInternalCache = copy_src.pipelineBinaryPrecompiledInternalCache; - pipelineBinaryCompressedData = copy_src.pipelineBinaryCompressedData; + pipeline = copy_src.pipeline; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::operator=( - const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& copy_src) { +safe_VkReleaseCapturedPipelineDataInfoKHR& safe_VkReleaseCapturedPipelineDataInfoKHR::operator=( + const safe_VkReleaseCapturedPipelineDataInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - pipelineBinaryInternalCache = copy_src.pipelineBinaryInternalCache; - pipelineBinaryInternalCacheControl = copy_src.pipelineBinaryInternalCacheControl; - pipelineBinaryPrefersInternalCache = copy_src.pipelineBinaryPrefersInternalCache; - pipelineBinaryPrecompiledInternalCache = copy_src.pipelineBinaryPrecompiledInternalCache; - pipelineBinaryCompressedData = copy_src.pipelineBinaryCompressedData; + pipeline = copy_src.pipeline; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::~safe_VkPhysicalDevicePipelineBinaryPropertiesKHR() { FreePnextChain(pNext); } +safe_VkReleaseCapturedPipelineDataInfoKHR::~safe_VkReleaseCapturedPipelineDataInfoKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::initialize(const VkPhysicalDevicePipelineBinaryPropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkReleaseCapturedPipelineDataInfoKHR::initialize(const VkReleaseCapturedPipelineDataInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - pipelineBinaryInternalCache = in_struct->pipelineBinaryInternalCache; - pipelineBinaryInternalCacheControl = in_struct->pipelineBinaryInternalCacheControl; - pipelineBinaryPrefersInternalCache = in_struct->pipelineBinaryPrefersInternalCache; - pipelineBinaryPrecompiledInternalCache = in_struct->pipelineBinaryPrecompiledInternalCache; - pipelineBinaryCompressedData = in_struct->pipelineBinaryCompressedData; + pipeline = in_struct->pipeline; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::initialize(const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkReleaseCapturedPipelineDataInfoKHR::initialize(const safe_VkReleaseCapturedPipelineDataInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - pipelineBinaryInternalCache = copy_src->pipelineBinaryInternalCache; - pipelineBinaryInternalCacheControl = copy_src->pipelineBinaryInternalCacheControl; - pipelineBinaryPrefersInternalCache = copy_src->pipelineBinaryPrefersInternalCache; - pipelineBinaryPrecompiledInternalCache = copy_src->pipelineBinaryPrecompiledInternalCache; - pipelineBinaryCompressedData = copy_src->pipelineBinaryCompressedData; + pipeline = copy_src->pipeline; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkDevicePipelineBinaryInternalCacheControlKHR::safe_VkDevicePipelineBinaryInternalCacheControlKHR( - const VkDevicePipelineBinaryInternalCacheControlKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), disableInternalCache(in_struct->disableInternalCache) { +safe_VkPipelineBinaryDataInfoKHR::safe_VkPipelineBinaryDataInfoKHR(const VkPipelineBinaryDataInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pipelineBinary(in_struct->pipelineBinary) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkDevicePipelineBinaryInternalCacheControlKHR::safe_VkDevicePipelineBinaryInternalCacheControlKHR() - : sType(VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR), pNext(nullptr), disableInternalCache() {} +safe_VkPipelineBinaryDataInfoKHR::safe_VkPipelineBinaryDataInfoKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR), pNext(nullptr), pipelineBinary() {} -safe_VkDevicePipelineBinaryInternalCacheControlKHR::safe_VkDevicePipelineBinaryInternalCacheControlKHR( - const safe_VkDevicePipelineBinaryInternalCacheControlKHR& copy_src) { +safe_VkPipelineBinaryDataInfoKHR::safe_VkPipelineBinaryDataInfoKHR(const safe_VkPipelineBinaryDataInfoKHR& copy_src) { sType = copy_src.sType; - disableInternalCache = copy_src.disableInternalCache; + pipelineBinary = copy_src.pipelineBinary; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkDevicePipelineBinaryInternalCacheControlKHR& safe_VkDevicePipelineBinaryInternalCacheControlKHR::operator=( - const safe_VkDevicePipelineBinaryInternalCacheControlKHR& copy_src) { +safe_VkPipelineBinaryDataInfoKHR& safe_VkPipelineBinaryDataInfoKHR::operator=(const safe_VkPipelineBinaryDataInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - disableInternalCache = copy_src.disableInternalCache; + pipelineBinary = copy_src.pipelineBinary; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkDevicePipelineBinaryInternalCacheControlKHR::~safe_VkDevicePipelineBinaryInternalCacheControlKHR() { FreePnextChain(pNext); } +safe_VkPipelineBinaryDataInfoKHR::~safe_VkPipelineBinaryDataInfoKHR() { FreePnextChain(pNext); } -void safe_VkDevicePipelineBinaryInternalCacheControlKHR::initialize(const VkDevicePipelineBinaryInternalCacheControlKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPipelineBinaryDataInfoKHR::initialize(const VkPipelineBinaryDataInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - disableInternalCache = in_struct->disableInternalCache; + pipelineBinary = in_struct->pipelineBinary; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkDevicePipelineBinaryInternalCacheControlKHR::initialize( - const safe_VkDevicePipelineBinaryInternalCacheControlKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPipelineBinaryDataInfoKHR::initialize(const safe_VkPipelineBinaryDataInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - disableInternalCache = copy_src->disableInternalCache; + pipelineBinary = copy_src->pipelineBinary; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPipelineBinaryKeyKHR::safe_VkPipelineBinaryKeyKHR(const VkPipelineBinaryKeyKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), keySize(in_struct->keySize) { +safe_VkPipelineBinaryHandlesInfoKHR::safe_VkPipelineBinaryHandlesInfoKHR(const VkPipelineBinaryHandlesInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), pipelineBinaryCount(in_struct->pipelineBinaryCount), pPipelineBinaries(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) { - key[i] = in_struct->key[i]; + if (pipelineBinaryCount && in_struct->pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount]; + for (uint32_t i = 0; i < pipelineBinaryCount; ++i) { + pPipelineBinaries[i] = in_struct->pPipelineBinaries[i]; + } } } -safe_VkPipelineBinaryKeyKHR::safe_VkPipelineBinaryKeyKHR() - : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR), pNext(nullptr), keySize() {} +safe_VkPipelineBinaryHandlesInfoKHR::safe_VkPipelineBinaryHandlesInfoKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR), + pNext(nullptr), + pipelineBinaryCount(), + pPipelineBinaries(nullptr) {} -safe_VkPipelineBinaryKeyKHR::safe_VkPipelineBinaryKeyKHR(const safe_VkPipelineBinaryKeyKHR& copy_src) { +safe_VkPipelineBinaryHandlesInfoKHR::safe_VkPipelineBinaryHandlesInfoKHR(const safe_VkPipelineBinaryHandlesInfoKHR& copy_src) { sType = copy_src.sType; - keySize = copy_src.keySize; + pipelineBinaryCount = copy_src.pipelineBinaryCount; + pPipelineBinaries = nullptr; pNext = SafePnextCopy(copy_src.pNext); - - for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) { - key[i] = copy_src.key[i]; + if (pipelineBinaryCount && copy_src.pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount]; + for (uint32_t i = 0; i < pipelineBinaryCount; ++i) { + pPipelineBinaries[i] = copy_src.pPipelineBinaries[i]; + } } } -safe_VkPipelineBinaryKeyKHR& safe_VkPipelineBinaryKeyKHR::operator=(const safe_VkPipelineBinaryKeyKHR& copy_src) { +safe_VkPipelineBinaryHandlesInfoKHR& safe_VkPipelineBinaryHandlesInfoKHR::operator=( + const safe_VkPipelineBinaryHandlesInfoKHR& copy_src) { if (©_src == this) return *this; + if (pPipelineBinaries) delete[] pPipelineBinaries; FreePnextChain(pNext); sType = copy_src.sType; - keySize = copy_src.keySize; + pipelineBinaryCount = copy_src.pipelineBinaryCount; + pPipelineBinaries = nullptr; pNext = SafePnextCopy(copy_src.pNext); - - for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) { - key[i] = copy_src.key[i]; + if (pipelineBinaryCount && copy_src.pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount]; + for (uint32_t i = 0; i < pipelineBinaryCount; ++i) { + pPipelineBinaries[i] = copy_src.pPipelineBinaries[i]; + } } return *this; } -safe_VkPipelineBinaryKeyKHR::~safe_VkPipelineBinaryKeyKHR() { FreePnextChain(pNext); } +safe_VkPipelineBinaryHandlesInfoKHR::~safe_VkPipelineBinaryHandlesInfoKHR() { + if (pPipelineBinaries) delete[] pPipelineBinaries; + FreePnextChain(pNext); +} -void safe_VkPipelineBinaryKeyKHR::initialize(const VkPipelineBinaryKeyKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPipelineBinaryHandlesInfoKHR::initialize(const VkPipelineBinaryHandlesInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPipelineBinaries) delete[] pPipelineBinaries; FreePnextChain(pNext); sType = in_struct->sType; - keySize = in_struct->keySize; + pipelineBinaryCount = in_struct->pipelineBinaryCount; + pPipelineBinaries = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) { - key[i] = in_struct->key[i]; + if (pipelineBinaryCount && in_struct->pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount]; + for (uint32_t i = 0; i < pipelineBinaryCount; ++i) { + pPipelineBinaries[i] = in_struct->pPipelineBinaries[i]; + } } } -void safe_VkPipelineBinaryKeyKHR::initialize(const safe_VkPipelineBinaryKeyKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPipelineBinaryHandlesInfoKHR::initialize(const safe_VkPipelineBinaryHandlesInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - keySize = copy_src->keySize; + pipelineBinaryCount = copy_src->pipelineBinaryCount; + pPipelineBinaries = nullptr; pNext = SafePnextCopy(copy_src->pNext); - - for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) { - key[i] = copy_src->key[i]; + if (pipelineBinaryCount && copy_src->pPipelineBinaries) { + pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount]; + for (uint32_t i = 0; i < pipelineBinaryCount; ++i) { + pPipelineBinaries[i] = copy_src->pPipelineBinaries[i]; + } } } -safe_VkPipelineBinaryDataKHR::safe_VkPipelineBinaryDataKHR(const VkPipelineBinaryDataKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) - : dataSize(in_struct->dataSize), pData(nullptr) { - if (in_struct->pData != nullptr) { - auto temp = new std::byte[in_struct->dataSize]; - std::memcpy(temp, in_struct->pData, in_struct->dataSize); - pData = temp; +safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR(const VkCooperativeMatrixPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + MSize(in_struct->MSize), + NSize(in_struct->NSize), + KSize(in_struct->KSize), + AType(in_struct->AType), + BType(in_struct->BType), + CType(in_struct->CType), + ResultType(in_struct->ResultType), + saturatingAccumulation(in_struct->saturatingAccumulation), + scope(in_struct->scope) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPipelineBinaryDataKHR::safe_VkPipelineBinaryDataKHR() : dataSize(), pData(nullptr) {} +safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR), + pNext(nullptr), + MSize(), + NSize(), + KSize(), + AType(), + BType(), + CType(), + ResultType(), + saturatingAccumulation(), + scope() {} -safe_VkPipelineBinaryDataKHR::safe_VkPipelineBinaryDataKHR(const safe_VkPipelineBinaryDataKHR& copy_src) { - dataSize = copy_src.dataSize; +safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR( + const safe_VkCooperativeMatrixPropertiesKHR& copy_src) { + sType = copy_src.sType; + MSize = copy_src.MSize; + NSize = copy_src.NSize; + KSize = copy_src.KSize; + AType = copy_src.AType; + BType = copy_src.BType; + CType = copy_src.CType; + ResultType = copy_src.ResultType; + saturatingAccumulation = copy_src.saturatingAccumulation; + scope = copy_src.scope; + pNext = SafePnextCopy(copy_src.pNext); +} - if (copy_src.pData != nullptr) { - auto temp = new std::byte[copy_src.dataSize]; - std::memcpy(temp, copy_src.pData, copy_src.dataSize); - pData = temp; - } -} - -safe_VkPipelineBinaryDataKHR& safe_VkPipelineBinaryDataKHR::operator=(const safe_VkPipelineBinaryDataKHR& copy_src) { - if (©_src == this) return *this; - - if (pData != nullptr) { - auto temp = reinterpret_cast(pData); - delete[] temp; - } - - dataSize = copy_src.dataSize; - - if (copy_src.pData != nullptr) { - auto temp = new std::byte[copy_src.dataSize]; - std::memcpy(temp, copy_src.pData, copy_src.dataSize); - pData = temp; - } - - return *this; -} - -safe_VkPipelineBinaryDataKHR::~safe_VkPipelineBinaryDataKHR() { - if (pData != nullptr) { - auto temp = reinterpret_cast(pData); - delete[] temp; - } -} - -void safe_VkPipelineBinaryDataKHR::initialize(const VkPipelineBinaryDataKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pData != nullptr) { - auto temp = reinterpret_cast(pData); - delete[] temp; - } - dataSize = in_struct->dataSize; - - if (in_struct->pData != nullptr) { - auto temp = new std::byte[in_struct->dataSize]; - std::memcpy(temp, in_struct->pData, in_struct->dataSize); - pData = temp; - } -} - -void safe_VkPipelineBinaryDataKHR::initialize(const safe_VkPipelineBinaryDataKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - dataSize = copy_src->dataSize; - - if (copy_src->pData != nullptr) { - auto temp = new std::byte[copy_src->dataSize]; - std::memcpy(temp, copy_src->pData, copy_src->dataSize); - pData = temp; - } -} - -safe_VkPipelineBinaryKeysAndDataKHR::safe_VkPipelineBinaryKeysAndDataKHR(const VkPipelineBinaryKeysAndDataKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) - : binaryCount(in_struct->binaryCount), pPipelineBinaryKeys(nullptr), pPipelineBinaryData(nullptr) { - if (binaryCount && in_struct->pPipelineBinaryKeys) { - pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount]; - for (uint32_t i = 0; i < binaryCount; ++i) { - pPipelineBinaryKeys[i].initialize(&in_struct->pPipelineBinaryKeys[i]); - } - } - if (binaryCount && in_struct->pPipelineBinaryData) { - pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount]; - for (uint32_t i = 0; i < binaryCount; ++i) { - pPipelineBinaryData[i].initialize(&in_struct->pPipelineBinaryData[i]); - } - } -} - -safe_VkPipelineBinaryKeysAndDataKHR::safe_VkPipelineBinaryKeysAndDataKHR() - : binaryCount(), pPipelineBinaryKeys(nullptr), pPipelineBinaryData(nullptr) {} - -safe_VkPipelineBinaryKeysAndDataKHR::safe_VkPipelineBinaryKeysAndDataKHR(const safe_VkPipelineBinaryKeysAndDataKHR& copy_src) { - binaryCount = copy_src.binaryCount; - pPipelineBinaryKeys = nullptr; - pPipelineBinaryData = nullptr; - if (binaryCount && copy_src.pPipelineBinaryKeys) { - pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount]; - for (uint32_t i = 0; i < binaryCount; ++i) { - pPipelineBinaryKeys[i].initialize(©_src.pPipelineBinaryKeys[i]); - } - } - if (binaryCount && copy_src.pPipelineBinaryData) { - pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount]; - for (uint32_t i = 0; i < binaryCount; ++i) { - pPipelineBinaryData[i].initialize(©_src.pPipelineBinaryData[i]); - } - } -} - -safe_VkPipelineBinaryKeysAndDataKHR& safe_VkPipelineBinaryKeysAndDataKHR::operator=( - const safe_VkPipelineBinaryKeysAndDataKHR& copy_src) { - if (©_src == this) return *this; - - if (pPipelineBinaryKeys) delete[] pPipelineBinaryKeys; - if (pPipelineBinaryData) delete[] pPipelineBinaryData; - - binaryCount = copy_src.binaryCount; - pPipelineBinaryKeys = nullptr; - pPipelineBinaryData = nullptr; - if (binaryCount && copy_src.pPipelineBinaryKeys) { - pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount]; - for (uint32_t i = 0; i < binaryCount; ++i) { - pPipelineBinaryKeys[i].initialize(©_src.pPipelineBinaryKeys[i]); - } - } - if (binaryCount && copy_src.pPipelineBinaryData) { - pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount]; - for (uint32_t i = 0; i < binaryCount; ++i) { - pPipelineBinaryData[i].initialize(©_src.pPipelineBinaryData[i]); - } - } - - return *this; -} - -safe_VkPipelineBinaryKeysAndDataKHR::~safe_VkPipelineBinaryKeysAndDataKHR() { - if (pPipelineBinaryKeys) delete[] pPipelineBinaryKeys; - if (pPipelineBinaryData) delete[] pPipelineBinaryData; -} - -void safe_VkPipelineBinaryKeysAndDataKHR::initialize(const VkPipelineBinaryKeysAndDataKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pPipelineBinaryKeys) delete[] pPipelineBinaryKeys; - if (pPipelineBinaryData) delete[] pPipelineBinaryData; - binaryCount = in_struct->binaryCount; - pPipelineBinaryKeys = nullptr; - pPipelineBinaryData = nullptr; - if (binaryCount && in_struct->pPipelineBinaryKeys) { - pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount]; - for (uint32_t i = 0; i < binaryCount; ++i) { - pPipelineBinaryKeys[i].initialize(&in_struct->pPipelineBinaryKeys[i]); - } - } - if (binaryCount && in_struct->pPipelineBinaryData) { - pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount]; - for (uint32_t i = 0; i < binaryCount; ++i) { - pPipelineBinaryData[i].initialize(&in_struct->pPipelineBinaryData[i]); - } - } -} - -void safe_VkPipelineBinaryKeysAndDataKHR::initialize(const safe_VkPipelineBinaryKeysAndDataKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - binaryCount = copy_src->binaryCount; - pPipelineBinaryKeys = nullptr; - pPipelineBinaryData = nullptr; - if (binaryCount && copy_src->pPipelineBinaryKeys) { - pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount]; - for (uint32_t i = 0; i < binaryCount; ++i) { - pPipelineBinaryKeys[i].initialize(©_src->pPipelineBinaryKeys[i]); - } - } - if (binaryCount && copy_src->pPipelineBinaryData) { - pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount]; - for (uint32_t i = 0; i < binaryCount; ++i) { - pPipelineBinaryData[i].initialize(©_src->pPipelineBinaryData[i]); - } - } -} - -safe_VkPipelineCreateInfoKHR::safe_VkPipelineCreateInfoKHR(const VkPipelineCreateInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkPipelineCreateInfoKHR::safe_VkPipelineCreateInfoKHR() : sType(VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR), pNext(nullptr) {} - -safe_VkPipelineCreateInfoKHR::safe_VkPipelineCreateInfoKHR(const safe_VkPipelineCreateInfoKHR& copy_src) { - sType = copy_src.sType; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkPipelineCreateInfoKHR& safe_VkPipelineCreateInfoKHR::operator=(const safe_VkPipelineCreateInfoKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkPipelineCreateInfoKHR::~safe_VkPipelineCreateInfoKHR() { FreePnextChain(pNext); } - -void safe_VkPipelineCreateInfoKHR::initialize(const VkPipelineCreateInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPipelineCreateInfoKHR::initialize(const safe_VkPipelineCreateInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkPipelineBinaryCreateInfoKHR::safe_VkPipelineBinaryCreateInfoKHR(const VkPipelineBinaryCreateInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), pKeysAndDataInfo(nullptr), pipeline(in_struct->pipeline), pPipelineCreateInfo(nullptr) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } - if (in_struct->pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(in_struct->pKeysAndDataInfo); - if (in_struct->pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(in_struct->pPipelineCreateInfo); -} - -safe_VkPipelineBinaryCreateInfoKHR::safe_VkPipelineBinaryCreateInfoKHR() - : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR), - pNext(nullptr), - pKeysAndDataInfo(nullptr), - pipeline(), - pPipelineCreateInfo(nullptr) {} - -safe_VkPipelineBinaryCreateInfoKHR::safe_VkPipelineBinaryCreateInfoKHR(const safe_VkPipelineBinaryCreateInfoKHR& copy_src) { - sType = copy_src.sType; - pKeysAndDataInfo = nullptr; - pipeline = copy_src.pipeline; - pPipelineCreateInfo = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(*copy_src.pKeysAndDataInfo); - if (copy_src.pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(*copy_src.pPipelineCreateInfo); -} - -safe_VkPipelineBinaryCreateInfoKHR& safe_VkPipelineBinaryCreateInfoKHR::operator=( - const safe_VkPipelineBinaryCreateInfoKHR& copy_src) { - if (©_src == this) return *this; - - if (pKeysAndDataInfo) delete pKeysAndDataInfo; - if (pPipelineCreateInfo) delete pPipelineCreateInfo; - FreePnextChain(pNext); - - sType = copy_src.sType; - pKeysAndDataInfo = nullptr; - pipeline = copy_src.pipeline; - pPipelineCreateInfo = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(*copy_src.pKeysAndDataInfo); - if (copy_src.pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(*copy_src.pPipelineCreateInfo); - - return *this; -} - -safe_VkPipelineBinaryCreateInfoKHR::~safe_VkPipelineBinaryCreateInfoKHR() { - if (pKeysAndDataInfo) delete pKeysAndDataInfo; - if (pPipelineCreateInfo) delete pPipelineCreateInfo; - FreePnextChain(pNext); -} - -void safe_VkPipelineBinaryCreateInfoKHR::initialize(const VkPipelineBinaryCreateInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pKeysAndDataInfo) delete pKeysAndDataInfo; - if (pPipelineCreateInfo) delete pPipelineCreateInfo; - FreePnextChain(pNext); - sType = in_struct->sType; - pKeysAndDataInfo = nullptr; - pipeline = in_struct->pipeline; - pPipelineCreateInfo = nullptr; - pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (in_struct->pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(in_struct->pKeysAndDataInfo); - if (in_struct->pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(in_struct->pPipelineCreateInfo); -} - -void safe_VkPipelineBinaryCreateInfoKHR::initialize(const safe_VkPipelineBinaryCreateInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - pKeysAndDataInfo = nullptr; - pipeline = copy_src->pipeline; - pPipelineCreateInfo = nullptr; - pNext = SafePnextCopy(copy_src->pNext); - if (copy_src->pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(*copy_src->pKeysAndDataInfo); - if (copy_src->pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(*copy_src->pPipelineCreateInfo); -} - -safe_VkPipelineBinaryInfoKHR::safe_VkPipelineBinaryInfoKHR(const VkPipelineBinaryInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), binaryCount(in_struct->binaryCount), pPipelineBinaries(nullptr) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } - if (binaryCount && in_struct->pPipelineBinaries) { - pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount]; - for (uint32_t i = 0; i < binaryCount; ++i) { - pPipelineBinaries[i] = in_struct->pPipelineBinaries[i]; - } - } -} - -safe_VkPipelineBinaryInfoKHR::safe_VkPipelineBinaryInfoKHR() - : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR), pNext(nullptr), binaryCount(), pPipelineBinaries(nullptr) {} - -safe_VkPipelineBinaryInfoKHR::safe_VkPipelineBinaryInfoKHR(const safe_VkPipelineBinaryInfoKHR& copy_src) { - sType = copy_src.sType; - binaryCount = copy_src.binaryCount; - pPipelineBinaries = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (binaryCount && copy_src.pPipelineBinaries) { - pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount]; - for (uint32_t i = 0; i < binaryCount; ++i) { - pPipelineBinaries[i] = copy_src.pPipelineBinaries[i]; - } - } -} - -safe_VkPipelineBinaryInfoKHR& safe_VkPipelineBinaryInfoKHR::operator=(const safe_VkPipelineBinaryInfoKHR& copy_src) { - if (©_src == this) return *this; - - if (pPipelineBinaries) delete[] pPipelineBinaries; - FreePnextChain(pNext); - - sType = copy_src.sType; - binaryCount = copy_src.binaryCount; - pPipelineBinaries = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (binaryCount && copy_src.pPipelineBinaries) { - pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount]; - for (uint32_t i = 0; i < binaryCount; ++i) { - pPipelineBinaries[i] = copy_src.pPipelineBinaries[i]; - } - } - - return *this; -} - -safe_VkPipelineBinaryInfoKHR::~safe_VkPipelineBinaryInfoKHR() { - if (pPipelineBinaries) delete[] pPipelineBinaries; - FreePnextChain(pNext); -} - -void safe_VkPipelineBinaryInfoKHR::initialize(const VkPipelineBinaryInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pPipelineBinaries) delete[] pPipelineBinaries; - FreePnextChain(pNext); - sType = in_struct->sType; - binaryCount = in_struct->binaryCount; - pPipelineBinaries = nullptr; - pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (binaryCount && in_struct->pPipelineBinaries) { - pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount]; - for (uint32_t i = 0; i < binaryCount; ++i) { - pPipelineBinaries[i] = in_struct->pPipelineBinaries[i]; - } - } -} - -void safe_VkPipelineBinaryInfoKHR::initialize(const safe_VkPipelineBinaryInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - binaryCount = copy_src->binaryCount; - pPipelineBinaries = nullptr; - pNext = SafePnextCopy(copy_src->pNext); - if (binaryCount && copy_src->pPipelineBinaries) { - pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount]; - for (uint32_t i = 0; i < binaryCount; ++i) { - pPipelineBinaries[i] = copy_src->pPipelineBinaries[i]; - } - } -} - -safe_VkReleaseCapturedPipelineDataInfoKHR::safe_VkReleaseCapturedPipelineDataInfoKHR( - const VkReleaseCapturedPipelineDataInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), pipeline(in_struct->pipeline) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkReleaseCapturedPipelineDataInfoKHR::safe_VkReleaseCapturedPipelineDataInfoKHR() - : sType(VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR), pNext(nullptr), pipeline() {} - -safe_VkReleaseCapturedPipelineDataInfoKHR::safe_VkReleaseCapturedPipelineDataInfoKHR( - const safe_VkReleaseCapturedPipelineDataInfoKHR& copy_src) { - sType = copy_src.sType; - pipeline = copy_src.pipeline; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkReleaseCapturedPipelineDataInfoKHR& safe_VkReleaseCapturedPipelineDataInfoKHR::operator=( - const safe_VkReleaseCapturedPipelineDataInfoKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - pipeline = copy_src.pipeline; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkReleaseCapturedPipelineDataInfoKHR::~safe_VkReleaseCapturedPipelineDataInfoKHR() { FreePnextChain(pNext); } - -void safe_VkReleaseCapturedPipelineDataInfoKHR::initialize(const VkReleaseCapturedPipelineDataInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - pipeline = in_struct->pipeline; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkReleaseCapturedPipelineDataInfoKHR::initialize(const safe_VkReleaseCapturedPipelineDataInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - pipeline = copy_src->pipeline; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkPipelineBinaryDataInfoKHR::safe_VkPipelineBinaryDataInfoKHR(const VkPipelineBinaryDataInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), pipelineBinary(in_struct->pipelineBinary) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkPipelineBinaryDataInfoKHR::safe_VkPipelineBinaryDataInfoKHR() - : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR), pNext(nullptr), pipelineBinary() {} - -safe_VkPipelineBinaryDataInfoKHR::safe_VkPipelineBinaryDataInfoKHR(const safe_VkPipelineBinaryDataInfoKHR& copy_src) { - sType = copy_src.sType; - pipelineBinary = copy_src.pipelineBinary; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkPipelineBinaryDataInfoKHR& safe_VkPipelineBinaryDataInfoKHR::operator=(const safe_VkPipelineBinaryDataInfoKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - pipelineBinary = copy_src.pipelineBinary; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkPipelineBinaryDataInfoKHR::~safe_VkPipelineBinaryDataInfoKHR() { FreePnextChain(pNext); } - -void safe_VkPipelineBinaryDataInfoKHR::initialize(const VkPipelineBinaryDataInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - pipelineBinary = in_struct->pipelineBinary; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPipelineBinaryDataInfoKHR::initialize(const safe_VkPipelineBinaryDataInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - pipelineBinary = copy_src->pipelineBinary; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkPipelineBinaryHandlesInfoKHR::safe_VkPipelineBinaryHandlesInfoKHR(const VkPipelineBinaryHandlesInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), pipelineBinaryCount(in_struct->pipelineBinaryCount), pPipelineBinaries(nullptr) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } - if (pipelineBinaryCount && in_struct->pPipelineBinaries) { - pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount]; - for (uint32_t i = 0; i < pipelineBinaryCount; ++i) { - pPipelineBinaries[i] = in_struct->pPipelineBinaries[i]; - } - } -} - -safe_VkPipelineBinaryHandlesInfoKHR::safe_VkPipelineBinaryHandlesInfoKHR() - : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR), - pNext(nullptr), - pipelineBinaryCount(), - pPipelineBinaries(nullptr) {} - -safe_VkPipelineBinaryHandlesInfoKHR::safe_VkPipelineBinaryHandlesInfoKHR(const safe_VkPipelineBinaryHandlesInfoKHR& copy_src) { - sType = copy_src.sType; - pipelineBinaryCount = copy_src.pipelineBinaryCount; - pPipelineBinaries = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (pipelineBinaryCount && copy_src.pPipelineBinaries) { - pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount]; - for (uint32_t i = 0; i < pipelineBinaryCount; ++i) { - pPipelineBinaries[i] = copy_src.pPipelineBinaries[i]; - } - } -} - -safe_VkPipelineBinaryHandlesInfoKHR& safe_VkPipelineBinaryHandlesInfoKHR::operator=( - const safe_VkPipelineBinaryHandlesInfoKHR& copy_src) { - if (©_src == this) return *this; - - if (pPipelineBinaries) delete[] pPipelineBinaries; - FreePnextChain(pNext); - - sType = copy_src.sType; - pipelineBinaryCount = copy_src.pipelineBinaryCount; - pPipelineBinaries = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (pipelineBinaryCount && copy_src.pPipelineBinaries) { - pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount]; - for (uint32_t i = 0; i < pipelineBinaryCount; ++i) { - pPipelineBinaries[i] = copy_src.pPipelineBinaries[i]; - } - } - - return *this; -} - -safe_VkPipelineBinaryHandlesInfoKHR::~safe_VkPipelineBinaryHandlesInfoKHR() { - if (pPipelineBinaries) delete[] pPipelineBinaries; - FreePnextChain(pNext); -} - -void safe_VkPipelineBinaryHandlesInfoKHR::initialize(const VkPipelineBinaryHandlesInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pPipelineBinaries) delete[] pPipelineBinaries; - FreePnextChain(pNext); - sType = in_struct->sType; - pipelineBinaryCount = in_struct->pipelineBinaryCount; - pPipelineBinaries = nullptr; - pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (pipelineBinaryCount && in_struct->pPipelineBinaries) { - pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount]; - for (uint32_t i = 0; i < pipelineBinaryCount; ++i) { - pPipelineBinaries[i] = in_struct->pPipelineBinaries[i]; - } - } -} - -void safe_VkPipelineBinaryHandlesInfoKHR::initialize(const safe_VkPipelineBinaryHandlesInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - pipelineBinaryCount = copy_src->pipelineBinaryCount; - pPipelineBinaries = nullptr; - pNext = SafePnextCopy(copy_src->pNext); - if (pipelineBinaryCount && copy_src->pPipelineBinaries) { - pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount]; - for (uint32_t i = 0; i < pipelineBinaryCount; ++i) { - pPipelineBinaries[i] = copy_src->pPipelineBinaries[i]; - } - } -} - -safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR(const VkCooperativeMatrixPropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), - MSize(in_struct->MSize), - NSize(in_struct->NSize), - KSize(in_struct->KSize), - AType(in_struct->AType), - BType(in_struct->BType), - CType(in_struct->CType), - ResultType(in_struct->ResultType), - saturatingAccumulation(in_struct->saturatingAccumulation), - scope(in_struct->scope) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR() - : sType(VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR), - pNext(nullptr), - MSize(), - NSize(), - KSize(), - AType(), - BType(), - CType(), - ResultType(), - saturatingAccumulation(), - scope() {} - -safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR( - const safe_VkCooperativeMatrixPropertiesKHR& copy_src) { - sType = copy_src.sType; - MSize = copy_src.MSize; - NSize = copy_src.NSize; - KSize = copy_src.KSize; - AType = copy_src.AType; - BType = copy_src.BType; - CType = copy_src.CType; - ResultType = copy_src.ResultType; - saturatingAccumulation = copy_src.saturatingAccumulation; - scope = copy_src.scope; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkCooperativeMatrixPropertiesKHR& safe_VkCooperativeMatrixPropertiesKHR::operator=( - const safe_VkCooperativeMatrixPropertiesKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - MSize = copy_src.MSize; - NSize = copy_src.NSize; - KSize = copy_src.KSize; - AType = copy_src.AType; - BType = copy_src.BType; - CType = copy_src.CType; - ResultType = copy_src.ResultType; - saturatingAccumulation = copy_src.saturatingAccumulation; - scope = copy_src.scope; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkCooperativeMatrixPropertiesKHR::~safe_VkCooperativeMatrixPropertiesKHR() { FreePnextChain(pNext); } - -void safe_VkCooperativeMatrixPropertiesKHR::initialize(const VkCooperativeMatrixPropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - MSize = in_struct->MSize; - NSize = in_struct->NSize; - KSize = in_struct->KSize; - AType = in_struct->AType; - BType = in_struct->BType; - CType = in_struct->CType; - ResultType = in_struct->ResultType; - saturatingAccumulation = in_struct->saturatingAccumulation; - scope = in_struct->scope; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkCooperativeMatrixPropertiesKHR::initialize(const safe_VkCooperativeMatrixPropertiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - MSize = copy_src->MSize; - NSize = copy_src->NSize; - KSize = copy_src->KSize; - AType = copy_src->AType; - BType = copy_src->BType; - CType = copy_src->CType; - ResultType = copy_src->ResultType; - saturatingAccumulation = copy_src->saturatingAccumulation; - scope = copy_src->scope; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR( - const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - cooperativeMatrix(in_struct->cooperativeMatrix), - cooperativeMatrixRobustBufferAccess(in_struct->cooperativeMatrixRobustBufferAccess) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR), - pNext(nullptr), - cooperativeMatrix(), - cooperativeMatrixRobustBufferAccess() {} - -safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR( - const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src) { - sType = copy_src.sType; - cooperativeMatrix = copy_src.cooperativeMatrix; - cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::operator=( - const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - cooperativeMatrix = copy_src.cooperativeMatrix; - cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::~safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR() { FreePnextChain(pNext); } - -void safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - cooperativeMatrix = in_struct->cooperativeMatrix; - cooperativeMatrixRobustBufferAccess = in_struct->cooperativeMatrixRobustBufferAccess; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::initialize( - const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - cooperativeMatrix = copy_src->cooperativeMatrix; - cooperativeMatrixRobustBufferAccess = copy_src->cooperativeMatrixRobustBufferAccess; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR( - const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), cooperativeMatrixSupportedStages(in_struct->cooperativeMatrixSupportedStages) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR), - pNext(nullptr), - cooperativeMatrixSupportedStages() {} - -safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR( - const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src) { - sType = copy_src.sType; - cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::operator=( - const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::~safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR() { - FreePnextChain(pNext); -} - -void safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::initialize( - const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - cooperativeMatrixSupportedStages = in_struct->cooperativeMatrixSupportedStages; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::initialize( - const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - cooperativeMatrixSupportedStages = copy_src->cooperativeMatrixSupportedStages; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR( - const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), - computeDerivativeGroupQuads(in_struct->computeDerivativeGroupQuads), - computeDerivativeGroupLinear(in_struct->computeDerivativeGroupLinear) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR), - pNext(nullptr), - computeDerivativeGroupQuads(), - computeDerivativeGroupLinear() {} - -safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR( - const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR& copy_src) { - sType = copy_src.sType; - computeDerivativeGroupQuads = copy_src.computeDerivativeGroupQuads; - computeDerivativeGroupLinear = copy_src.computeDerivativeGroupLinear; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR& safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::operator=( - const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - computeDerivativeGroupQuads = copy_src.computeDerivativeGroupQuads; - computeDerivativeGroupLinear = copy_src.computeDerivativeGroupLinear; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::~safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR() { - FreePnextChain(pNext); -} - -void safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::initialize( - const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - computeDerivativeGroupQuads = in_struct->computeDerivativeGroupQuads; - computeDerivativeGroupLinear = in_struct->computeDerivativeGroupLinear; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::initialize( - const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - computeDerivativeGroupQuads = copy_src->computeDerivativeGroupQuads; - computeDerivativeGroupLinear = copy_src->computeDerivativeGroupLinear; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR( - const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), meshAndTaskShaderDerivatives(in_struct->meshAndTaskShaderDerivatives) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR), - pNext(nullptr), - meshAndTaskShaderDerivatives() {} - -safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR( - const safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR& copy_src) { - sType = copy_src.sType; - meshAndTaskShaderDerivatives = copy_src.meshAndTaskShaderDerivatives; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR& safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::operator=( - const safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - meshAndTaskShaderDerivatives = copy_src.meshAndTaskShaderDerivatives; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::~safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR() { - FreePnextChain(pNext); -} - -void safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::initialize( - const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - meshAndTaskShaderDerivatives = in_struct->meshAndTaskShaderDerivatives; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::initialize( - const safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - meshAndTaskShaderDerivatives = copy_src->meshAndTaskShaderDerivatives; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoDecodeAV1ProfileInfoKHR::safe_VkVideoDecodeAV1ProfileInfoKHR(const VkVideoDecodeAV1ProfileInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), stdProfile(in_struct->stdProfile), filmGrainSupport(in_struct->filmGrainSupport) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoDecodeAV1ProfileInfoKHR::safe_VkVideoDecodeAV1ProfileInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR), pNext(nullptr), stdProfile(), filmGrainSupport() {} - -safe_VkVideoDecodeAV1ProfileInfoKHR::safe_VkVideoDecodeAV1ProfileInfoKHR(const safe_VkVideoDecodeAV1ProfileInfoKHR& copy_src) { - sType = copy_src.sType; - stdProfile = copy_src.stdProfile; - filmGrainSupport = copy_src.filmGrainSupport; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoDecodeAV1ProfileInfoKHR& safe_VkVideoDecodeAV1ProfileInfoKHR::operator=( - const safe_VkVideoDecodeAV1ProfileInfoKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - stdProfile = copy_src.stdProfile; - filmGrainSupport = copy_src.filmGrainSupport; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoDecodeAV1ProfileInfoKHR::~safe_VkVideoDecodeAV1ProfileInfoKHR() { FreePnextChain(pNext); } - -void safe_VkVideoDecodeAV1ProfileInfoKHR::initialize(const VkVideoDecodeAV1ProfileInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - stdProfile = in_struct->stdProfile; - filmGrainSupport = in_struct->filmGrainSupport; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoDecodeAV1ProfileInfoKHR::initialize(const safe_VkVideoDecodeAV1ProfileInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - stdProfile = copy_src->stdProfile; - filmGrainSupport = copy_src->filmGrainSupport; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoDecodeAV1CapabilitiesKHR::safe_VkVideoDecodeAV1CapabilitiesKHR(const VkVideoDecodeAV1CapabilitiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), maxLevel(in_struct->maxLevel) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoDecodeAV1CapabilitiesKHR::safe_VkVideoDecodeAV1CapabilitiesKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR), pNext(nullptr), maxLevel() {} - -safe_VkVideoDecodeAV1CapabilitiesKHR::safe_VkVideoDecodeAV1CapabilitiesKHR(const safe_VkVideoDecodeAV1CapabilitiesKHR& copy_src) { - sType = copy_src.sType; - maxLevel = copy_src.maxLevel; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoDecodeAV1CapabilitiesKHR& safe_VkVideoDecodeAV1CapabilitiesKHR::operator=( - const safe_VkVideoDecodeAV1CapabilitiesKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - maxLevel = copy_src.maxLevel; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoDecodeAV1CapabilitiesKHR::~safe_VkVideoDecodeAV1CapabilitiesKHR() { FreePnextChain(pNext); } - -void safe_VkVideoDecodeAV1CapabilitiesKHR::initialize(const VkVideoDecodeAV1CapabilitiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - maxLevel = in_struct->maxLevel; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoDecodeAV1CapabilitiesKHR::initialize(const safe_VkVideoDecodeAV1CapabilitiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - maxLevel = copy_src->maxLevel; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR( - const VkVideoDecodeAV1SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), pStdSequenceHeader(nullptr) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } - if (in_struct->pStdSequenceHeader) { - pStdSequenceHeader = new StdVideoAV1SequenceHeader(*in_struct->pStdSequenceHeader); - } -} - -safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR), pNext(nullptr), pStdSequenceHeader(nullptr) {} - -safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR( - const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& copy_src) { - sType = copy_src.sType; - pStdSequenceHeader = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdSequenceHeader) { - pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src.pStdSequenceHeader); - } -} - -safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::operator=( - const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& copy_src) { - if (©_src == this) return *this; - - if (pStdSequenceHeader) delete pStdSequenceHeader; - FreePnextChain(pNext); - - sType = copy_src.sType; - pStdSequenceHeader = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdSequenceHeader) { - pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src.pStdSequenceHeader); - } - - return *this; -} - -safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::~safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR() { - if (pStdSequenceHeader) delete pStdSequenceHeader; - FreePnextChain(pNext); -} - -void safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::initialize( - const VkVideoDecodeAV1SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - if (pStdSequenceHeader) delete pStdSequenceHeader; - FreePnextChain(pNext); - sType = in_struct->sType; - pStdSequenceHeader = nullptr; - pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pStdSequenceHeader) { - pStdSequenceHeader = new StdVideoAV1SequenceHeader(*in_struct->pStdSequenceHeader); - } -} - -void safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::initialize( - const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - pStdSequenceHeader = nullptr; - pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pStdSequenceHeader) { - pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src->pStdSequenceHeader); - } -} - -safe_VkVideoDecodeAV1PictureInfoKHR::safe_VkVideoDecodeAV1PictureInfoKHR(const VkVideoDecodeAV1PictureInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), - pStdPictureInfo(nullptr), - frameHeaderOffset(in_struct->frameHeaderOffset), - tileCount(in_struct->tileCount), - pTileOffsets(nullptr), - pTileSizes(nullptr) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } - if (in_struct->pStdPictureInfo) { - pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*in_struct->pStdPictureInfo); - } - - for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { - referenceNameSlotIndices[i] = in_struct->referenceNameSlotIndices[i]; - } - - if (in_struct->pTileOffsets) { - pTileOffsets = new uint32_t[in_struct->tileCount]; - memcpy((void*)pTileOffsets, (void*)in_struct->pTileOffsets, sizeof(uint32_t) * in_struct->tileCount); - } - - if (in_struct->pTileSizes) { - pTileSizes = new uint32_t[in_struct->tileCount]; - memcpy((void*)pTileSizes, (void*)in_struct->pTileSizes, sizeof(uint32_t) * in_struct->tileCount); - } -} - -safe_VkVideoDecodeAV1PictureInfoKHR::safe_VkVideoDecodeAV1PictureInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR), - pNext(nullptr), - pStdPictureInfo(nullptr), - frameHeaderOffset(), - tileCount(), - pTileOffsets(nullptr), - pTileSizes(nullptr) {} - -safe_VkVideoDecodeAV1PictureInfoKHR::safe_VkVideoDecodeAV1PictureInfoKHR(const safe_VkVideoDecodeAV1PictureInfoKHR& copy_src) { - sType = copy_src.sType; - pStdPictureInfo = nullptr; - frameHeaderOffset = copy_src.frameHeaderOffset; - tileCount = copy_src.tileCount; - pTileOffsets = nullptr; - pTileSizes = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdPictureInfo) { - pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*copy_src.pStdPictureInfo); - } - - for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { - referenceNameSlotIndices[i] = copy_src.referenceNameSlotIndices[i]; - } - - if (copy_src.pTileOffsets) { - pTileOffsets = new uint32_t[copy_src.tileCount]; - memcpy((void*)pTileOffsets, (void*)copy_src.pTileOffsets, sizeof(uint32_t) * copy_src.tileCount); - } - - if (copy_src.pTileSizes) { - pTileSizes = new uint32_t[copy_src.tileCount]; - memcpy((void*)pTileSizes, (void*)copy_src.pTileSizes, sizeof(uint32_t) * copy_src.tileCount); - } -} - -safe_VkVideoDecodeAV1PictureInfoKHR& safe_VkVideoDecodeAV1PictureInfoKHR::operator=( - const safe_VkVideoDecodeAV1PictureInfoKHR& copy_src) { - if (©_src == this) return *this; - - if (pStdPictureInfo) delete pStdPictureInfo; - if (pTileOffsets) delete[] pTileOffsets; - if (pTileSizes) delete[] pTileSizes; - FreePnextChain(pNext); - - sType = copy_src.sType; - pStdPictureInfo = nullptr; - frameHeaderOffset = copy_src.frameHeaderOffset; - tileCount = copy_src.tileCount; - pTileOffsets = nullptr; - pTileSizes = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdPictureInfo) { - pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*copy_src.pStdPictureInfo); - } - - for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { - referenceNameSlotIndices[i] = copy_src.referenceNameSlotIndices[i]; - } - - if (copy_src.pTileOffsets) { - pTileOffsets = new uint32_t[copy_src.tileCount]; - memcpy((void*)pTileOffsets, (void*)copy_src.pTileOffsets, sizeof(uint32_t) * copy_src.tileCount); - } - - if (copy_src.pTileSizes) { - pTileSizes = new uint32_t[copy_src.tileCount]; - memcpy((void*)pTileSizes, (void*)copy_src.pTileSizes, sizeof(uint32_t) * copy_src.tileCount); - } - - return *this; -} - -safe_VkVideoDecodeAV1PictureInfoKHR::~safe_VkVideoDecodeAV1PictureInfoKHR() { - if (pStdPictureInfo) delete pStdPictureInfo; - if (pTileOffsets) delete[] pTileOffsets; - if (pTileSizes) delete[] pTileSizes; - FreePnextChain(pNext); -} - -void safe_VkVideoDecodeAV1PictureInfoKHR::initialize(const VkVideoDecodeAV1PictureInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pStdPictureInfo) delete pStdPictureInfo; - if (pTileOffsets) delete[] pTileOffsets; - if (pTileSizes) delete[] pTileSizes; - FreePnextChain(pNext); - sType = in_struct->sType; - pStdPictureInfo = nullptr; - frameHeaderOffset = in_struct->frameHeaderOffset; - tileCount = in_struct->tileCount; - pTileOffsets = nullptr; - pTileSizes = nullptr; - pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pStdPictureInfo) { - pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*in_struct->pStdPictureInfo); - } - - for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { - referenceNameSlotIndices[i] = in_struct->referenceNameSlotIndices[i]; - } - - if (in_struct->pTileOffsets) { - pTileOffsets = new uint32_t[in_struct->tileCount]; - memcpy((void*)pTileOffsets, (void*)in_struct->pTileOffsets, sizeof(uint32_t) * in_struct->tileCount); - } - - if (in_struct->pTileSizes) { - pTileSizes = new uint32_t[in_struct->tileCount]; - memcpy((void*)pTileSizes, (void*)in_struct->pTileSizes, sizeof(uint32_t) * in_struct->tileCount); - } -} - -void safe_VkVideoDecodeAV1PictureInfoKHR::initialize(const safe_VkVideoDecodeAV1PictureInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - pStdPictureInfo = nullptr; - frameHeaderOffset = copy_src->frameHeaderOffset; - tileCount = copy_src->tileCount; - pTileOffsets = nullptr; - pTileSizes = nullptr; - pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pStdPictureInfo) { - pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*copy_src->pStdPictureInfo); - } - - for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { - referenceNameSlotIndices[i] = copy_src->referenceNameSlotIndices[i]; - } - - if (copy_src->pTileOffsets) { - pTileOffsets = new uint32_t[copy_src->tileCount]; - memcpy((void*)pTileOffsets, (void*)copy_src->pTileOffsets, sizeof(uint32_t) * copy_src->tileCount); - } - - if (copy_src->pTileSizes) { - pTileSizes = new uint32_t[copy_src->tileCount]; - memcpy((void*)pTileSizes, (void*)copy_src->pTileSizes, sizeof(uint32_t) * copy_src->tileCount); - } -} - -safe_VkVideoDecodeAV1DpbSlotInfoKHR::safe_VkVideoDecodeAV1DpbSlotInfoKHR(const VkVideoDecodeAV1DpbSlotInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), pStdReferenceInfo(nullptr) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } - if (in_struct->pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*in_struct->pStdReferenceInfo); - } -} - -safe_VkVideoDecodeAV1DpbSlotInfoKHR::safe_VkVideoDecodeAV1DpbSlotInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {} - -safe_VkVideoDecodeAV1DpbSlotInfoKHR::safe_VkVideoDecodeAV1DpbSlotInfoKHR(const safe_VkVideoDecodeAV1DpbSlotInfoKHR& copy_src) { - sType = copy_src.sType; - pStdReferenceInfo = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*copy_src.pStdReferenceInfo); - } -} - -safe_VkVideoDecodeAV1DpbSlotInfoKHR& safe_VkVideoDecodeAV1DpbSlotInfoKHR::operator=( - const safe_VkVideoDecodeAV1DpbSlotInfoKHR& copy_src) { - if (©_src == this) return *this; - - if (pStdReferenceInfo) delete pStdReferenceInfo; - FreePnextChain(pNext); - - sType = copy_src.sType; - pStdReferenceInfo = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*copy_src.pStdReferenceInfo); - } - - return *this; -} - -safe_VkVideoDecodeAV1DpbSlotInfoKHR::~safe_VkVideoDecodeAV1DpbSlotInfoKHR() { - if (pStdReferenceInfo) delete pStdReferenceInfo; - FreePnextChain(pNext); -} - -void safe_VkVideoDecodeAV1DpbSlotInfoKHR::initialize(const VkVideoDecodeAV1DpbSlotInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pStdReferenceInfo) delete pStdReferenceInfo; - FreePnextChain(pNext); - sType = in_struct->sType; - pStdReferenceInfo = nullptr; - pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*in_struct->pStdReferenceInfo); - } -} - -void safe_VkVideoDecodeAV1DpbSlotInfoKHR::initialize(const safe_VkVideoDecodeAV1DpbSlotInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - pStdReferenceInfo = nullptr; - pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*copy_src->pStdReferenceInfo); - } -} - -safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR( - const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), videoEncodeAV1(in_struct->videoEncodeAV1) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR), pNext(nullptr), videoEncodeAV1() {} - -safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR( - const safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& copy_src) { - sType = copy_src.sType; - videoEncodeAV1 = copy_src.videoEncodeAV1; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::operator=( - const safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - videoEncodeAV1 = copy_src.videoEncodeAV1; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::~safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR() { FreePnextChain(pNext); } - -void safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::initialize(const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - videoEncodeAV1 = in_struct->videoEncodeAV1; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::initialize(const safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - videoEncodeAV1 = copy_src->videoEncodeAV1; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeAV1CapabilitiesKHR::safe_VkVideoEncodeAV1CapabilitiesKHR(const VkVideoEncodeAV1CapabilitiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), - flags(in_struct->flags), - maxLevel(in_struct->maxLevel), - codedPictureAlignment(in_struct->codedPictureAlignment), - maxTiles(in_struct->maxTiles), - minTileSize(in_struct->minTileSize), - maxTileSize(in_struct->maxTileSize), - superblockSizes(in_struct->superblockSizes), - maxSingleReferenceCount(in_struct->maxSingleReferenceCount), - singleReferenceNameMask(in_struct->singleReferenceNameMask), - maxUnidirectionalCompoundReferenceCount(in_struct->maxUnidirectionalCompoundReferenceCount), - maxUnidirectionalCompoundGroup1ReferenceCount(in_struct->maxUnidirectionalCompoundGroup1ReferenceCount), - unidirectionalCompoundReferenceNameMask(in_struct->unidirectionalCompoundReferenceNameMask), - maxBidirectionalCompoundReferenceCount(in_struct->maxBidirectionalCompoundReferenceCount), - maxBidirectionalCompoundGroup1ReferenceCount(in_struct->maxBidirectionalCompoundGroup1ReferenceCount), - maxBidirectionalCompoundGroup2ReferenceCount(in_struct->maxBidirectionalCompoundGroup2ReferenceCount), - bidirectionalCompoundReferenceNameMask(in_struct->bidirectionalCompoundReferenceNameMask), - maxTemporalLayerCount(in_struct->maxTemporalLayerCount), - maxSpatialLayerCount(in_struct->maxSpatialLayerCount), - maxOperatingPoints(in_struct->maxOperatingPoints), - minQIndex(in_struct->minQIndex), - maxQIndex(in_struct->maxQIndex), - prefersGopRemainingFrames(in_struct->prefersGopRemainingFrames), - requiresGopRemainingFrames(in_struct->requiresGopRemainingFrames), - stdSyntaxFlags(in_struct->stdSyntaxFlags) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeAV1CapabilitiesKHR::safe_VkVideoEncodeAV1CapabilitiesKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR), - pNext(nullptr), - flags(), - maxLevel(), - codedPictureAlignment(), - maxTiles(), - minTileSize(), - maxTileSize(), - superblockSizes(), - maxSingleReferenceCount(), - singleReferenceNameMask(), - maxUnidirectionalCompoundReferenceCount(), - maxUnidirectionalCompoundGroup1ReferenceCount(), - unidirectionalCompoundReferenceNameMask(), - maxBidirectionalCompoundReferenceCount(), - maxBidirectionalCompoundGroup1ReferenceCount(), - maxBidirectionalCompoundGroup2ReferenceCount(), - bidirectionalCompoundReferenceNameMask(), - maxTemporalLayerCount(), - maxSpatialLayerCount(), - maxOperatingPoints(), - minQIndex(), - maxQIndex(), - prefersGopRemainingFrames(), - requiresGopRemainingFrames(), - stdSyntaxFlags() {} - -safe_VkVideoEncodeAV1CapabilitiesKHR::safe_VkVideoEncodeAV1CapabilitiesKHR(const safe_VkVideoEncodeAV1CapabilitiesKHR& copy_src) { - sType = copy_src.sType; - flags = copy_src.flags; - maxLevel = copy_src.maxLevel; - codedPictureAlignment = copy_src.codedPictureAlignment; - maxTiles = copy_src.maxTiles; - minTileSize = copy_src.minTileSize; - maxTileSize = copy_src.maxTileSize; - superblockSizes = copy_src.superblockSizes; - maxSingleReferenceCount = copy_src.maxSingleReferenceCount; - singleReferenceNameMask = copy_src.singleReferenceNameMask; - maxUnidirectionalCompoundReferenceCount = copy_src.maxUnidirectionalCompoundReferenceCount; - maxUnidirectionalCompoundGroup1ReferenceCount = copy_src.maxUnidirectionalCompoundGroup1ReferenceCount; - unidirectionalCompoundReferenceNameMask = copy_src.unidirectionalCompoundReferenceNameMask; - maxBidirectionalCompoundReferenceCount = copy_src.maxBidirectionalCompoundReferenceCount; - maxBidirectionalCompoundGroup1ReferenceCount = copy_src.maxBidirectionalCompoundGroup1ReferenceCount; - maxBidirectionalCompoundGroup2ReferenceCount = copy_src.maxBidirectionalCompoundGroup2ReferenceCount; - bidirectionalCompoundReferenceNameMask = copy_src.bidirectionalCompoundReferenceNameMask; - maxTemporalLayerCount = copy_src.maxTemporalLayerCount; - maxSpatialLayerCount = copy_src.maxSpatialLayerCount; - maxOperatingPoints = copy_src.maxOperatingPoints; - minQIndex = copy_src.minQIndex; - maxQIndex = copy_src.maxQIndex; - prefersGopRemainingFrames = copy_src.prefersGopRemainingFrames; - requiresGopRemainingFrames = copy_src.requiresGopRemainingFrames; - stdSyntaxFlags = copy_src.stdSyntaxFlags; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeAV1CapabilitiesKHR& safe_VkVideoEncodeAV1CapabilitiesKHR::operator=( - const safe_VkVideoEncodeAV1CapabilitiesKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - flags = copy_src.flags; - maxLevel = copy_src.maxLevel; - codedPictureAlignment = copy_src.codedPictureAlignment; - maxTiles = copy_src.maxTiles; - minTileSize = copy_src.minTileSize; - maxTileSize = copy_src.maxTileSize; - superblockSizes = copy_src.superblockSizes; - maxSingleReferenceCount = copy_src.maxSingleReferenceCount; - singleReferenceNameMask = copy_src.singleReferenceNameMask; - maxUnidirectionalCompoundReferenceCount = copy_src.maxUnidirectionalCompoundReferenceCount; - maxUnidirectionalCompoundGroup1ReferenceCount = copy_src.maxUnidirectionalCompoundGroup1ReferenceCount; - unidirectionalCompoundReferenceNameMask = copy_src.unidirectionalCompoundReferenceNameMask; - maxBidirectionalCompoundReferenceCount = copy_src.maxBidirectionalCompoundReferenceCount; - maxBidirectionalCompoundGroup1ReferenceCount = copy_src.maxBidirectionalCompoundGroup1ReferenceCount; - maxBidirectionalCompoundGroup2ReferenceCount = copy_src.maxBidirectionalCompoundGroup2ReferenceCount; - bidirectionalCompoundReferenceNameMask = copy_src.bidirectionalCompoundReferenceNameMask; - maxTemporalLayerCount = copy_src.maxTemporalLayerCount; - maxSpatialLayerCount = copy_src.maxSpatialLayerCount; - maxOperatingPoints = copy_src.maxOperatingPoints; - minQIndex = copy_src.minQIndex; - maxQIndex = copy_src.maxQIndex; - prefersGopRemainingFrames = copy_src.prefersGopRemainingFrames; - requiresGopRemainingFrames = copy_src.requiresGopRemainingFrames; - stdSyntaxFlags = copy_src.stdSyntaxFlags; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeAV1CapabilitiesKHR::~safe_VkVideoEncodeAV1CapabilitiesKHR() { FreePnextChain(pNext); } - -void safe_VkVideoEncodeAV1CapabilitiesKHR::initialize(const VkVideoEncodeAV1CapabilitiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - flags = in_struct->flags; - maxLevel = in_struct->maxLevel; - codedPictureAlignment = in_struct->codedPictureAlignment; - maxTiles = in_struct->maxTiles; - minTileSize = in_struct->minTileSize; - maxTileSize = in_struct->maxTileSize; - superblockSizes = in_struct->superblockSizes; - maxSingleReferenceCount = in_struct->maxSingleReferenceCount; - singleReferenceNameMask = in_struct->singleReferenceNameMask; - maxUnidirectionalCompoundReferenceCount = in_struct->maxUnidirectionalCompoundReferenceCount; - maxUnidirectionalCompoundGroup1ReferenceCount = in_struct->maxUnidirectionalCompoundGroup1ReferenceCount; - unidirectionalCompoundReferenceNameMask = in_struct->unidirectionalCompoundReferenceNameMask; - maxBidirectionalCompoundReferenceCount = in_struct->maxBidirectionalCompoundReferenceCount; - maxBidirectionalCompoundGroup1ReferenceCount = in_struct->maxBidirectionalCompoundGroup1ReferenceCount; - maxBidirectionalCompoundGroup2ReferenceCount = in_struct->maxBidirectionalCompoundGroup2ReferenceCount; - bidirectionalCompoundReferenceNameMask = in_struct->bidirectionalCompoundReferenceNameMask; - maxTemporalLayerCount = in_struct->maxTemporalLayerCount; - maxSpatialLayerCount = in_struct->maxSpatialLayerCount; - maxOperatingPoints = in_struct->maxOperatingPoints; - minQIndex = in_struct->minQIndex; - maxQIndex = in_struct->maxQIndex; - prefersGopRemainingFrames = in_struct->prefersGopRemainingFrames; - requiresGopRemainingFrames = in_struct->requiresGopRemainingFrames; - stdSyntaxFlags = in_struct->stdSyntaxFlags; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeAV1CapabilitiesKHR::initialize(const safe_VkVideoEncodeAV1CapabilitiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - flags = copy_src->flags; - maxLevel = copy_src->maxLevel; - codedPictureAlignment = copy_src->codedPictureAlignment; - maxTiles = copy_src->maxTiles; - minTileSize = copy_src->minTileSize; - maxTileSize = copy_src->maxTileSize; - superblockSizes = copy_src->superblockSizes; - maxSingleReferenceCount = copy_src->maxSingleReferenceCount; - singleReferenceNameMask = copy_src->singleReferenceNameMask; - maxUnidirectionalCompoundReferenceCount = copy_src->maxUnidirectionalCompoundReferenceCount; - maxUnidirectionalCompoundGroup1ReferenceCount = copy_src->maxUnidirectionalCompoundGroup1ReferenceCount; - unidirectionalCompoundReferenceNameMask = copy_src->unidirectionalCompoundReferenceNameMask; - maxBidirectionalCompoundReferenceCount = copy_src->maxBidirectionalCompoundReferenceCount; - maxBidirectionalCompoundGroup1ReferenceCount = copy_src->maxBidirectionalCompoundGroup1ReferenceCount; - maxBidirectionalCompoundGroup2ReferenceCount = copy_src->maxBidirectionalCompoundGroup2ReferenceCount; - bidirectionalCompoundReferenceNameMask = copy_src->bidirectionalCompoundReferenceNameMask; - maxTemporalLayerCount = copy_src->maxTemporalLayerCount; - maxSpatialLayerCount = copy_src->maxSpatialLayerCount; - maxOperatingPoints = copy_src->maxOperatingPoints; - minQIndex = copy_src->minQIndex; - maxQIndex = copy_src->maxQIndex; - prefersGopRemainingFrames = copy_src->prefersGopRemainingFrames; - requiresGopRemainingFrames = copy_src->requiresGopRemainingFrames; - stdSyntaxFlags = copy_src->stdSyntaxFlags; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::safe_VkVideoEncodeAV1QualityLevelPropertiesKHR( - const VkVideoEncodeAV1QualityLevelPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - preferredRateControlFlags(in_struct->preferredRateControlFlags), - preferredGopFrameCount(in_struct->preferredGopFrameCount), - preferredKeyFramePeriod(in_struct->preferredKeyFramePeriod), - preferredConsecutiveBipredictiveFrameCount(in_struct->preferredConsecutiveBipredictiveFrameCount), - preferredTemporalLayerCount(in_struct->preferredTemporalLayerCount), - preferredConstantQIndex(in_struct->preferredConstantQIndex), - preferredMaxSingleReferenceCount(in_struct->preferredMaxSingleReferenceCount), - preferredSingleReferenceNameMask(in_struct->preferredSingleReferenceNameMask), - preferredMaxUnidirectionalCompoundReferenceCount(in_struct->preferredMaxUnidirectionalCompoundReferenceCount), - preferredMaxUnidirectionalCompoundGroup1ReferenceCount(in_struct->preferredMaxUnidirectionalCompoundGroup1ReferenceCount), - preferredUnidirectionalCompoundReferenceNameMask(in_struct->preferredUnidirectionalCompoundReferenceNameMask), - preferredMaxBidirectionalCompoundReferenceCount(in_struct->preferredMaxBidirectionalCompoundReferenceCount), - preferredMaxBidirectionalCompoundGroup1ReferenceCount(in_struct->preferredMaxBidirectionalCompoundGroup1ReferenceCount), - preferredMaxBidirectionalCompoundGroup2ReferenceCount(in_struct->preferredMaxBidirectionalCompoundGroup2ReferenceCount), - preferredBidirectionalCompoundReferenceNameMask(in_struct->preferredBidirectionalCompoundReferenceNameMask) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::safe_VkVideoEncodeAV1QualityLevelPropertiesKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR), - pNext(nullptr), - preferredRateControlFlags(), - preferredGopFrameCount(), - preferredKeyFramePeriod(), - preferredConsecutiveBipredictiveFrameCount(), - preferredTemporalLayerCount(), - preferredConstantQIndex(), - preferredMaxSingleReferenceCount(), - preferredSingleReferenceNameMask(), - preferredMaxUnidirectionalCompoundReferenceCount(), - preferredMaxUnidirectionalCompoundGroup1ReferenceCount(), - preferredUnidirectionalCompoundReferenceNameMask(), - preferredMaxBidirectionalCompoundReferenceCount(), - preferredMaxBidirectionalCompoundGroup1ReferenceCount(), - preferredMaxBidirectionalCompoundGroup2ReferenceCount(), - preferredBidirectionalCompoundReferenceNameMask() {} - -safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::safe_VkVideoEncodeAV1QualityLevelPropertiesKHR( - const safe_VkVideoEncodeAV1QualityLevelPropertiesKHR& copy_src) { - sType = copy_src.sType; - preferredRateControlFlags = copy_src.preferredRateControlFlags; - preferredGopFrameCount = copy_src.preferredGopFrameCount; - preferredKeyFramePeriod = copy_src.preferredKeyFramePeriod; - preferredConsecutiveBipredictiveFrameCount = copy_src.preferredConsecutiveBipredictiveFrameCount; - preferredTemporalLayerCount = copy_src.preferredTemporalLayerCount; - preferredConstantQIndex = copy_src.preferredConstantQIndex; - preferredMaxSingleReferenceCount = copy_src.preferredMaxSingleReferenceCount; - preferredSingleReferenceNameMask = copy_src.preferredSingleReferenceNameMask; - preferredMaxUnidirectionalCompoundReferenceCount = copy_src.preferredMaxUnidirectionalCompoundReferenceCount; - preferredMaxUnidirectionalCompoundGroup1ReferenceCount = copy_src.preferredMaxUnidirectionalCompoundGroup1ReferenceCount; - preferredUnidirectionalCompoundReferenceNameMask = copy_src.preferredUnidirectionalCompoundReferenceNameMask; - preferredMaxBidirectionalCompoundReferenceCount = copy_src.preferredMaxBidirectionalCompoundReferenceCount; - preferredMaxBidirectionalCompoundGroup1ReferenceCount = copy_src.preferredMaxBidirectionalCompoundGroup1ReferenceCount; - preferredMaxBidirectionalCompoundGroup2ReferenceCount = copy_src.preferredMaxBidirectionalCompoundGroup2ReferenceCount; - preferredBidirectionalCompoundReferenceNameMask = copy_src.preferredBidirectionalCompoundReferenceNameMask; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeAV1QualityLevelPropertiesKHR& safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::operator=( - const safe_VkVideoEncodeAV1QualityLevelPropertiesKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - preferredRateControlFlags = copy_src.preferredRateControlFlags; - preferredGopFrameCount = copy_src.preferredGopFrameCount; - preferredKeyFramePeriod = copy_src.preferredKeyFramePeriod; - preferredConsecutiveBipredictiveFrameCount = copy_src.preferredConsecutiveBipredictiveFrameCount; - preferredTemporalLayerCount = copy_src.preferredTemporalLayerCount; - preferredConstantQIndex = copy_src.preferredConstantQIndex; - preferredMaxSingleReferenceCount = copy_src.preferredMaxSingleReferenceCount; - preferredSingleReferenceNameMask = copy_src.preferredSingleReferenceNameMask; - preferredMaxUnidirectionalCompoundReferenceCount = copy_src.preferredMaxUnidirectionalCompoundReferenceCount; - preferredMaxUnidirectionalCompoundGroup1ReferenceCount = copy_src.preferredMaxUnidirectionalCompoundGroup1ReferenceCount; - preferredUnidirectionalCompoundReferenceNameMask = copy_src.preferredUnidirectionalCompoundReferenceNameMask; - preferredMaxBidirectionalCompoundReferenceCount = copy_src.preferredMaxBidirectionalCompoundReferenceCount; - preferredMaxBidirectionalCompoundGroup1ReferenceCount = copy_src.preferredMaxBidirectionalCompoundGroup1ReferenceCount; - preferredMaxBidirectionalCompoundGroup2ReferenceCount = copy_src.preferredMaxBidirectionalCompoundGroup2ReferenceCount; - preferredBidirectionalCompoundReferenceNameMask = copy_src.preferredBidirectionalCompoundReferenceNameMask; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::~safe_VkVideoEncodeAV1QualityLevelPropertiesKHR() { FreePnextChain(pNext); } - -void safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::initialize(const VkVideoEncodeAV1QualityLevelPropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - preferredRateControlFlags = in_struct->preferredRateControlFlags; - preferredGopFrameCount = in_struct->preferredGopFrameCount; - preferredKeyFramePeriod = in_struct->preferredKeyFramePeriod; - preferredConsecutiveBipredictiveFrameCount = in_struct->preferredConsecutiveBipredictiveFrameCount; - preferredTemporalLayerCount = in_struct->preferredTemporalLayerCount; - preferredConstantQIndex = in_struct->preferredConstantQIndex; - preferredMaxSingleReferenceCount = in_struct->preferredMaxSingleReferenceCount; - preferredSingleReferenceNameMask = in_struct->preferredSingleReferenceNameMask; - preferredMaxUnidirectionalCompoundReferenceCount = in_struct->preferredMaxUnidirectionalCompoundReferenceCount; - preferredMaxUnidirectionalCompoundGroup1ReferenceCount = in_struct->preferredMaxUnidirectionalCompoundGroup1ReferenceCount; - preferredUnidirectionalCompoundReferenceNameMask = in_struct->preferredUnidirectionalCompoundReferenceNameMask; - preferredMaxBidirectionalCompoundReferenceCount = in_struct->preferredMaxBidirectionalCompoundReferenceCount; - preferredMaxBidirectionalCompoundGroup1ReferenceCount = in_struct->preferredMaxBidirectionalCompoundGroup1ReferenceCount; - preferredMaxBidirectionalCompoundGroup2ReferenceCount = in_struct->preferredMaxBidirectionalCompoundGroup2ReferenceCount; - preferredBidirectionalCompoundReferenceNameMask = in_struct->preferredBidirectionalCompoundReferenceNameMask; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::initialize(const safe_VkVideoEncodeAV1QualityLevelPropertiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - preferredRateControlFlags = copy_src->preferredRateControlFlags; - preferredGopFrameCount = copy_src->preferredGopFrameCount; - preferredKeyFramePeriod = copy_src->preferredKeyFramePeriod; - preferredConsecutiveBipredictiveFrameCount = copy_src->preferredConsecutiveBipredictiveFrameCount; - preferredTemporalLayerCount = copy_src->preferredTemporalLayerCount; - preferredConstantQIndex = copy_src->preferredConstantQIndex; - preferredMaxSingleReferenceCount = copy_src->preferredMaxSingleReferenceCount; - preferredSingleReferenceNameMask = copy_src->preferredSingleReferenceNameMask; - preferredMaxUnidirectionalCompoundReferenceCount = copy_src->preferredMaxUnidirectionalCompoundReferenceCount; - preferredMaxUnidirectionalCompoundGroup1ReferenceCount = copy_src->preferredMaxUnidirectionalCompoundGroup1ReferenceCount; - preferredUnidirectionalCompoundReferenceNameMask = copy_src->preferredUnidirectionalCompoundReferenceNameMask; - preferredMaxBidirectionalCompoundReferenceCount = copy_src->preferredMaxBidirectionalCompoundReferenceCount; - preferredMaxBidirectionalCompoundGroup1ReferenceCount = copy_src->preferredMaxBidirectionalCompoundGroup1ReferenceCount; - preferredMaxBidirectionalCompoundGroup2ReferenceCount = copy_src->preferredMaxBidirectionalCompoundGroup2ReferenceCount; - preferredBidirectionalCompoundReferenceNameMask = copy_src->preferredBidirectionalCompoundReferenceNameMask; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeAV1SessionCreateInfoKHR::safe_VkVideoEncodeAV1SessionCreateInfoKHR( - const VkVideoEncodeAV1SessionCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), useMaxLevel(in_struct->useMaxLevel), maxLevel(in_struct->maxLevel) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeAV1SessionCreateInfoKHR::safe_VkVideoEncodeAV1SessionCreateInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR), pNext(nullptr), useMaxLevel(), maxLevel() {} - -safe_VkVideoEncodeAV1SessionCreateInfoKHR::safe_VkVideoEncodeAV1SessionCreateInfoKHR( - const safe_VkVideoEncodeAV1SessionCreateInfoKHR& copy_src) { - sType = copy_src.sType; - useMaxLevel = copy_src.useMaxLevel; - maxLevel = copy_src.maxLevel; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeAV1SessionCreateInfoKHR& safe_VkVideoEncodeAV1SessionCreateInfoKHR::operator=( - const safe_VkVideoEncodeAV1SessionCreateInfoKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - useMaxLevel = copy_src.useMaxLevel; - maxLevel = copy_src.maxLevel; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeAV1SessionCreateInfoKHR::~safe_VkVideoEncodeAV1SessionCreateInfoKHR() { FreePnextChain(pNext); } - -void safe_VkVideoEncodeAV1SessionCreateInfoKHR::initialize(const VkVideoEncodeAV1SessionCreateInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - useMaxLevel = in_struct->useMaxLevel; - maxLevel = in_struct->maxLevel; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeAV1SessionCreateInfoKHR::initialize(const safe_VkVideoEncodeAV1SessionCreateInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - useMaxLevel = copy_src->useMaxLevel; - maxLevel = copy_src->maxLevel; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR( - const VkVideoEncodeAV1SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - pStdSequenceHeader(nullptr), - pStdDecoderModelInfo(nullptr), - stdOperatingPointCount(in_struct->stdOperatingPointCount), - pStdOperatingPoints(nullptr) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } - if (in_struct->pStdSequenceHeader) { - pStdSequenceHeader = new StdVideoAV1SequenceHeader(*in_struct->pStdSequenceHeader); - } - - if (in_struct->pStdDecoderModelInfo) { - pStdDecoderModelInfo = new StdVideoEncodeAV1DecoderModelInfo(*in_struct->pStdDecoderModelInfo); - } - - if (in_struct->pStdOperatingPoints) { - pStdOperatingPoints = new StdVideoEncodeAV1OperatingPointInfo[in_struct->stdOperatingPointCount]; - memcpy((void*)pStdOperatingPoints, (void*)in_struct->pStdOperatingPoints, - sizeof(StdVideoEncodeAV1OperatingPointInfo) * in_struct->stdOperatingPointCount); - } -} - -safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR), - pNext(nullptr), - pStdSequenceHeader(nullptr), - pStdDecoderModelInfo(nullptr), - stdOperatingPointCount(), - pStdOperatingPoints(nullptr) {} - -safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR( - const safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR& copy_src) { - sType = copy_src.sType; - pStdSequenceHeader = nullptr; - pStdDecoderModelInfo = nullptr; - stdOperatingPointCount = copy_src.stdOperatingPointCount; - pStdOperatingPoints = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdSequenceHeader) { - pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src.pStdSequenceHeader); - } - - if (copy_src.pStdDecoderModelInfo) { - pStdDecoderModelInfo = new StdVideoEncodeAV1DecoderModelInfo(*copy_src.pStdDecoderModelInfo); - } - - if (copy_src.pStdOperatingPoints) { - pStdOperatingPoints = new StdVideoEncodeAV1OperatingPointInfo[copy_src.stdOperatingPointCount]; - memcpy((void*)pStdOperatingPoints, (void*)copy_src.pStdOperatingPoints, - sizeof(StdVideoEncodeAV1OperatingPointInfo) * copy_src.stdOperatingPointCount); - } -} - -safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR& safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::operator=( - const safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR& copy_src) { +safe_VkCooperativeMatrixPropertiesKHR& safe_VkCooperativeMatrixPropertiesKHR::operator=( + const safe_VkCooperativeMatrixPropertiesKHR& copy_src) { if (©_src == this) return *this; - if (pStdSequenceHeader) delete pStdSequenceHeader; - if (pStdDecoderModelInfo) delete pStdDecoderModelInfo; - if (pStdOperatingPoints) delete[] pStdOperatingPoints; FreePnextChain(pNext); sType = copy_src.sType; - pStdSequenceHeader = nullptr; - pStdDecoderModelInfo = nullptr; - stdOperatingPointCount = copy_src.stdOperatingPointCount; - pStdOperatingPoints = nullptr; + MSize = copy_src.MSize; + NSize = copy_src.NSize; + KSize = copy_src.KSize; + AType = copy_src.AType; + BType = copy_src.BType; + CType = copy_src.CType; + ResultType = copy_src.ResultType; + saturatingAccumulation = copy_src.saturatingAccumulation; + scope = copy_src.scope; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pStdSequenceHeader) { - pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src.pStdSequenceHeader); - } - - if (copy_src.pStdDecoderModelInfo) { - pStdDecoderModelInfo = new StdVideoEncodeAV1DecoderModelInfo(*copy_src.pStdDecoderModelInfo); - } - - if (copy_src.pStdOperatingPoints) { - pStdOperatingPoints = new StdVideoEncodeAV1OperatingPointInfo[copy_src.stdOperatingPointCount]; - memcpy((void*)pStdOperatingPoints, (void*)copy_src.pStdOperatingPoints, - sizeof(StdVideoEncodeAV1OperatingPointInfo) * copy_src.stdOperatingPointCount); - } - return *this; } -safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::~safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR() { - if (pStdSequenceHeader) delete pStdSequenceHeader; - if (pStdDecoderModelInfo) delete pStdDecoderModelInfo; - if (pStdOperatingPoints) delete[] pStdOperatingPoints; - FreePnextChain(pNext); -} +safe_VkCooperativeMatrixPropertiesKHR::~safe_VkCooperativeMatrixPropertiesKHR() { FreePnextChain(pNext); } -void safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::initialize( - const VkVideoEncodeAV1SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - if (pStdSequenceHeader) delete pStdSequenceHeader; - if (pStdDecoderModelInfo) delete pStdDecoderModelInfo; - if (pStdOperatingPoints) delete[] pStdOperatingPoints; +void safe_VkCooperativeMatrixPropertiesKHR::initialize(const VkCooperativeMatrixPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - pStdSequenceHeader = nullptr; - pStdDecoderModelInfo = nullptr; - stdOperatingPointCount = in_struct->stdOperatingPointCount; - pStdOperatingPoints = nullptr; + MSize = in_struct->MSize; + NSize = in_struct->NSize; + KSize = in_struct->KSize; + AType = in_struct->AType; + BType = in_struct->BType; + CType = in_struct->CType; + ResultType = in_struct->ResultType; + saturatingAccumulation = in_struct->saturatingAccumulation; + scope = in_struct->scope; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pStdSequenceHeader) { - pStdSequenceHeader = new StdVideoAV1SequenceHeader(*in_struct->pStdSequenceHeader); - } - - if (in_struct->pStdDecoderModelInfo) { - pStdDecoderModelInfo = new StdVideoEncodeAV1DecoderModelInfo(*in_struct->pStdDecoderModelInfo); - } - - if (in_struct->pStdOperatingPoints) { - pStdOperatingPoints = new StdVideoEncodeAV1OperatingPointInfo[in_struct->stdOperatingPointCount]; - memcpy((void*)pStdOperatingPoints, (void*)in_struct->pStdOperatingPoints, - sizeof(StdVideoEncodeAV1OperatingPointInfo) * in_struct->stdOperatingPointCount); - } } -void safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::initialize( - const safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkCooperativeMatrixPropertiesKHR::initialize(const safe_VkCooperativeMatrixPropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - pStdSequenceHeader = nullptr; - pStdDecoderModelInfo = nullptr; - stdOperatingPointCount = copy_src->stdOperatingPointCount; - pStdOperatingPoints = nullptr; + MSize = copy_src->MSize; + NSize = copy_src->NSize; + KSize = copy_src->KSize; + AType = copy_src->AType; + BType = copy_src->BType; + CType = copy_src->CType; + ResultType = copy_src->ResultType; + saturatingAccumulation = copy_src->saturatingAccumulation; + scope = copy_src->scope; pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pStdSequenceHeader) { - pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src->pStdSequenceHeader); - } - - if (copy_src->pStdDecoderModelInfo) { - pStdDecoderModelInfo = new StdVideoEncodeAV1DecoderModelInfo(*copy_src->pStdDecoderModelInfo); - } - - if (copy_src->pStdOperatingPoints) { - pStdOperatingPoints = new StdVideoEncodeAV1OperatingPointInfo[copy_src->stdOperatingPointCount]; - memcpy((void*)pStdOperatingPoints, (void*)copy_src->pStdOperatingPoints, - sizeof(StdVideoEncodeAV1OperatingPointInfo) * copy_src->stdOperatingPointCount); - } } -safe_VkVideoEncodeAV1PictureInfoKHR::safe_VkVideoEncodeAV1PictureInfoKHR(const VkVideoEncodeAV1PictureInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) +safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR( + const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), - predictionMode(in_struct->predictionMode), - rateControlGroup(in_struct->rateControlGroup), - constantQIndex(in_struct->constantQIndex), - pStdPictureInfo(nullptr), - primaryReferenceCdfOnly(in_struct->primaryReferenceCdfOnly), - generateObuExtensionHeader(in_struct->generateObuExtensionHeader) { + cooperativeMatrix(in_struct->cooperativeMatrix), + cooperativeMatrixRobustBufferAccess(in_struct->cooperativeMatrixRobustBufferAccess) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pStdPictureInfo) { - pStdPictureInfo = new StdVideoEncodeAV1PictureInfo(*in_struct->pStdPictureInfo); - } - - for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { - referenceNameSlotIndices[i] = in_struct->referenceNameSlotIndices[i]; - } } -safe_VkVideoEncodeAV1PictureInfoKHR::safe_VkVideoEncodeAV1PictureInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR), +safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR), pNext(nullptr), - predictionMode(), - rateControlGroup(), - constantQIndex(), - pStdPictureInfo(nullptr), - primaryReferenceCdfOnly(), - generateObuExtensionHeader() {} + cooperativeMatrix(), + cooperativeMatrixRobustBufferAccess() {} -safe_VkVideoEncodeAV1PictureInfoKHR::safe_VkVideoEncodeAV1PictureInfoKHR(const safe_VkVideoEncodeAV1PictureInfoKHR& copy_src) { +safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR( + const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src) { sType = copy_src.sType; - predictionMode = copy_src.predictionMode; - rateControlGroup = copy_src.rateControlGroup; - constantQIndex = copy_src.constantQIndex; - pStdPictureInfo = nullptr; - primaryReferenceCdfOnly = copy_src.primaryReferenceCdfOnly; - generateObuExtensionHeader = copy_src.generateObuExtensionHeader; + cooperativeMatrix = copy_src.cooperativeMatrix; + cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess; pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdPictureInfo) { - pStdPictureInfo = new StdVideoEncodeAV1PictureInfo(*copy_src.pStdPictureInfo); - } - - for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { - referenceNameSlotIndices[i] = copy_src.referenceNameSlotIndices[i]; - } } -safe_VkVideoEncodeAV1PictureInfoKHR& safe_VkVideoEncodeAV1PictureInfoKHR::operator=( - const safe_VkVideoEncodeAV1PictureInfoKHR& copy_src) { +safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::operator=( + const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src) { if (©_src == this) return *this; - if (pStdPictureInfo) delete pStdPictureInfo; FreePnextChain(pNext); sType = copy_src.sType; - predictionMode = copy_src.predictionMode; - rateControlGroup = copy_src.rateControlGroup; - constantQIndex = copy_src.constantQIndex; - pStdPictureInfo = nullptr; - primaryReferenceCdfOnly = copy_src.primaryReferenceCdfOnly; - generateObuExtensionHeader = copy_src.generateObuExtensionHeader; + cooperativeMatrix = copy_src.cooperativeMatrix; + cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pStdPictureInfo) { - pStdPictureInfo = new StdVideoEncodeAV1PictureInfo(*copy_src.pStdPictureInfo); - } - - for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { - referenceNameSlotIndices[i] = copy_src.referenceNameSlotIndices[i]; - } - return *this; } -safe_VkVideoEncodeAV1PictureInfoKHR::~safe_VkVideoEncodeAV1PictureInfoKHR() { - if (pStdPictureInfo) delete pStdPictureInfo; - FreePnextChain(pNext); -} +safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::~safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR() { FreePnextChain(pNext); } -void safe_VkVideoEncodeAV1PictureInfoKHR::initialize(const VkVideoEncodeAV1PictureInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pStdPictureInfo) delete pStdPictureInfo; +void safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - predictionMode = in_struct->predictionMode; - rateControlGroup = in_struct->rateControlGroup; - constantQIndex = in_struct->constantQIndex; - pStdPictureInfo = nullptr; - primaryReferenceCdfOnly = in_struct->primaryReferenceCdfOnly; - generateObuExtensionHeader = in_struct->generateObuExtensionHeader; + cooperativeMatrix = in_struct->cooperativeMatrix; + cooperativeMatrixRobustBufferAccess = in_struct->cooperativeMatrixRobustBufferAccess; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pStdPictureInfo) { - pStdPictureInfo = new StdVideoEncodeAV1PictureInfo(*in_struct->pStdPictureInfo); - } - - for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { - referenceNameSlotIndices[i] = in_struct->referenceNameSlotIndices[i]; - } } -void safe_VkVideoEncodeAV1PictureInfoKHR::initialize(const safe_VkVideoEncodeAV1PictureInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::initialize( + const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - predictionMode = copy_src->predictionMode; - rateControlGroup = copy_src->rateControlGroup; - constantQIndex = copy_src->constantQIndex; - pStdPictureInfo = nullptr; - primaryReferenceCdfOnly = copy_src->primaryReferenceCdfOnly; - generateObuExtensionHeader = copy_src->generateObuExtensionHeader; + cooperativeMatrix = copy_src->cooperativeMatrix; + cooperativeMatrixRobustBufferAccess = copy_src->cooperativeMatrixRobustBufferAccess; pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pStdPictureInfo) { - pStdPictureInfo = new StdVideoEncodeAV1PictureInfo(*copy_src->pStdPictureInfo); - } - - for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { - referenceNameSlotIndices[i] = copy_src->referenceNameSlotIndices[i]; - } } -safe_VkVideoEncodeAV1DpbSlotInfoKHR::safe_VkVideoEncodeAV1DpbSlotInfoKHR(const VkVideoEncodeAV1DpbSlotInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), pStdReferenceInfo(nullptr) { +safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR( + const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), cooperativeMatrixSupportedStages(in_struct->cooperativeMatrixSupportedStages) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoEncodeAV1ReferenceInfo(*in_struct->pStdReferenceInfo); - } } -safe_VkVideoEncodeAV1DpbSlotInfoKHR::safe_VkVideoEncodeAV1DpbSlotInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {} +safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR), + pNext(nullptr), + cooperativeMatrixSupportedStages() {} -safe_VkVideoEncodeAV1DpbSlotInfoKHR::safe_VkVideoEncodeAV1DpbSlotInfoKHR(const safe_VkVideoEncodeAV1DpbSlotInfoKHR& copy_src) { +safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR( + const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src) { sType = copy_src.sType; - pStdReferenceInfo = nullptr; + cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages; pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoEncodeAV1ReferenceInfo(*copy_src.pStdReferenceInfo); - } } -safe_VkVideoEncodeAV1DpbSlotInfoKHR& safe_VkVideoEncodeAV1DpbSlotInfoKHR::operator=( - const safe_VkVideoEncodeAV1DpbSlotInfoKHR& copy_src) { +safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::operator=( + const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src) { if (©_src == this) return *this; - if (pStdReferenceInfo) delete pStdReferenceInfo; FreePnextChain(pNext); sType = copy_src.sType; - pStdReferenceInfo = nullptr; + cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoEncodeAV1ReferenceInfo(*copy_src.pStdReferenceInfo); - } - return *this; } -safe_VkVideoEncodeAV1DpbSlotInfoKHR::~safe_VkVideoEncodeAV1DpbSlotInfoKHR() { - if (pStdReferenceInfo) delete pStdReferenceInfo; +safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::~safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR() { FreePnextChain(pNext); } -void safe_VkVideoEncodeAV1DpbSlotInfoKHR::initialize(const VkVideoEncodeAV1DpbSlotInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pStdReferenceInfo) delete pStdReferenceInfo; +void safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::initialize( + const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - pStdReferenceInfo = nullptr; + cooperativeMatrixSupportedStages = in_struct->cooperativeMatrixSupportedStages; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoEncodeAV1ReferenceInfo(*in_struct->pStdReferenceInfo); - } } -void safe_VkVideoEncodeAV1DpbSlotInfoKHR::initialize(const safe_VkVideoEncodeAV1DpbSlotInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::initialize( + const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - pStdReferenceInfo = nullptr; + cooperativeMatrixSupportedStages = copy_src->cooperativeMatrixSupportedStages; pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoEncodeAV1ReferenceInfo(*copy_src->pStdReferenceInfo); - } } -safe_VkVideoEncodeAV1ProfileInfoKHR::safe_VkVideoEncodeAV1ProfileInfoKHR(const VkVideoEncodeAV1ProfileInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), stdProfile(in_struct->stdProfile) { +safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR( + const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + computeDerivativeGroupQuads(in_struct->computeDerivativeGroupQuads), + computeDerivativeGroupLinear(in_struct->computeDerivativeGroupLinear) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkVideoEncodeAV1ProfileInfoKHR::safe_VkVideoEncodeAV1ProfileInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR), pNext(nullptr), stdProfile() {} +safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR), + pNext(nullptr), + computeDerivativeGroupQuads(), + computeDerivativeGroupLinear() {} -safe_VkVideoEncodeAV1ProfileInfoKHR::safe_VkVideoEncodeAV1ProfileInfoKHR(const safe_VkVideoEncodeAV1ProfileInfoKHR& copy_src) { +safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR( + const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR& copy_src) { sType = copy_src.sType; - stdProfile = copy_src.stdProfile; + computeDerivativeGroupQuads = copy_src.computeDerivativeGroupQuads; + computeDerivativeGroupLinear = copy_src.computeDerivativeGroupLinear; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkVideoEncodeAV1ProfileInfoKHR& safe_VkVideoEncodeAV1ProfileInfoKHR::operator=( - const safe_VkVideoEncodeAV1ProfileInfoKHR& copy_src) { +safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR& safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::operator=( + const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - stdProfile = copy_src.stdProfile; + computeDerivativeGroupQuads = copy_src.computeDerivativeGroupQuads; + computeDerivativeGroupLinear = copy_src.computeDerivativeGroupLinear; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkVideoEncodeAV1ProfileInfoKHR::~safe_VkVideoEncodeAV1ProfileInfoKHR() { FreePnextChain(pNext); } +safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::~safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR() { + FreePnextChain(pNext); +} -void safe_VkVideoEncodeAV1ProfileInfoKHR::initialize(const VkVideoEncodeAV1ProfileInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::initialize( + const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - stdProfile = in_struct->stdProfile; + computeDerivativeGroupQuads = in_struct->computeDerivativeGroupQuads; + computeDerivativeGroupLinear = in_struct->computeDerivativeGroupLinear; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkVideoEncodeAV1ProfileInfoKHR::initialize(const safe_VkVideoEncodeAV1ProfileInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::initialize( + const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - stdProfile = copy_src->stdProfile; + computeDerivativeGroupQuads = copy_src->computeDerivativeGroupQuads; + computeDerivativeGroupLinear = copy_src->computeDerivativeGroupLinear; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR( - const VkVideoEncodeAV1GopRemainingFrameInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - useGopRemainingFrames(in_struct->useGopRemainingFrames), - gopRemainingIntra(in_struct->gopRemainingIntra), - gopRemainingPredictive(in_struct->gopRemainingPredictive), - gopRemainingBipredictive(in_struct->gopRemainingBipredictive) { +safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR( + const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), meshAndTaskShaderDerivatives(in_struct->meshAndTaskShaderDerivatives) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR), +safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR), pNext(nullptr), - useGopRemainingFrames(), - gopRemainingIntra(), - gopRemainingPredictive(), - gopRemainingBipredictive() {} + meshAndTaskShaderDerivatives() {} -safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR( - const safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR& copy_src) { +safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR( + const safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR& copy_src) { sType = copy_src.sType; - useGopRemainingFrames = copy_src.useGopRemainingFrames; - gopRemainingIntra = copy_src.gopRemainingIntra; - gopRemainingPredictive = copy_src.gopRemainingPredictive; - gopRemainingBipredictive = copy_src.gopRemainingBipredictive; + meshAndTaskShaderDerivatives = copy_src.meshAndTaskShaderDerivatives; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR& safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::operator=( - const safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR& copy_src) { +safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR& safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::operator=( + const safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - useGopRemainingFrames = copy_src.useGopRemainingFrames; - gopRemainingIntra = copy_src.gopRemainingIntra; - gopRemainingPredictive = copy_src.gopRemainingPredictive; - gopRemainingBipredictive = copy_src.gopRemainingBipredictive; + meshAndTaskShaderDerivatives = copy_src.meshAndTaskShaderDerivatives; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::~safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR() { FreePnextChain(pNext); } +safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::~safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR() { + FreePnextChain(pNext); +} -void safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::initialize(const VkVideoEncodeAV1GopRemainingFrameInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::initialize( + const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - useGopRemainingFrames = in_struct->useGopRemainingFrames; - gopRemainingIntra = in_struct->gopRemainingIntra; - gopRemainingPredictive = in_struct->gopRemainingPredictive; - gopRemainingBipredictive = in_struct->gopRemainingBipredictive; + meshAndTaskShaderDerivatives = in_struct->meshAndTaskShaderDerivatives; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::initialize(const safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::initialize( + const safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - useGopRemainingFrames = copy_src->useGopRemainingFrames; - gopRemainingIntra = copy_src->gopRemainingIntra; - gopRemainingPredictive = copy_src->gopRemainingPredictive; - gopRemainingBipredictive = copy_src->gopRemainingBipredictive; + meshAndTaskShaderDerivatives = copy_src->meshAndTaskShaderDerivatives; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkVideoEncodeAV1RateControlInfoKHR::safe_VkVideoEncodeAV1RateControlInfoKHR( - const VkVideoEncodeAV1RateControlInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - flags(in_struct->flags), - gopFrameCount(in_struct->gopFrameCount), - keyFramePeriod(in_struct->keyFramePeriod), - consecutiveBipredictiveFrameCount(in_struct->consecutiveBipredictiveFrameCount), - temporalLayerCount(in_struct->temporalLayerCount) { +safe_VkVideoDecodeAV1ProfileInfoKHR::safe_VkVideoDecodeAV1ProfileInfoKHR(const VkVideoDecodeAV1ProfileInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), stdProfile(in_struct->stdProfile), filmGrainSupport(in_struct->filmGrainSupport) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkVideoEncodeAV1RateControlInfoKHR::safe_VkVideoEncodeAV1RateControlInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR), - pNext(nullptr), - flags(), - gopFrameCount(), - keyFramePeriod(), - consecutiveBipredictiveFrameCount(), - temporalLayerCount() {} +safe_VkVideoDecodeAV1ProfileInfoKHR::safe_VkVideoDecodeAV1ProfileInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR), pNext(nullptr), stdProfile(), filmGrainSupport() {} -safe_VkVideoEncodeAV1RateControlInfoKHR::safe_VkVideoEncodeAV1RateControlInfoKHR( - const safe_VkVideoEncodeAV1RateControlInfoKHR& copy_src) { +safe_VkVideoDecodeAV1ProfileInfoKHR::safe_VkVideoDecodeAV1ProfileInfoKHR(const safe_VkVideoDecodeAV1ProfileInfoKHR& copy_src) { sType = copy_src.sType; - flags = copy_src.flags; - gopFrameCount = copy_src.gopFrameCount; - keyFramePeriod = copy_src.keyFramePeriod; - consecutiveBipredictiveFrameCount = copy_src.consecutiveBipredictiveFrameCount; - temporalLayerCount = copy_src.temporalLayerCount; + stdProfile = copy_src.stdProfile; + filmGrainSupport = copy_src.filmGrainSupport; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkVideoEncodeAV1RateControlInfoKHR& safe_VkVideoEncodeAV1RateControlInfoKHR::operator=( - const safe_VkVideoEncodeAV1RateControlInfoKHR& copy_src) { +safe_VkVideoDecodeAV1ProfileInfoKHR& safe_VkVideoDecodeAV1ProfileInfoKHR::operator=( + const safe_VkVideoDecodeAV1ProfileInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - flags = copy_src.flags; - gopFrameCount = copy_src.gopFrameCount; - keyFramePeriod = copy_src.keyFramePeriod; - consecutiveBipredictiveFrameCount = copy_src.consecutiveBipredictiveFrameCount; - temporalLayerCount = copy_src.temporalLayerCount; + stdProfile = copy_src.stdProfile; + filmGrainSupport = copy_src.filmGrainSupport; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkVideoEncodeAV1RateControlInfoKHR::~safe_VkVideoEncodeAV1RateControlInfoKHR() { FreePnextChain(pNext); } +safe_VkVideoDecodeAV1ProfileInfoKHR::~safe_VkVideoDecodeAV1ProfileInfoKHR() { FreePnextChain(pNext); } -void safe_VkVideoEncodeAV1RateControlInfoKHR::initialize(const VkVideoEncodeAV1RateControlInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoDecodeAV1ProfileInfoKHR::initialize(const VkVideoDecodeAV1ProfileInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - flags = in_struct->flags; - gopFrameCount = in_struct->gopFrameCount; - keyFramePeriod = in_struct->keyFramePeriod; - consecutiveBipredictiveFrameCount = in_struct->consecutiveBipredictiveFrameCount; - temporalLayerCount = in_struct->temporalLayerCount; + stdProfile = in_struct->stdProfile; + filmGrainSupport = in_struct->filmGrainSupport; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkVideoEncodeAV1RateControlInfoKHR::initialize(const safe_VkVideoEncodeAV1RateControlInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoDecodeAV1ProfileInfoKHR::initialize(const safe_VkVideoDecodeAV1ProfileInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - flags = copy_src->flags; - gopFrameCount = copy_src->gopFrameCount; - keyFramePeriod = copy_src->keyFramePeriod; - consecutiveBipredictiveFrameCount = copy_src->consecutiveBipredictiveFrameCount; - temporalLayerCount = copy_src->temporalLayerCount; + stdProfile = copy_src->stdProfile; + filmGrainSupport = copy_src->filmGrainSupport; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkVideoEncodeAV1RateControlLayerInfoKHR::safe_VkVideoEncodeAV1RateControlLayerInfoKHR( - const VkVideoEncodeAV1RateControlLayerInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - useMinQIndex(in_struct->useMinQIndex), - minQIndex(in_struct->minQIndex), - useMaxQIndex(in_struct->useMaxQIndex), - maxQIndex(in_struct->maxQIndex), - useMaxFrameSize(in_struct->useMaxFrameSize), - maxFrameSize(in_struct->maxFrameSize) { +safe_VkVideoDecodeAV1CapabilitiesKHR::safe_VkVideoDecodeAV1CapabilitiesKHR(const VkVideoDecodeAV1CapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), maxLevel(in_struct->maxLevel) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkVideoEncodeAV1RateControlLayerInfoKHR::safe_VkVideoEncodeAV1RateControlLayerInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR), - pNext(nullptr), - useMinQIndex(), - minQIndex(), - useMaxQIndex(), - maxQIndex(), - useMaxFrameSize(), - maxFrameSize() {} +safe_VkVideoDecodeAV1CapabilitiesKHR::safe_VkVideoDecodeAV1CapabilitiesKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR), pNext(nullptr), maxLevel() {} -safe_VkVideoEncodeAV1RateControlLayerInfoKHR::safe_VkVideoEncodeAV1RateControlLayerInfoKHR( - const safe_VkVideoEncodeAV1RateControlLayerInfoKHR& copy_src) { - sType = copy_src.sType; - useMinQIndex = copy_src.useMinQIndex; - minQIndex = copy_src.minQIndex; - useMaxQIndex = copy_src.useMaxQIndex; - maxQIndex = copy_src.maxQIndex; - useMaxFrameSize = copy_src.useMaxFrameSize; - maxFrameSize = copy_src.maxFrameSize; +safe_VkVideoDecodeAV1CapabilitiesKHR::safe_VkVideoDecodeAV1CapabilitiesKHR(const safe_VkVideoDecodeAV1CapabilitiesKHR& copy_src) { + sType = copy_src.sType; + maxLevel = copy_src.maxLevel; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkVideoEncodeAV1RateControlLayerInfoKHR& safe_VkVideoEncodeAV1RateControlLayerInfoKHR::operator=( - const safe_VkVideoEncodeAV1RateControlLayerInfoKHR& copy_src) { +safe_VkVideoDecodeAV1CapabilitiesKHR& safe_VkVideoDecodeAV1CapabilitiesKHR::operator=( + const safe_VkVideoDecodeAV1CapabilitiesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - useMinQIndex = copy_src.useMinQIndex; - minQIndex = copy_src.minQIndex; - useMaxQIndex = copy_src.useMaxQIndex; - maxQIndex = copy_src.maxQIndex; - useMaxFrameSize = copy_src.useMaxFrameSize; - maxFrameSize = copy_src.maxFrameSize; + maxLevel = copy_src.maxLevel; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkVideoEncodeAV1RateControlLayerInfoKHR::~safe_VkVideoEncodeAV1RateControlLayerInfoKHR() { FreePnextChain(pNext); } +safe_VkVideoDecodeAV1CapabilitiesKHR::~safe_VkVideoDecodeAV1CapabilitiesKHR() { FreePnextChain(pNext); } -void safe_VkVideoEncodeAV1RateControlLayerInfoKHR::initialize(const VkVideoEncodeAV1RateControlLayerInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoDecodeAV1CapabilitiesKHR::initialize(const VkVideoDecodeAV1CapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - useMinQIndex = in_struct->useMinQIndex; - minQIndex = in_struct->minQIndex; - useMaxQIndex = in_struct->useMaxQIndex; - maxQIndex = in_struct->maxQIndex; - useMaxFrameSize = in_struct->useMaxFrameSize; - maxFrameSize = in_struct->maxFrameSize; + maxLevel = in_struct->maxLevel; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkVideoEncodeAV1RateControlLayerInfoKHR::initialize(const safe_VkVideoEncodeAV1RateControlLayerInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoDecodeAV1CapabilitiesKHR::initialize(const safe_VkVideoDecodeAV1CapabilitiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - useMinQIndex = copy_src->useMinQIndex; - minQIndex = copy_src->minQIndex; - useMaxQIndex = copy_src->useMaxQIndex; - maxQIndex = copy_src->maxQIndex; - useMaxFrameSize = copy_src->useMaxFrameSize; - maxFrameSize = copy_src->maxFrameSize; + maxLevel = copy_src->maxLevel; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR( - const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), videoMaintenance1(in_struct->videoMaintenance1) { +safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR( + const VkVideoDecodeAV1SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pStdSequenceHeader(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + if (in_struct->pStdSequenceHeader) { + pStdSequenceHeader = new StdVideoAV1SequenceHeader(*in_struct->pStdSequenceHeader); + } } -safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR), pNext(nullptr), videoMaintenance1() {} +safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR), pNext(nullptr), pStdSequenceHeader(nullptr) {} -safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR( - const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src) { +safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR( + const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& copy_src) { sType = copy_src.sType; - videoMaintenance1 = copy_src.videoMaintenance1; + pStdSequenceHeader = nullptr; pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdSequenceHeader) { + pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src.pStdSequenceHeader); + } } -safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::operator=( - const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src) { +safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::operator=( + const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& copy_src) { if (©_src == this) return *this; + if (pStdSequenceHeader) delete pStdSequenceHeader; FreePnextChain(pNext); sType = copy_src.sType; - videoMaintenance1 = copy_src.videoMaintenance1; + pStdSequenceHeader = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pStdSequenceHeader) { + pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src.pStdSequenceHeader); + } + return *this; } -safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::~safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR() { FreePnextChain(pNext); } +safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::~safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR() { + if (pStdSequenceHeader) delete pStdSequenceHeader; + FreePnextChain(pNext); +} -void safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::initialize(const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::initialize( + const VkVideoDecodeAV1SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdSequenceHeader) delete pStdSequenceHeader; FreePnextChain(pNext); sType = in_struct->sType; - videoMaintenance1 = in_struct->videoMaintenance1; + pStdSequenceHeader = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pStdSequenceHeader) { + pStdSequenceHeader = new StdVideoAV1SequenceHeader(*in_struct->pStdSequenceHeader); + } } -void safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::initialize( - const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::initialize( + const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - videoMaintenance1 = copy_src->videoMaintenance1; + pStdSequenceHeader = nullptr; pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdSequenceHeader) { + pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src->pStdSequenceHeader); + } } -safe_VkVideoInlineQueryInfoKHR::safe_VkVideoInlineQueryInfoKHR(const VkVideoInlineQueryInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkVideoDecodeAV1PictureInfoKHR::safe_VkVideoDecodeAV1PictureInfoKHR(const VkVideoDecodeAV1PictureInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) : sType(in_struct->sType), - queryPool(in_struct->queryPool), - firstQuery(in_struct->firstQuery), - queryCount(in_struct->queryCount) { + pStdPictureInfo(nullptr), + frameHeaderOffset(in_struct->frameHeaderOffset), + tileCount(in_struct->tileCount), + pTileOffsets(nullptr), + pTileSizes(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + if (in_struct->pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*in_struct->pStdPictureInfo); + } + + for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = in_struct->referenceNameSlotIndices[i]; + } + + if (in_struct->pTileOffsets) { + pTileOffsets = new uint32_t[in_struct->tileCount]; + memcpy((void*)pTileOffsets, (void*)in_struct->pTileOffsets, sizeof(uint32_t) * in_struct->tileCount); + } + + if (in_struct->pTileSizes) { + pTileSizes = new uint32_t[in_struct->tileCount]; + memcpy((void*)pTileSizes, (void*)in_struct->pTileSizes, sizeof(uint32_t) * in_struct->tileCount); + } } -safe_VkVideoInlineQueryInfoKHR::safe_VkVideoInlineQueryInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR), pNext(nullptr), queryPool(), firstQuery(), queryCount() {} +safe_VkVideoDecodeAV1PictureInfoKHR::safe_VkVideoDecodeAV1PictureInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR), + pNext(nullptr), + pStdPictureInfo(nullptr), + frameHeaderOffset(), + tileCount(), + pTileOffsets(nullptr), + pTileSizes(nullptr) {} -safe_VkVideoInlineQueryInfoKHR::safe_VkVideoInlineQueryInfoKHR(const safe_VkVideoInlineQueryInfoKHR& copy_src) { +safe_VkVideoDecodeAV1PictureInfoKHR::safe_VkVideoDecodeAV1PictureInfoKHR(const safe_VkVideoDecodeAV1PictureInfoKHR& copy_src) { sType = copy_src.sType; - queryPool = copy_src.queryPool; - firstQuery = copy_src.firstQuery; - queryCount = copy_src.queryCount; + pStdPictureInfo = nullptr; + frameHeaderOffset = copy_src.frameHeaderOffset; + tileCount = copy_src.tileCount; + pTileOffsets = nullptr; + pTileSizes = nullptr; pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*copy_src.pStdPictureInfo); + } + + for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = copy_src.referenceNameSlotIndices[i]; + } + + if (copy_src.pTileOffsets) { + pTileOffsets = new uint32_t[copy_src.tileCount]; + memcpy((void*)pTileOffsets, (void*)copy_src.pTileOffsets, sizeof(uint32_t) * copy_src.tileCount); + } + + if (copy_src.pTileSizes) { + pTileSizes = new uint32_t[copy_src.tileCount]; + memcpy((void*)pTileSizes, (void*)copy_src.pTileSizes, sizeof(uint32_t) * copy_src.tileCount); + } } -safe_VkVideoInlineQueryInfoKHR& safe_VkVideoInlineQueryInfoKHR::operator=(const safe_VkVideoInlineQueryInfoKHR& copy_src) { +safe_VkVideoDecodeAV1PictureInfoKHR& safe_VkVideoDecodeAV1PictureInfoKHR::operator=( + const safe_VkVideoDecodeAV1PictureInfoKHR& copy_src) { if (©_src == this) return *this; + if (pStdPictureInfo) delete pStdPictureInfo; + if (pTileOffsets) delete[] pTileOffsets; + if (pTileSizes) delete[] pTileSizes; FreePnextChain(pNext); sType = copy_src.sType; - queryPool = copy_src.queryPool; - firstQuery = copy_src.firstQuery; - queryCount = copy_src.queryCount; + pStdPictureInfo = nullptr; + frameHeaderOffset = copy_src.frameHeaderOffset; + tileCount = copy_src.tileCount; + pTileOffsets = nullptr; + pTileSizes = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*copy_src.pStdPictureInfo); + } + + for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = copy_src.referenceNameSlotIndices[i]; + } + + if (copy_src.pTileOffsets) { + pTileOffsets = new uint32_t[copy_src.tileCount]; + memcpy((void*)pTileOffsets, (void*)copy_src.pTileOffsets, sizeof(uint32_t) * copy_src.tileCount); + } + + if (copy_src.pTileSizes) { + pTileSizes = new uint32_t[copy_src.tileCount]; + memcpy((void*)pTileSizes, (void*)copy_src.pTileSizes, sizeof(uint32_t) * copy_src.tileCount); + } + return *this; } -safe_VkVideoInlineQueryInfoKHR::~safe_VkVideoInlineQueryInfoKHR() { FreePnextChain(pNext); } +safe_VkVideoDecodeAV1PictureInfoKHR::~safe_VkVideoDecodeAV1PictureInfoKHR() { + if (pStdPictureInfo) delete pStdPictureInfo; + if (pTileOffsets) delete[] pTileOffsets; + if (pTileSizes) delete[] pTileSizes; + FreePnextChain(pNext); +} -void safe_VkVideoInlineQueryInfoKHR::initialize(const VkVideoInlineQueryInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoDecodeAV1PictureInfoKHR::initialize(const VkVideoDecodeAV1PictureInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdPictureInfo) delete pStdPictureInfo; + if (pTileOffsets) delete[] pTileOffsets; + if (pTileSizes) delete[] pTileSizes; FreePnextChain(pNext); sType = in_struct->sType; - queryPool = in_struct->queryPool; - firstQuery = in_struct->firstQuery; - queryCount = in_struct->queryCount; + pStdPictureInfo = nullptr; + frameHeaderOffset = in_struct->frameHeaderOffset; + tileCount = in_struct->tileCount; + pTileOffsets = nullptr; + pTileSizes = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*in_struct->pStdPictureInfo); + } + + for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = in_struct->referenceNameSlotIndices[i]; + } + + if (in_struct->pTileOffsets) { + pTileOffsets = new uint32_t[in_struct->tileCount]; + memcpy((void*)pTileOffsets, (void*)in_struct->pTileOffsets, sizeof(uint32_t) * in_struct->tileCount); + } + + if (in_struct->pTileSizes) { + pTileSizes = new uint32_t[in_struct->tileCount]; + memcpy((void*)pTileSizes, (void*)in_struct->pTileSizes, sizeof(uint32_t) * in_struct->tileCount); + } } -void safe_VkVideoInlineQueryInfoKHR::initialize(const safe_VkVideoInlineQueryInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - queryPool = copy_src->queryPool; - firstQuery = copy_src->firstQuery; - queryCount = copy_src->queryCount; - pNext = SafePnextCopy(copy_src->pNext); +void safe_VkVideoDecodeAV1PictureInfoKHR::initialize(const safe_VkVideoDecodeAV1PictureInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pStdPictureInfo = nullptr; + frameHeaderOffset = copy_src->frameHeaderOffset; + tileCount = copy_src->tileCount; + pTileOffsets = nullptr; + pTileSizes = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*copy_src->pStdPictureInfo); + } + + for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = copy_src->referenceNameSlotIndices[i]; + } + + if (copy_src->pTileOffsets) { + pTileOffsets = new uint32_t[copy_src->tileCount]; + memcpy((void*)pTileOffsets, (void*)copy_src->pTileOffsets, sizeof(uint32_t) * copy_src->tileCount); + } + + if (copy_src->pTileSizes) { + pTileSizes = new uint32_t[copy_src->tileCount]; + memcpy((void*)pTileSizes, (void*)copy_src->pTileSizes, sizeof(uint32_t) * copy_src->tileCount); + } } -safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR( - const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), - maxVertexAttribDivisor(in_struct->maxVertexAttribDivisor), - supportsNonZeroFirstInstance(in_struct->supportsNonZeroFirstInstance) { +safe_VkVideoDecodeAV1DpbSlotInfoKHR::safe_VkVideoDecodeAV1DpbSlotInfoKHR(const VkVideoDecodeAV1DpbSlotInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), pStdReferenceInfo(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + if (in_struct->pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*in_struct->pStdReferenceInfo); + } } -safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR), - pNext(nullptr), - maxVertexAttribDivisor(), - supportsNonZeroFirstInstance() {} +safe_VkVideoDecodeAV1DpbSlotInfoKHR::safe_VkVideoDecodeAV1DpbSlotInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {} -safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR( - const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src) { +safe_VkVideoDecodeAV1DpbSlotInfoKHR::safe_VkVideoDecodeAV1DpbSlotInfoKHR(const safe_VkVideoDecodeAV1DpbSlotInfoKHR& copy_src) { sType = copy_src.sType; - maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor; - supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*copy_src.pStdReferenceInfo); + } } -safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::operator=( - const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src) { +safe_VkVideoDecodeAV1DpbSlotInfoKHR& safe_VkVideoDecodeAV1DpbSlotInfoKHR::operator=( + const safe_VkVideoDecodeAV1DpbSlotInfoKHR& copy_src) { if (©_src == this) return *this; + if (pStdReferenceInfo) delete pStdReferenceInfo; FreePnextChain(pNext); sType = copy_src.sType; - maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor; - supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*copy_src.pStdReferenceInfo); + } + return *this; } -safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::~safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR() { +safe_VkVideoDecodeAV1DpbSlotInfoKHR::~safe_VkVideoDecodeAV1DpbSlotInfoKHR() { + if (pStdReferenceInfo) delete pStdReferenceInfo; FreePnextChain(pNext); } -void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::initialize( - const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoDecodeAV1DpbSlotInfoKHR::initialize(const VkVideoDecodeAV1DpbSlotInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdReferenceInfo) delete pStdReferenceInfo; FreePnextChain(pNext); sType = in_struct->sType; - maxVertexAttribDivisor = in_struct->maxVertexAttribDivisor; - supportsNonZeroFirstInstance = in_struct->supportsNonZeroFirstInstance; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*in_struct->pStdReferenceInfo); + } } -void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::initialize( - const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoDecodeAV1DpbSlotInfoKHR::initialize(const safe_VkVideoDecodeAV1DpbSlotInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - maxVertexAttribDivisor = copy_src->maxVertexAttribDivisor; - supportsNonZeroFirstInstance = copy_src->supportsNonZeroFirstInstance; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*copy_src->pStdReferenceInfo); + } } -safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::safe_VkPipelineVertexInputDivisorStateCreateInfoKHR( - const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), vertexBindingDivisorCount(in_struct->vertexBindingDivisorCount), pVertexBindingDivisors(nullptr) { +safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR( + const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), videoEncodeAV1(in_struct->videoEncodeAV1) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pVertexBindingDivisors) { - pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionKHR[in_struct->vertexBindingDivisorCount]; - memcpy((void*)pVertexBindingDivisors, (void*)in_struct->pVertexBindingDivisors, - sizeof(VkVertexInputBindingDivisorDescriptionKHR) * in_struct->vertexBindingDivisorCount); - } } -safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::safe_VkPipelineVertexInputDivisorStateCreateInfoKHR() - : sType(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR), - pNext(nullptr), - vertexBindingDivisorCount(), - pVertexBindingDivisors(nullptr) {} +safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR), pNext(nullptr), videoEncodeAV1() {} -safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::safe_VkPipelineVertexInputDivisorStateCreateInfoKHR( - const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src) { +safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR( + const safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& copy_src) { sType = copy_src.sType; - vertexBindingDivisorCount = copy_src.vertexBindingDivisorCount; - pVertexBindingDivisors = nullptr; + videoEncodeAV1 = copy_src.videoEncodeAV1; pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pVertexBindingDivisors) { - pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionKHR[copy_src.vertexBindingDivisorCount]; - memcpy((void*)pVertexBindingDivisors, (void*)copy_src.pVertexBindingDivisors, - sizeof(VkVertexInputBindingDivisorDescriptionKHR) * copy_src.vertexBindingDivisorCount); - } } -safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::operator=( - const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src) { +safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::operator=( + const safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& copy_src) { if (©_src == this) return *this; - if (pVertexBindingDivisors) delete[] pVertexBindingDivisors; FreePnextChain(pNext); sType = copy_src.sType; - vertexBindingDivisorCount = copy_src.vertexBindingDivisorCount; - pVertexBindingDivisors = nullptr; + videoEncodeAV1 = copy_src.videoEncodeAV1; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pVertexBindingDivisors) { - pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionKHR[copy_src.vertexBindingDivisorCount]; - memcpy((void*)pVertexBindingDivisors, (void*)copy_src.pVertexBindingDivisors, - sizeof(VkVertexInputBindingDivisorDescriptionKHR) * copy_src.vertexBindingDivisorCount); - } - return *this; } -safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::~safe_VkPipelineVertexInputDivisorStateCreateInfoKHR() { - if (pVertexBindingDivisors) delete[] pVertexBindingDivisors; - FreePnextChain(pNext); -} +safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::~safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR() { FreePnextChain(pNext); } -void safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::initialize( - const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - if (pVertexBindingDivisors) delete[] pVertexBindingDivisors; +void safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::initialize(const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - vertexBindingDivisorCount = in_struct->vertexBindingDivisorCount; - pVertexBindingDivisors = nullptr; + videoEncodeAV1 = in_struct->videoEncodeAV1; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pVertexBindingDivisors) { - pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionKHR[in_struct->vertexBindingDivisorCount]; - memcpy((void*)pVertexBindingDivisors, (void*)in_struct->pVertexBindingDivisors, - sizeof(VkVertexInputBindingDivisorDescriptionKHR) * in_struct->vertexBindingDivisorCount); - } } -void safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::initialize( - const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::initialize(const safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - vertexBindingDivisorCount = copy_src->vertexBindingDivisorCount; - pVertexBindingDivisors = nullptr; + videoEncodeAV1 = copy_src->videoEncodeAV1; pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pVertexBindingDivisors) { - pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionKHR[copy_src->vertexBindingDivisorCount]; - memcpy((void*)pVertexBindingDivisors, (void*)copy_src->pVertexBindingDivisors, - sizeof(VkVertexInputBindingDivisorDescriptionKHR) * copy_src->vertexBindingDivisorCount); - } } -safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR( - const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) +safe_VkVideoEncodeAV1CapabilitiesKHR::safe_VkVideoEncodeAV1CapabilitiesKHR(const VkVideoEncodeAV1CapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) : sType(in_struct->sType), - vertexAttributeInstanceRateDivisor(in_struct->vertexAttributeInstanceRateDivisor), - vertexAttributeInstanceRateZeroDivisor(in_struct->vertexAttributeInstanceRateZeroDivisor) { + flags(in_struct->flags), + maxLevel(in_struct->maxLevel), + codedPictureAlignment(in_struct->codedPictureAlignment), + maxTiles(in_struct->maxTiles), + minTileSize(in_struct->minTileSize), + maxTileSize(in_struct->maxTileSize), + superblockSizes(in_struct->superblockSizes), + maxSingleReferenceCount(in_struct->maxSingleReferenceCount), + singleReferenceNameMask(in_struct->singleReferenceNameMask), + maxUnidirectionalCompoundReferenceCount(in_struct->maxUnidirectionalCompoundReferenceCount), + maxUnidirectionalCompoundGroup1ReferenceCount(in_struct->maxUnidirectionalCompoundGroup1ReferenceCount), + unidirectionalCompoundReferenceNameMask(in_struct->unidirectionalCompoundReferenceNameMask), + maxBidirectionalCompoundReferenceCount(in_struct->maxBidirectionalCompoundReferenceCount), + maxBidirectionalCompoundGroup1ReferenceCount(in_struct->maxBidirectionalCompoundGroup1ReferenceCount), + maxBidirectionalCompoundGroup2ReferenceCount(in_struct->maxBidirectionalCompoundGroup2ReferenceCount), + bidirectionalCompoundReferenceNameMask(in_struct->bidirectionalCompoundReferenceNameMask), + maxTemporalLayerCount(in_struct->maxTemporalLayerCount), + maxSpatialLayerCount(in_struct->maxSpatialLayerCount), + maxOperatingPoints(in_struct->maxOperatingPoints), + minQIndex(in_struct->minQIndex), + maxQIndex(in_struct->maxQIndex), + prefersGopRemainingFrames(in_struct->prefersGopRemainingFrames), + requiresGopRemainingFrames(in_struct->requiresGopRemainingFrames), + stdSyntaxFlags(in_struct->stdSyntaxFlags) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR), +safe_VkVideoEncodeAV1CapabilitiesKHR::safe_VkVideoEncodeAV1CapabilitiesKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR), pNext(nullptr), - vertexAttributeInstanceRateDivisor(), - vertexAttributeInstanceRateZeroDivisor() {} + flags(), + maxLevel(), + codedPictureAlignment(), + maxTiles(), + minTileSize(), + maxTileSize(), + superblockSizes(), + maxSingleReferenceCount(), + singleReferenceNameMask(), + maxUnidirectionalCompoundReferenceCount(), + maxUnidirectionalCompoundGroup1ReferenceCount(), + unidirectionalCompoundReferenceNameMask(), + maxBidirectionalCompoundReferenceCount(), + maxBidirectionalCompoundGroup1ReferenceCount(), + maxBidirectionalCompoundGroup2ReferenceCount(), + bidirectionalCompoundReferenceNameMask(), + maxTemporalLayerCount(), + maxSpatialLayerCount(), + maxOperatingPoints(), + minQIndex(), + maxQIndex(), + prefersGopRemainingFrames(), + requiresGopRemainingFrames(), + stdSyntaxFlags() {} -safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR( - const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src) { +safe_VkVideoEncodeAV1CapabilitiesKHR::safe_VkVideoEncodeAV1CapabilitiesKHR(const safe_VkVideoEncodeAV1CapabilitiesKHR& copy_src) { sType = copy_src.sType; - vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor; - vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor; + flags = copy_src.flags; + maxLevel = copy_src.maxLevel; + codedPictureAlignment = copy_src.codedPictureAlignment; + maxTiles = copy_src.maxTiles; + minTileSize = copy_src.minTileSize; + maxTileSize = copy_src.maxTileSize; + superblockSizes = copy_src.superblockSizes; + maxSingleReferenceCount = copy_src.maxSingleReferenceCount; + singleReferenceNameMask = copy_src.singleReferenceNameMask; + maxUnidirectionalCompoundReferenceCount = copy_src.maxUnidirectionalCompoundReferenceCount; + maxUnidirectionalCompoundGroup1ReferenceCount = copy_src.maxUnidirectionalCompoundGroup1ReferenceCount; + unidirectionalCompoundReferenceNameMask = copy_src.unidirectionalCompoundReferenceNameMask; + maxBidirectionalCompoundReferenceCount = copy_src.maxBidirectionalCompoundReferenceCount; + maxBidirectionalCompoundGroup1ReferenceCount = copy_src.maxBidirectionalCompoundGroup1ReferenceCount; + maxBidirectionalCompoundGroup2ReferenceCount = copy_src.maxBidirectionalCompoundGroup2ReferenceCount; + bidirectionalCompoundReferenceNameMask = copy_src.bidirectionalCompoundReferenceNameMask; + maxTemporalLayerCount = copy_src.maxTemporalLayerCount; + maxSpatialLayerCount = copy_src.maxSpatialLayerCount; + maxOperatingPoints = copy_src.maxOperatingPoints; + minQIndex = copy_src.minQIndex; + maxQIndex = copy_src.maxQIndex; + prefersGopRemainingFrames = copy_src.prefersGopRemainingFrames; + requiresGopRemainingFrames = copy_src.requiresGopRemainingFrames; + stdSyntaxFlags = copy_src.stdSyntaxFlags; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::operator=( - const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src) { +safe_VkVideoEncodeAV1CapabilitiesKHR& safe_VkVideoEncodeAV1CapabilitiesKHR::operator=( + const safe_VkVideoEncodeAV1CapabilitiesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor; - vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor; + flags = copy_src.flags; + maxLevel = copy_src.maxLevel; + codedPictureAlignment = copy_src.codedPictureAlignment; + maxTiles = copy_src.maxTiles; + minTileSize = copy_src.minTileSize; + maxTileSize = copy_src.maxTileSize; + superblockSizes = copy_src.superblockSizes; + maxSingleReferenceCount = copy_src.maxSingleReferenceCount; + singleReferenceNameMask = copy_src.singleReferenceNameMask; + maxUnidirectionalCompoundReferenceCount = copy_src.maxUnidirectionalCompoundReferenceCount; + maxUnidirectionalCompoundGroup1ReferenceCount = copy_src.maxUnidirectionalCompoundGroup1ReferenceCount; + unidirectionalCompoundReferenceNameMask = copy_src.unidirectionalCompoundReferenceNameMask; + maxBidirectionalCompoundReferenceCount = copy_src.maxBidirectionalCompoundReferenceCount; + maxBidirectionalCompoundGroup1ReferenceCount = copy_src.maxBidirectionalCompoundGroup1ReferenceCount; + maxBidirectionalCompoundGroup2ReferenceCount = copy_src.maxBidirectionalCompoundGroup2ReferenceCount; + bidirectionalCompoundReferenceNameMask = copy_src.bidirectionalCompoundReferenceNameMask; + maxTemporalLayerCount = copy_src.maxTemporalLayerCount; + maxSpatialLayerCount = copy_src.maxSpatialLayerCount; + maxOperatingPoints = copy_src.maxOperatingPoints; + minQIndex = copy_src.minQIndex; + maxQIndex = copy_src.maxQIndex; + prefersGopRemainingFrames = copy_src.prefersGopRemainingFrames; + requiresGopRemainingFrames = copy_src.requiresGopRemainingFrames; + stdSyntaxFlags = copy_src.stdSyntaxFlags; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::~safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR() { - FreePnextChain(pNext); -} +safe_VkVideoEncodeAV1CapabilitiesKHR::~safe_VkVideoEncodeAV1CapabilitiesKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::initialize( - const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeAV1CapabilitiesKHR::initialize(const VkVideoEncodeAV1CapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - vertexAttributeInstanceRateDivisor = in_struct->vertexAttributeInstanceRateDivisor; - vertexAttributeInstanceRateZeroDivisor = in_struct->vertexAttributeInstanceRateZeroDivisor; + flags = in_struct->flags; + maxLevel = in_struct->maxLevel; + codedPictureAlignment = in_struct->codedPictureAlignment; + maxTiles = in_struct->maxTiles; + minTileSize = in_struct->minTileSize; + maxTileSize = in_struct->maxTileSize; + superblockSizes = in_struct->superblockSizes; + maxSingleReferenceCount = in_struct->maxSingleReferenceCount; + singleReferenceNameMask = in_struct->singleReferenceNameMask; + maxUnidirectionalCompoundReferenceCount = in_struct->maxUnidirectionalCompoundReferenceCount; + maxUnidirectionalCompoundGroup1ReferenceCount = in_struct->maxUnidirectionalCompoundGroup1ReferenceCount; + unidirectionalCompoundReferenceNameMask = in_struct->unidirectionalCompoundReferenceNameMask; + maxBidirectionalCompoundReferenceCount = in_struct->maxBidirectionalCompoundReferenceCount; + maxBidirectionalCompoundGroup1ReferenceCount = in_struct->maxBidirectionalCompoundGroup1ReferenceCount; + maxBidirectionalCompoundGroup2ReferenceCount = in_struct->maxBidirectionalCompoundGroup2ReferenceCount; + bidirectionalCompoundReferenceNameMask = in_struct->bidirectionalCompoundReferenceNameMask; + maxTemporalLayerCount = in_struct->maxTemporalLayerCount; + maxSpatialLayerCount = in_struct->maxSpatialLayerCount; + maxOperatingPoints = in_struct->maxOperatingPoints; + minQIndex = in_struct->minQIndex; + maxQIndex = in_struct->maxQIndex; + prefersGopRemainingFrames = in_struct->prefersGopRemainingFrames; + requiresGopRemainingFrames = in_struct->requiresGopRemainingFrames; + stdSyntaxFlags = in_struct->stdSyntaxFlags; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::initialize( - const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeAV1CapabilitiesKHR::initialize(const safe_VkVideoEncodeAV1CapabilitiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - vertexAttributeInstanceRateDivisor = copy_src->vertexAttributeInstanceRateDivisor; - vertexAttributeInstanceRateZeroDivisor = copy_src->vertexAttributeInstanceRateZeroDivisor; + flags = copy_src->flags; + maxLevel = copy_src->maxLevel; + codedPictureAlignment = copy_src->codedPictureAlignment; + maxTiles = copy_src->maxTiles; + minTileSize = copy_src->minTileSize; + maxTileSize = copy_src->maxTileSize; + superblockSizes = copy_src->superblockSizes; + maxSingleReferenceCount = copy_src->maxSingleReferenceCount; + singleReferenceNameMask = copy_src->singleReferenceNameMask; + maxUnidirectionalCompoundReferenceCount = copy_src->maxUnidirectionalCompoundReferenceCount; + maxUnidirectionalCompoundGroup1ReferenceCount = copy_src->maxUnidirectionalCompoundGroup1ReferenceCount; + unidirectionalCompoundReferenceNameMask = copy_src->unidirectionalCompoundReferenceNameMask; + maxBidirectionalCompoundReferenceCount = copy_src->maxBidirectionalCompoundReferenceCount; + maxBidirectionalCompoundGroup1ReferenceCount = copy_src->maxBidirectionalCompoundGroup1ReferenceCount; + maxBidirectionalCompoundGroup2ReferenceCount = copy_src->maxBidirectionalCompoundGroup2ReferenceCount; + bidirectionalCompoundReferenceNameMask = copy_src->bidirectionalCompoundReferenceNameMask; + maxTemporalLayerCount = copy_src->maxTemporalLayerCount; + maxSpatialLayerCount = copy_src->maxSpatialLayerCount; + maxOperatingPoints = copy_src->maxOperatingPoints; + minQIndex = copy_src->minQIndex; + maxQIndex = copy_src->maxQIndex; + prefersGopRemainingFrames = copy_src->prefersGopRemainingFrames; + requiresGopRemainingFrames = copy_src->requiresGopRemainingFrames; + stdSyntaxFlags = copy_src->stdSyntaxFlags; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR( - const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), shaderFloatControls2(in_struct->shaderFloatControls2) { +safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::safe_VkVideoEncodeAV1QualityLevelPropertiesKHR( + const VkVideoEncodeAV1QualityLevelPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + preferredRateControlFlags(in_struct->preferredRateControlFlags), + preferredGopFrameCount(in_struct->preferredGopFrameCount), + preferredKeyFramePeriod(in_struct->preferredKeyFramePeriod), + preferredConsecutiveBipredictiveFrameCount(in_struct->preferredConsecutiveBipredictiveFrameCount), + preferredTemporalLayerCount(in_struct->preferredTemporalLayerCount), + preferredConstantQIndex(in_struct->preferredConstantQIndex), + preferredMaxSingleReferenceCount(in_struct->preferredMaxSingleReferenceCount), + preferredSingleReferenceNameMask(in_struct->preferredSingleReferenceNameMask), + preferredMaxUnidirectionalCompoundReferenceCount(in_struct->preferredMaxUnidirectionalCompoundReferenceCount), + preferredMaxUnidirectionalCompoundGroup1ReferenceCount(in_struct->preferredMaxUnidirectionalCompoundGroup1ReferenceCount), + preferredUnidirectionalCompoundReferenceNameMask(in_struct->preferredUnidirectionalCompoundReferenceNameMask), + preferredMaxBidirectionalCompoundReferenceCount(in_struct->preferredMaxBidirectionalCompoundReferenceCount), + preferredMaxBidirectionalCompoundGroup1ReferenceCount(in_struct->preferredMaxBidirectionalCompoundGroup1ReferenceCount), + preferredMaxBidirectionalCompoundGroup2ReferenceCount(in_struct->preferredMaxBidirectionalCompoundGroup2ReferenceCount), + preferredBidirectionalCompoundReferenceNameMask(in_struct->preferredBidirectionalCompoundReferenceNameMask) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR), pNext(nullptr), shaderFloatControls2() {} +safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::safe_VkVideoEncodeAV1QualityLevelPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR), + pNext(nullptr), + preferredRateControlFlags(), + preferredGopFrameCount(), + preferredKeyFramePeriod(), + preferredConsecutiveBipredictiveFrameCount(), + preferredTemporalLayerCount(), + preferredConstantQIndex(), + preferredMaxSingleReferenceCount(), + preferredSingleReferenceNameMask(), + preferredMaxUnidirectionalCompoundReferenceCount(), + preferredMaxUnidirectionalCompoundGroup1ReferenceCount(), + preferredUnidirectionalCompoundReferenceNameMask(), + preferredMaxBidirectionalCompoundReferenceCount(), + preferredMaxBidirectionalCompoundGroup1ReferenceCount(), + preferredMaxBidirectionalCompoundGroup2ReferenceCount(), + preferredBidirectionalCompoundReferenceNameMask() {} -safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR( - const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src) { +safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::safe_VkVideoEncodeAV1QualityLevelPropertiesKHR( + const safe_VkVideoEncodeAV1QualityLevelPropertiesKHR& copy_src) { sType = copy_src.sType; - shaderFloatControls2 = copy_src.shaderFloatControls2; + preferredRateControlFlags = copy_src.preferredRateControlFlags; + preferredGopFrameCount = copy_src.preferredGopFrameCount; + preferredKeyFramePeriod = copy_src.preferredKeyFramePeriod; + preferredConsecutiveBipredictiveFrameCount = copy_src.preferredConsecutiveBipredictiveFrameCount; + preferredTemporalLayerCount = copy_src.preferredTemporalLayerCount; + preferredConstantQIndex = copy_src.preferredConstantQIndex; + preferredMaxSingleReferenceCount = copy_src.preferredMaxSingleReferenceCount; + preferredSingleReferenceNameMask = copy_src.preferredSingleReferenceNameMask; + preferredMaxUnidirectionalCompoundReferenceCount = copy_src.preferredMaxUnidirectionalCompoundReferenceCount; + preferredMaxUnidirectionalCompoundGroup1ReferenceCount = copy_src.preferredMaxUnidirectionalCompoundGroup1ReferenceCount; + preferredUnidirectionalCompoundReferenceNameMask = copy_src.preferredUnidirectionalCompoundReferenceNameMask; + preferredMaxBidirectionalCompoundReferenceCount = copy_src.preferredMaxBidirectionalCompoundReferenceCount; + preferredMaxBidirectionalCompoundGroup1ReferenceCount = copy_src.preferredMaxBidirectionalCompoundGroup1ReferenceCount; + preferredMaxBidirectionalCompoundGroup2ReferenceCount = copy_src.preferredMaxBidirectionalCompoundGroup2ReferenceCount; + preferredBidirectionalCompoundReferenceNameMask = copy_src.preferredBidirectionalCompoundReferenceNameMask; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::operator=( - const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src) { +safe_VkVideoEncodeAV1QualityLevelPropertiesKHR& safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::operator=( + const safe_VkVideoEncodeAV1QualityLevelPropertiesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - shaderFloatControls2 = copy_src.shaderFloatControls2; + preferredRateControlFlags = copy_src.preferredRateControlFlags; + preferredGopFrameCount = copy_src.preferredGopFrameCount; + preferredKeyFramePeriod = copy_src.preferredKeyFramePeriod; + preferredConsecutiveBipredictiveFrameCount = copy_src.preferredConsecutiveBipredictiveFrameCount; + preferredTemporalLayerCount = copy_src.preferredTemporalLayerCount; + preferredConstantQIndex = copy_src.preferredConstantQIndex; + preferredMaxSingleReferenceCount = copy_src.preferredMaxSingleReferenceCount; + preferredSingleReferenceNameMask = copy_src.preferredSingleReferenceNameMask; + preferredMaxUnidirectionalCompoundReferenceCount = copy_src.preferredMaxUnidirectionalCompoundReferenceCount; + preferredMaxUnidirectionalCompoundGroup1ReferenceCount = copy_src.preferredMaxUnidirectionalCompoundGroup1ReferenceCount; + preferredUnidirectionalCompoundReferenceNameMask = copy_src.preferredUnidirectionalCompoundReferenceNameMask; + preferredMaxBidirectionalCompoundReferenceCount = copy_src.preferredMaxBidirectionalCompoundReferenceCount; + preferredMaxBidirectionalCompoundGroup1ReferenceCount = copy_src.preferredMaxBidirectionalCompoundGroup1ReferenceCount; + preferredMaxBidirectionalCompoundGroup2ReferenceCount = copy_src.preferredMaxBidirectionalCompoundGroup2ReferenceCount; + preferredBidirectionalCompoundReferenceNameMask = copy_src.preferredBidirectionalCompoundReferenceNameMask; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::~safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR() { - FreePnextChain(pNext); -} +safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::~safe_VkVideoEncodeAV1QualityLevelPropertiesKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::initialize( - const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::initialize(const VkVideoEncodeAV1QualityLevelPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - shaderFloatControls2 = in_struct->shaderFloatControls2; + preferredRateControlFlags = in_struct->preferredRateControlFlags; + preferredGopFrameCount = in_struct->preferredGopFrameCount; + preferredKeyFramePeriod = in_struct->preferredKeyFramePeriod; + preferredConsecutiveBipredictiveFrameCount = in_struct->preferredConsecutiveBipredictiveFrameCount; + preferredTemporalLayerCount = in_struct->preferredTemporalLayerCount; + preferredConstantQIndex = in_struct->preferredConstantQIndex; + preferredMaxSingleReferenceCount = in_struct->preferredMaxSingleReferenceCount; + preferredSingleReferenceNameMask = in_struct->preferredSingleReferenceNameMask; + preferredMaxUnidirectionalCompoundReferenceCount = in_struct->preferredMaxUnidirectionalCompoundReferenceCount; + preferredMaxUnidirectionalCompoundGroup1ReferenceCount = in_struct->preferredMaxUnidirectionalCompoundGroup1ReferenceCount; + preferredUnidirectionalCompoundReferenceNameMask = in_struct->preferredUnidirectionalCompoundReferenceNameMask; + preferredMaxBidirectionalCompoundReferenceCount = in_struct->preferredMaxBidirectionalCompoundReferenceCount; + preferredMaxBidirectionalCompoundGroup1ReferenceCount = in_struct->preferredMaxBidirectionalCompoundGroup1ReferenceCount; + preferredMaxBidirectionalCompoundGroup2ReferenceCount = in_struct->preferredMaxBidirectionalCompoundGroup2ReferenceCount; + preferredBidirectionalCompoundReferenceNameMask = in_struct->preferredBidirectionalCompoundReferenceNameMask; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::initialize( - const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::initialize(const safe_VkVideoEncodeAV1QualityLevelPropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - shaderFloatControls2 = copy_src->shaderFloatControls2; + preferredRateControlFlags = copy_src->preferredRateControlFlags; + preferredGopFrameCount = copy_src->preferredGopFrameCount; + preferredKeyFramePeriod = copy_src->preferredKeyFramePeriod; + preferredConsecutiveBipredictiveFrameCount = copy_src->preferredConsecutiveBipredictiveFrameCount; + preferredTemporalLayerCount = copy_src->preferredTemporalLayerCount; + preferredConstantQIndex = copy_src->preferredConstantQIndex; + preferredMaxSingleReferenceCount = copy_src->preferredMaxSingleReferenceCount; + preferredSingleReferenceNameMask = copy_src->preferredSingleReferenceNameMask; + preferredMaxUnidirectionalCompoundReferenceCount = copy_src->preferredMaxUnidirectionalCompoundReferenceCount; + preferredMaxUnidirectionalCompoundGroup1ReferenceCount = copy_src->preferredMaxUnidirectionalCompoundGroup1ReferenceCount; + preferredUnidirectionalCompoundReferenceNameMask = copy_src->preferredUnidirectionalCompoundReferenceNameMask; + preferredMaxBidirectionalCompoundReferenceCount = copy_src->preferredMaxBidirectionalCompoundReferenceCount; + preferredMaxBidirectionalCompoundGroup1ReferenceCount = copy_src->preferredMaxBidirectionalCompoundGroup1ReferenceCount; + preferredMaxBidirectionalCompoundGroup2ReferenceCount = copy_src->preferredMaxBidirectionalCompoundGroup2ReferenceCount; + preferredBidirectionalCompoundReferenceNameMask = copy_src->preferredBidirectionalCompoundReferenceNameMask; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR( - const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), indexTypeUint8(in_struct->indexTypeUint8) { +safe_VkVideoEncodeAV1SessionCreateInfoKHR::safe_VkVideoEncodeAV1SessionCreateInfoKHR( + const VkVideoEncodeAV1SessionCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), useMaxLevel(in_struct->useMaxLevel), maxLevel(in_struct->maxLevel) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR), pNext(nullptr), indexTypeUint8() {} +safe_VkVideoEncodeAV1SessionCreateInfoKHR::safe_VkVideoEncodeAV1SessionCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR), pNext(nullptr), useMaxLevel(), maxLevel() {} -safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR( - const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src) { +safe_VkVideoEncodeAV1SessionCreateInfoKHR::safe_VkVideoEncodeAV1SessionCreateInfoKHR( + const safe_VkVideoEncodeAV1SessionCreateInfoKHR& copy_src) { sType = copy_src.sType; - indexTypeUint8 = copy_src.indexTypeUint8; + useMaxLevel = copy_src.useMaxLevel; + maxLevel = copy_src.maxLevel; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::operator=( - const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src) { +safe_VkVideoEncodeAV1SessionCreateInfoKHR& safe_VkVideoEncodeAV1SessionCreateInfoKHR::operator=( + const safe_VkVideoEncodeAV1SessionCreateInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - indexTypeUint8 = copy_src.indexTypeUint8; + useMaxLevel = copy_src.useMaxLevel; + maxLevel = copy_src.maxLevel; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::~safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeAV1SessionCreateInfoKHR::~safe_VkVideoEncodeAV1SessionCreateInfoKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::initialize(const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeAV1SessionCreateInfoKHR::initialize(const VkVideoEncodeAV1SessionCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - indexTypeUint8 = in_struct->indexTypeUint8; + useMaxLevel = in_struct->useMaxLevel; + maxLevel = in_struct->maxLevel; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::initialize(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeAV1SessionCreateInfoKHR::initialize(const safe_VkVideoEncodeAV1SessionCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - indexTypeUint8 = copy_src->indexTypeUint8; + useMaxLevel = copy_src->useMaxLevel; + maxLevel = copy_src->maxLevel; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::safe_VkPhysicalDeviceLineRasterizationFeaturesKHR( - const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR( + const VkVideoEncodeAV1SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), - rectangularLines(in_struct->rectangularLines), - bresenhamLines(in_struct->bresenhamLines), - smoothLines(in_struct->smoothLines), - stippledRectangularLines(in_struct->stippledRectangularLines), - stippledBresenhamLines(in_struct->stippledBresenhamLines), - stippledSmoothLines(in_struct->stippledSmoothLines) { + pStdSequenceHeader(nullptr), + pStdDecoderModelInfo(nullptr), + stdOperatingPointCount(in_struct->stdOperatingPointCount), + pStdOperatingPoints(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } -} + if (in_struct->pStdSequenceHeader) { + pStdSequenceHeader = new StdVideoAV1SequenceHeader(*in_struct->pStdSequenceHeader); + } -safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::safe_VkPhysicalDeviceLineRasterizationFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR), - pNext(nullptr), - rectangularLines(), - bresenhamLines(), - smoothLines(), - stippledRectangularLines(), - stippledBresenhamLines(), - stippledSmoothLines() {} + if (in_struct->pStdDecoderModelInfo) { + pStdDecoderModelInfo = new StdVideoEncodeAV1DecoderModelInfo(*in_struct->pStdDecoderModelInfo); + } -safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::safe_VkPhysicalDeviceLineRasterizationFeaturesKHR( - const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& copy_src) { - sType = copy_src.sType; - rectangularLines = copy_src.rectangularLines; - bresenhamLines = copy_src.bresenhamLines; - smoothLines = copy_src.smoothLines; - stippledRectangularLines = copy_src.stippledRectangularLines; - stippledBresenhamLines = copy_src.stippledBresenhamLines; - stippledSmoothLines = copy_src.stippledSmoothLines; - pNext = SafePnextCopy(copy_src.pNext); + if (in_struct->pStdOperatingPoints) { + pStdOperatingPoints = new StdVideoEncodeAV1OperatingPointInfo[in_struct->stdOperatingPointCount]; + memcpy((void*)pStdOperatingPoints, (void*)in_struct->pStdOperatingPoints, + sizeof(StdVideoEncodeAV1OperatingPointInfo) * in_struct->stdOperatingPointCount); + } } -safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::operator=( - const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); +safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR), + pNext(nullptr), + pStdSequenceHeader(nullptr), + pStdDecoderModelInfo(nullptr), + stdOperatingPointCount(), + pStdOperatingPoints(nullptr) {} +safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR( + const safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR& copy_src) { sType = copy_src.sType; - rectangularLines = copy_src.rectangularLines; - bresenhamLines = copy_src.bresenhamLines; - smoothLines = copy_src.smoothLines; - stippledRectangularLines = copy_src.stippledRectangularLines; - stippledBresenhamLines = copy_src.stippledBresenhamLines; - stippledSmoothLines = copy_src.stippledSmoothLines; + pStdSequenceHeader = nullptr; + pStdDecoderModelInfo = nullptr; + stdOperatingPointCount = copy_src.stdOperatingPointCount; + pStdOperatingPoints = nullptr; pNext = SafePnextCopy(copy_src.pNext); - return *this; -} - -safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::~safe_VkPhysicalDeviceLineRasterizationFeaturesKHR() { FreePnextChain(pNext); } - -void safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::initialize(const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - rectangularLines = in_struct->rectangularLines; - bresenhamLines = in_struct->bresenhamLines; - smoothLines = in_struct->smoothLines; - stippledRectangularLines = in_struct->stippledRectangularLines; - stippledBresenhamLines = in_struct->stippledBresenhamLines; - stippledSmoothLines = in_struct->stippledSmoothLines; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::initialize( - const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - rectangularLines = copy_src->rectangularLines; - bresenhamLines = copy_src->bresenhamLines; - smoothLines = copy_src->smoothLines; - stippledRectangularLines = copy_src->stippledRectangularLines; - stippledBresenhamLines = copy_src->stippledBresenhamLines; - stippledSmoothLines = copy_src->stippledSmoothLines; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::safe_VkPhysicalDeviceLineRasterizationPropertiesKHR( - const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), lineSubPixelPrecisionBits(in_struct->lineSubPixelPrecisionBits) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (copy_src.pStdSequenceHeader) { + pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src.pStdSequenceHeader); } -} -safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::safe_VkPhysicalDeviceLineRasterizationPropertiesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR), pNext(nullptr), lineSubPixelPrecisionBits() {} + if (copy_src.pStdDecoderModelInfo) { + pStdDecoderModelInfo = new StdVideoEncodeAV1DecoderModelInfo(*copy_src.pStdDecoderModelInfo); + } -safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::safe_VkPhysicalDeviceLineRasterizationPropertiesKHR( - const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& copy_src) { - sType = copy_src.sType; - lineSubPixelPrecisionBits = copy_src.lineSubPixelPrecisionBits; - pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pStdOperatingPoints) { + pStdOperatingPoints = new StdVideoEncodeAV1OperatingPointInfo[copy_src.stdOperatingPointCount]; + memcpy((void*)pStdOperatingPoints, (void*)copy_src.pStdOperatingPoints, + sizeof(StdVideoEncodeAV1OperatingPointInfo) * copy_src.stdOperatingPointCount); + } } -safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::operator=( - const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& copy_src) { +safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR& safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::operator=( + const safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR& copy_src) { if (©_src == this) return *this; + if (pStdSequenceHeader) delete pStdSequenceHeader; + if (pStdDecoderModelInfo) delete pStdDecoderModelInfo; + if (pStdOperatingPoints) delete[] pStdOperatingPoints; FreePnextChain(pNext); sType = copy_src.sType; - lineSubPixelPrecisionBits = copy_src.lineSubPixelPrecisionBits; + pStdSequenceHeader = nullptr; + pStdDecoderModelInfo = nullptr; + stdOperatingPointCount = copy_src.stdOperatingPointCount; + pStdOperatingPoints = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pStdSequenceHeader) { + pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src.pStdSequenceHeader); + } + + if (copy_src.pStdDecoderModelInfo) { + pStdDecoderModelInfo = new StdVideoEncodeAV1DecoderModelInfo(*copy_src.pStdDecoderModelInfo); + } + + if (copy_src.pStdOperatingPoints) { + pStdOperatingPoints = new StdVideoEncodeAV1OperatingPointInfo[copy_src.stdOperatingPointCount]; + memcpy((void*)pStdOperatingPoints, (void*)copy_src.pStdOperatingPoints, + sizeof(StdVideoEncodeAV1OperatingPointInfo) * copy_src.stdOperatingPointCount); + } + return *this; } -safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::~safe_VkPhysicalDeviceLineRasterizationPropertiesKHR() { +safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::~safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR() { + if (pStdSequenceHeader) delete pStdSequenceHeader; + if (pStdDecoderModelInfo) delete pStdDecoderModelInfo; + if (pStdOperatingPoints) delete[] pStdOperatingPoints; FreePnextChain(pNext); } -void safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::initialize( - const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::initialize( + const VkVideoEncodeAV1SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdSequenceHeader) delete pStdSequenceHeader; + if (pStdDecoderModelInfo) delete pStdDecoderModelInfo; + if (pStdOperatingPoints) delete[] pStdOperatingPoints; FreePnextChain(pNext); sType = in_struct->sType; - lineSubPixelPrecisionBits = in_struct->lineSubPixelPrecisionBits; + pStdSequenceHeader = nullptr; + pStdDecoderModelInfo = nullptr; + stdOperatingPointCount = in_struct->stdOperatingPointCount; + pStdOperatingPoints = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pStdSequenceHeader) { + pStdSequenceHeader = new StdVideoAV1SequenceHeader(*in_struct->pStdSequenceHeader); + } + + if (in_struct->pStdDecoderModelInfo) { + pStdDecoderModelInfo = new StdVideoEncodeAV1DecoderModelInfo(*in_struct->pStdDecoderModelInfo); + } + + if (in_struct->pStdOperatingPoints) { + pStdOperatingPoints = new StdVideoEncodeAV1OperatingPointInfo[in_struct->stdOperatingPointCount]; + memcpy((void*)pStdOperatingPoints, (void*)in_struct->pStdOperatingPoints, + sizeof(StdVideoEncodeAV1OperatingPointInfo) * in_struct->stdOperatingPointCount); + } } -void safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::initialize( - const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - lineSubPixelPrecisionBits = copy_src->lineSubPixelPrecisionBits; - pNext = SafePnextCopy(copy_src->pNext); +void safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::initialize( + const safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pStdSequenceHeader = nullptr; + pStdDecoderModelInfo = nullptr; + stdOperatingPointCount = copy_src->stdOperatingPointCount; + pStdOperatingPoints = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdSequenceHeader) { + pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src->pStdSequenceHeader); + } + + if (copy_src->pStdDecoderModelInfo) { + pStdDecoderModelInfo = new StdVideoEncodeAV1DecoderModelInfo(*copy_src->pStdDecoderModelInfo); + } + + if (copy_src->pStdOperatingPoints) { + pStdOperatingPoints = new StdVideoEncodeAV1OperatingPointInfo[copy_src->stdOperatingPointCount]; + memcpy((void*)pStdOperatingPoints, (void*)copy_src->pStdOperatingPoints, + sizeof(StdVideoEncodeAV1OperatingPointInfo) * copy_src->stdOperatingPointCount); + } } -safe_VkPipelineRasterizationLineStateCreateInfoKHR::safe_VkPipelineRasterizationLineStateCreateInfoKHR( - const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkVideoEncodeAV1PictureInfoKHR::safe_VkVideoEncodeAV1PictureInfoKHR(const VkVideoEncodeAV1PictureInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) : sType(in_struct->sType), - lineRasterizationMode(in_struct->lineRasterizationMode), - stippledLineEnable(in_struct->stippledLineEnable), - lineStippleFactor(in_struct->lineStippleFactor), - lineStipplePattern(in_struct->lineStipplePattern) { + predictionMode(in_struct->predictionMode), + rateControlGroup(in_struct->rateControlGroup), + constantQIndex(in_struct->constantQIndex), + pStdPictureInfo(nullptr), + primaryReferenceCdfOnly(in_struct->primaryReferenceCdfOnly), + generateObuExtensionHeader(in_struct->generateObuExtensionHeader) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + if (in_struct->pStdPictureInfo) { + pStdPictureInfo = new StdVideoEncodeAV1PictureInfo(*in_struct->pStdPictureInfo); + } + + for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = in_struct->referenceNameSlotIndices[i]; + } } -safe_VkPipelineRasterizationLineStateCreateInfoKHR::safe_VkPipelineRasterizationLineStateCreateInfoKHR() - : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR), +safe_VkVideoEncodeAV1PictureInfoKHR::safe_VkVideoEncodeAV1PictureInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR), pNext(nullptr), - lineRasterizationMode(), - stippledLineEnable(), - lineStippleFactor(), - lineStipplePattern() {} + predictionMode(), + rateControlGroup(), + constantQIndex(), + pStdPictureInfo(nullptr), + primaryReferenceCdfOnly(), + generateObuExtensionHeader() {} -safe_VkPipelineRasterizationLineStateCreateInfoKHR::safe_VkPipelineRasterizationLineStateCreateInfoKHR( - const safe_VkPipelineRasterizationLineStateCreateInfoKHR& copy_src) { +safe_VkVideoEncodeAV1PictureInfoKHR::safe_VkVideoEncodeAV1PictureInfoKHR(const safe_VkVideoEncodeAV1PictureInfoKHR& copy_src) { sType = copy_src.sType; - lineRasterizationMode = copy_src.lineRasterizationMode; - stippledLineEnable = copy_src.stippledLineEnable; - lineStippleFactor = copy_src.lineStippleFactor; - lineStipplePattern = copy_src.lineStipplePattern; + predictionMode = copy_src.predictionMode; + rateControlGroup = copy_src.rateControlGroup; + constantQIndex = copy_src.constantQIndex; + pStdPictureInfo = nullptr; + primaryReferenceCdfOnly = copy_src.primaryReferenceCdfOnly; + generateObuExtensionHeader = copy_src.generateObuExtensionHeader; pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdPictureInfo) { + pStdPictureInfo = new StdVideoEncodeAV1PictureInfo(*copy_src.pStdPictureInfo); + } + + for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = copy_src.referenceNameSlotIndices[i]; + } } -safe_VkPipelineRasterizationLineStateCreateInfoKHR& safe_VkPipelineRasterizationLineStateCreateInfoKHR::operator=( - const safe_VkPipelineRasterizationLineStateCreateInfoKHR& copy_src) { +safe_VkVideoEncodeAV1PictureInfoKHR& safe_VkVideoEncodeAV1PictureInfoKHR::operator=( + const safe_VkVideoEncodeAV1PictureInfoKHR& copy_src) { if (©_src == this) return *this; + if (pStdPictureInfo) delete pStdPictureInfo; FreePnextChain(pNext); sType = copy_src.sType; - lineRasterizationMode = copy_src.lineRasterizationMode; - stippledLineEnable = copy_src.stippledLineEnable; - lineStippleFactor = copy_src.lineStippleFactor; - lineStipplePattern = copy_src.lineStipplePattern; + predictionMode = copy_src.predictionMode; + rateControlGroup = copy_src.rateControlGroup; + constantQIndex = copy_src.constantQIndex; + pStdPictureInfo = nullptr; + primaryReferenceCdfOnly = copy_src.primaryReferenceCdfOnly; + generateObuExtensionHeader = copy_src.generateObuExtensionHeader; pNext = SafePnextCopy(copy_src.pNext); - return *this; -} - -safe_VkPipelineRasterizationLineStateCreateInfoKHR::~safe_VkPipelineRasterizationLineStateCreateInfoKHR() { FreePnextChain(pNext); } - -void safe_VkPipelineRasterizationLineStateCreateInfoKHR::initialize(const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - lineRasterizationMode = in_struct->lineRasterizationMode; - stippledLineEnable = in_struct->stippledLineEnable; - lineStippleFactor = in_struct->lineStippleFactor; - lineStipplePattern = in_struct->lineStipplePattern; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPipelineRasterizationLineStateCreateInfoKHR::initialize( - const safe_VkPipelineRasterizationLineStateCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - lineRasterizationMode = copy_src->lineRasterizationMode; - stippledLineEnable = copy_src->stippledLineEnable; - lineStippleFactor = copy_src->lineStippleFactor; - lineStipplePattern = copy_src->lineStipplePattern; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR(const VkCalibratedTimestampInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), timeDomain(in_struct->timeDomain) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (copy_src.pStdPictureInfo) { + pStdPictureInfo = new StdVideoEncodeAV1PictureInfo(*copy_src.pStdPictureInfo); } -} -safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR() - : sType(VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR), pNext(nullptr), timeDomain() {} + for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = copy_src.referenceNameSlotIndices[i]; + } -safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR(const safe_VkCalibratedTimestampInfoKHR& copy_src) { - sType = copy_src.sType; - timeDomain = copy_src.timeDomain; - pNext = SafePnextCopy(copy_src.pNext); + return *this; } -safe_VkCalibratedTimestampInfoKHR& safe_VkCalibratedTimestampInfoKHR::operator=(const safe_VkCalibratedTimestampInfoKHR& copy_src) { - if (©_src == this) return *this; - +safe_VkVideoEncodeAV1PictureInfoKHR::~safe_VkVideoEncodeAV1PictureInfoKHR() { + if (pStdPictureInfo) delete pStdPictureInfo; FreePnextChain(pNext); - - sType = copy_src.sType; - timeDomain = copy_src.timeDomain; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; } -safe_VkCalibratedTimestampInfoKHR::~safe_VkCalibratedTimestampInfoKHR() { FreePnextChain(pNext); } - -void safe_VkCalibratedTimestampInfoKHR::initialize(const VkCalibratedTimestampInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeAV1PictureInfoKHR::initialize(const VkVideoEncodeAV1PictureInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdPictureInfo) delete pStdPictureInfo; FreePnextChain(pNext); sType = in_struct->sType; - timeDomain = in_struct->timeDomain; + predictionMode = in_struct->predictionMode; + rateControlGroup = in_struct->rateControlGroup; + constantQIndex = in_struct->constantQIndex; + pStdPictureInfo = nullptr; + primaryReferenceCdfOnly = in_struct->primaryReferenceCdfOnly; + generateObuExtensionHeader = in_struct->generateObuExtensionHeader; pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pStdPictureInfo) { + pStdPictureInfo = new StdVideoEncodeAV1PictureInfo(*in_struct->pStdPictureInfo); + } + + for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = in_struct->referenceNameSlotIndices[i]; + } } -void safe_VkCalibratedTimestampInfoKHR::initialize(const safe_VkCalibratedTimestampInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeAV1PictureInfoKHR::initialize(const safe_VkVideoEncodeAV1PictureInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - timeDomain = copy_src->timeDomain; + predictionMode = copy_src->predictionMode; + rateControlGroup = copy_src->rateControlGroup; + constantQIndex = copy_src->constantQIndex; + pStdPictureInfo = nullptr; + primaryReferenceCdfOnly = copy_src->primaryReferenceCdfOnly; + generateObuExtensionHeader = copy_src->generateObuExtensionHeader; pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdPictureInfo) { + pStdPictureInfo = new StdVideoEncodeAV1PictureInfo(*copy_src->pStdPictureInfo); + } + + for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = copy_src->referenceNameSlotIndices[i]; + } } -safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR( - const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), shaderExpectAssume(in_struct->shaderExpectAssume) { +safe_VkVideoEncodeAV1DpbSlotInfoKHR::safe_VkVideoEncodeAV1DpbSlotInfoKHR(const VkVideoEncodeAV1DpbSlotInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), pStdReferenceInfo(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + if (in_struct->pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoEncodeAV1ReferenceInfo(*in_struct->pStdReferenceInfo); + } } -safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR), pNext(nullptr), shaderExpectAssume() {} +safe_VkVideoEncodeAV1DpbSlotInfoKHR::safe_VkVideoEncodeAV1DpbSlotInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {} -safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR( - const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src) { +safe_VkVideoEncodeAV1DpbSlotInfoKHR::safe_VkVideoEncodeAV1DpbSlotInfoKHR(const safe_VkVideoEncodeAV1DpbSlotInfoKHR& copy_src) { sType = copy_src.sType; - shaderExpectAssume = copy_src.shaderExpectAssume; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoEncodeAV1ReferenceInfo(*copy_src.pStdReferenceInfo); + } } -safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::operator=( - const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src) { +safe_VkVideoEncodeAV1DpbSlotInfoKHR& safe_VkVideoEncodeAV1DpbSlotInfoKHR::operator=( + const safe_VkVideoEncodeAV1DpbSlotInfoKHR& copy_src) { if (©_src == this) return *this; + if (pStdReferenceInfo) delete pStdReferenceInfo; FreePnextChain(pNext); sType = copy_src.sType; - shaderExpectAssume = copy_src.shaderExpectAssume; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoEncodeAV1ReferenceInfo(*copy_src.pStdReferenceInfo); + } + return *this; } -safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::~safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeAV1DpbSlotInfoKHR::~safe_VkVideoEncodeAV1DpbSlotInfoKHR() { + if (pStdReferenceInfo) delete pStdReferenceInfo; + FreePnextChain(pNext); +} -void safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::initialize(const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeAV1DpbSlotInfoKHR::initialize(const VkVideoEncodeAV1DpbSlotInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdReferenceInfo) delete pStdReferenceInfo; FreePnextChain(pNext); sType = in_struct->sType; - shaderExpectAssume = in_struct->shaderExpectAssume; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoEncodeAV1ReferenceInfo(*in_struct->pStdReferenceInfo); + } } -void safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::initialize( - const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeAV1DpbSlotInfoKHR::initialize(const safe_VkVideoEncodeAV1DpbSlotInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - shaderExpectAssume = copy_src->shaderExpectAssume; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoEncodeAV1ReferenceInfo(*copy_src->pStdReferenceInfo); + } } -safe_VkPhysicalDeviceMaintenance6FeaturesKHR::safe_VkPhysicalDeviceMaintenance6FeaturesKHR( - const VkPhysicalDeviceMaintenance6FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), maintenance6(in_struct->maintenance6) { +safe_VkVideoEncodeAV1ProfileInfoKHR::safe_VkVideoEncodeAV1ProfileInfoKHR(const VkVideoEncodeAV1ProfileInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), stdProfile(in_struct->stdProfile) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDeviceMaintenance6FeaturesKHR::safe_VkPhysicalDeviceMaintenance6FeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR), pNext(nullptr), maintenance6() {} +safe_VkVideoEncodeAV1ProfileInfoKHR::safe_VkVideoEncodeAV1ProfileInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR), pNext(nullptr), stdProfile() {} -safe_VkPhysicalDeviceMaintenance6FeaturesKHR::safe_VkPhysicalDeviceMaintenance6FeaturesKHR( - const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& copy_src) { +safe_VkVideoEncodeAV1ProfileInfoKHR::safe_VkVideoEncodeAV1ProfileInfoKHR(const safe_VkVideoEncodeAV1ProfileInfoKHR& copy_src) { sType = copy_src.sType; - maintenance6 = copy_src.maintenance6; + stdProfile = copy_src.stdProfile; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceMaintenance6FeaturesKHR& safe_VkPhysicalDeviceMaintenance6FeaturesKHR::operator=( - const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& copy_src) { +safe_VkVideoEncodeAV1ProfileInfoKHR& safe_VkVideoEncodeAV1ProfileInfoKHR::operator=( + const safe_VkVideoEncodeAV1ProfileInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - maintenance6 = copy_src.maintenance6; + stdProfile = copy_src.stdProfile; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceMaintenance6FeaturesKHR::~safe_VkPhysicalDeviceMaintenance6FeaturesKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeAV1ProfileInfoKHR::~safe_VkVideoEncodeAV1ProfileInfoKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceMaintenance6FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance6FeaturesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeAV1ProfileInfoKHR::initialize(const VkVideoEncodeAV1ProfileInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - maintenance6 = in_struct->maintenance6; + stdProfile = in_struct->stdProfile; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceMaintenance6FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance6FeaturesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeAV1ProfileInfoKHR::initialize(const safe_VkVideoEncodeAV1ProfileInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - maintenance6 = copy_src->maintenance6; + stdProfile = copy_src->stdProfile; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDeviceMaintenance6PropertiesKHR::safe_VkPhysicalDeviceMaintenance6PropertiesKHR( - const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR( + const VkVideoEncodeAV1GopRemainingFrameInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), - blockTexelViewCompatibleMultipleLayers(in_struct->blockTexelViewCompatibleMultipleLayers), - maxCombinedImageSamplerDescriptorCount(in_struct->maxCombinedImageSamplerDescriptorCount), - fragmentShadingRateClampCombinerInputs(in_struct->fragmentShadingRateClampCombinerInputs) { + useGopRemainingFrames(in_struct->useGopRemainingFrames), + gopRemainingIntra(in_struct->gopRemainingIntra), + gopRemainingPredictive(in_struct->gopRemainingPredictive), + gopRemainingBipredictive(in_struct->gopRemainingBipredictive) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDeviceMaintenance6PropertiesKHR::safe_VkPhysicalDeviceMaintenance6PropertiesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR), +safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR), pNext(nullptr), - blockTexelViewCompatibleMultipleLayers(), - maxCombinedImageSamplerDescriptorCount(), - fragmentShadingRateClampCombinerInputs() {} + useGopRemainingFrames(), + gopRemainingIntra(), + gopRemainingPredictive(), + gopRemainingBipredictive() {} -safe_VkPhysicalDeviceMaintenance6PropertiesKHR::safe_VkPhysicalDeviceMaintenance6PropertiesKHR( - const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src) { +safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR( + const safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR& copy_src) { sType = copy_src.sType; - blockTexelViewCompatibleMultipleLayers = copy_src.blockTexelViewCompatibleMultipleLayers; - maxCombinedImageSamplerDescriptorCount = copy_src.maxCombinedImageSamplerDescriptorCount; - fragmentShadingRateClampCombinerInputs = copy_src.fragmentShadingRateClampCombinerInputs; + useGopRemainingFrames = copy_src.useGopRemainingFrames; + gopRemainingIntra = copy_src.gopRemainingIntra; + gopRemainingPredictive = copy_src.gopRemainingPredictive; + gopRemainingBipredictive = copy_src.gopRemainingBipredictive; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceMaintenance6PropertiesKHR& safe_VkPhysicalDeviceMaintenance6PropertiesKHR::operator=( - const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src) { +safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR& safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::operator=( + const safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - blockTexelViewCompatibleMultipleLayers = copy_src.blockTexelViewCompatibleMultipleLayers; - maxCombinedImageSamplerDescriptorCount = copy_src.maxCombinedImageSamplerDescriptorCount; - fragmentShadingRateClampCombinerInputs = copy_src.fragmentShadingRateClampCombinerInputs; + useGopRemainingFrames = copy_src.useGopRemainingFrames; + gopRemainingIntra = copy_src.gopRemainingIntra; + gopRemainingPredictive = copy_src.gopRemainingPredictive; + gopRemainingBipredictive = copy_src.gopRemainingBipredictive; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceMaintenance6PropertiesKHR::~safe_VkPhysicalDeviceMaintenance6PropertiesKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::~safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceMaintenance6PropertiesKHR::initialize(const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::initialize(const VkVideoEncodeAV1GopRemainingFrameInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - blockTexelViewCompatibleMultipleLayers = in_struct->blockTexelViewCompatibleMultipleLayers; - maxCombinedImageSamplerDescriptorCount = in_struct->maxCombinedImageSamplerDescriptorCount; - fragmentShadingRateClampCombinerInputs = in_struct->fragmentShadingRateClampCombinerInputs; + useGopRemainingFrames = in_struct->useGopRemainingFrames; + gopRemainingIntra = in_struct->gopRemainingIntra; + gopRemainingPredictive = in_struct->gopRemainingPredictive; + gopRemainingBipredictive = in_struct->gopRemainingBipredictive; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceMaintenance6PropertiesKHR::initialize(const safe_VkPhysicalDeviceMaintenance6PropertiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::initialize(const safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - blockTexelViewCompatibleMultipleLayers = copy_src->blockTexelViewCompatibleMultipleLayers; - maxCombinedImageSamplerDescriptorCount = copy_src->maxCombinedImageSamplerDescriptorCount; - fragmentShadingRateClampCombinerInputs = copy_src->fragmentShadingRateClampCombinerInputs; + useGopRemainingFrames = copy_src->useGopRemainingFrames; + gopRemainingIntra = copy_src->gopRemainingIntra; + gopRemainingPredictive = copy_src->gopRemainingPredictive; + gopRemainingBipredictive = copy_src->gopRemainingBipredictive; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkBindMemoryStatusKHR::safe_VkBindMemoryStatusKHR(const VkBindMemoryStatusKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), pResult(nullptr) { +safe_VkVideoEncodeAV1RateControlInfoKHR::safe_VkVideoEncodeAV1RateControlInfoKHR( + const VkVideoEncodeAV1RateControlInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + gopFrameCount(in_struct->gopFrameCount), + keyFramePeriod(in_struct->keyFramePeriod), + consecutiveBipredictiveFrameCount(in_struct->consecutiveBipredictiveFrameCount), + temporalLayerCount(in_struct->temporalLayerCount) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pResult) { - pResult = new VkResult(*in_struct->pResult); - } } -safe_VkBindMemoryStatusKHR::safe_VkBindMemoryStatusKHR() - : sType(VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR), pNext(nullptr), pResult(nullptr) {} +safe_VkVideoEncodeAV1RateControlInfoKHR::safe_VkVideoEncodeAV1RateControlInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR), + pNext(nullptr), + flags(), + gopFrameCount(), + keyFramePeriod(), + consecutiveBipredictiveFrameCount(), + temporalLayerCount() {} -safe_VkBindMemoryStatusKHR::safe_VkBindMemoryStatusKHR(const safe_VkBindMemoryStatusKHR& copy_src) { +safe_VkVideoEncodeAV1RateControlInfoKHR::safe_VkVideoEncodeAV1RateControlInfoKHR( + const safe_VkVideoEncodeAV1RateControlInfoKHR& copy_src) { sType = copy_src.sType; - pResult = nullptr; + flags = copy_src.flags; + gopFrameCount = copy_src.gopFrameCount; + keyFramePeriod = copy_src.keyFramePeriod; + consecutiveBipredictiveFrameCount = copy_src.consecutiveBipredictiveFrameCount; + temporalLayerCount = copy_src.temporalLayerCount; pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pResult) { - pResult = new VkResult(*copy_src.pResult); - } } -safe_VkBindMemoryStatusKHR& safe_VkBindMemoryStatusKHR::operator=(const safe_VkBindMemoryStatusKHR& copy_src) { +safe_VkVideoEncodeAV1RateControlInfoKHR& safe_VkVideoEncodeAV1RateControlInfoKHR::operator=( + const safe_VkVideoEncodeAV1RateControlInfoKHR& copy_src) { if (©_src == this) return *this; - if (pResult) delete pResult; FreePnextChain(pNext); sType = copy_src.sType; - pResult = nullptr; + flags = copy_src.flags; + gopFrameCount = copy_src.gopFrameCount; + keyFramePeriod = copy_src.keyFramePeriod; + consecutiveBipredictiveFrameCount = copy_src.consecutiveBipredictiveFrameCount; + temporalLayerCount = copy_src.temporalLayerCount; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pResult) { - pResult = new VkResult(*copy_src.pResult); - } - return *this; } -safe_VkBindMemoryStatusKHR::~safe_VkBindMemoryStatusKHR() { - if (pResult) delete pResult; - FreePnextChain(pNext); -} +safe_VkVideoEncodeAV1RateControlInfoKHR::~safe_VkVideoEncodeAV1RateControlInfoKHR() { FreePnextChain(pNext); } -void safe_VkBindMemoryStatusKHR::initialize(const VkBindMemoryStatusKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - if (pResult) delete pResult; +void safe_VkVideoEncodeAV1RateControlInfoKHR::initialize(const VkVideoEncodeAV1RateControlInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - pResult = nullptr; + flags = in_struct->flags; + gopFrameCount = in_struct->gopFrameCount; + keyFramePeriod = in_struct->keyFramePeriod; + consecutiveBipredictiveFrameCount = in_struct->consecutiveBipredictiveFrameCount; + temporalLayerCount = in_struct->temporalLayerCount; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pResult) { - pResult = new VkResult(*in_struct->pResult); - } } -void safe_VkBindMemoryStatusKHR::initialize(const safe_VkBindMemoryStatusKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeAV1RateControlInfoKHR::initialize(const safe_VkVideoEncodeAV1RateControlInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - pResult = nullptr; + flags = copy_src->flags; + gopFrameCount = copy_src->gopFrameCount; + keyFramePeriod = copy_src->keyFramePeriod; + consecutiveBipredictiveFrameCount = copy_src->consecutiveBipredictiveFrameCount; + temporalLayerCount = copy_src->temporalLayerCount; pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pResult) { - pResult = new VkResult(*copy_src->pResult); - } } -safe_VkBindDescriptorSetsInfoKHR::safe_VkBindDescriptorSetsInfoKHR(const VkBindDescriptorSetsInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkVideoEncodeAV1RateControlLayerInfoKHR::safe_VkVideoEncodeAV1RateControlLayerInfoKHR( + const VkVideoEncodeAV1RateControlLayerInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), - stageFlags(in_struct->stageFlags), - layout(in_struct->layout), - firstSet(in_struct->firstSet), - descriptorSetCount(in_struct->descriptorSetCount), - pDescriptorSets(nullptr), - dynamicOffsetCount(in_struct->dynamicOffsetCount), - pDynamicOffsets(nullptr) { + useMinQIndex(in_struct->useMinQIndex), + minQIndex(in_struct->minQIndex), + useMaxQIndex(in_struct->useMaxQIndex), + maxQIndex(in_struct->maxQIndex), + useMaxFrameSize(in_struct->useMaxFrameSize), + maxFrameSize(in_struct->maxFrameSize) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (descriptorSetCount && in_struct->pDescriptorSets) { - pDescriptorSets = new VkDescriptorSet[descriptorSetCount]; - for (uint32_t i = 0; i < descriptorSetCount; ++i) { - pDescriptorSets[i] = in_struct->pDescriptorSets[i]; - } - } - - if (in_struct->pDynamicOffsets) { - pDynamicOffsets = new uint32_t[in_struct->dynamicOffsetCount]; - memcpy((void*)pDynamicOffsets, (void*)in_struct->pDynamicOffsets, sizeof(uint32_t) * in_struct->dynamicOffsetCount); - } } -safe_VkBindDescriptorSetsInfoKHR::safe_VkBindDescriptorSetsInfoKHR() - : sType(VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR), +safe_VkVideoEncodeAV1RateControlLayerInfoKHR::safe_VkVideoEncodeAV1RateControlLayerInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR), pNext(nullptr), - stageFlags(), - layout(), - firstSet(), - descriptorSetCount(), - pDescriptorSets(nullptr), - dynamicOffsetCount(), - pDynamicOffsets(nullptr) {} + useMinQIndex(), + minQIndex(), + useMaxQIndex(), + maxQIndex(), + useMaxFrameSize(), + maxFrameSize() {} -safe_VkBindDescriptorSetsInfoKHR::safe_VkBindDescriptorSetsInfoKHR(const safe_VkBindDescriptorSetsInfoKHR& copy_src) { +safe_VkVideoEncodeAV1RateControlLayerInfoKHR::safe_VkVideoEncodeAV1RateControlLayerInfoKHR( + const safe_VkVideoEncodeAV1RateControlLayerInfoKHR& copy_src) { sType = copy_src.sType; - stageFlags = copy_src.stageFlags; - layout = copy_src.layout; - firstSet = copy_src.firstSet; - descriptorSetCount = copy_src.descriptorSetCount; - pDescriptorSets = nullptr; - dynamicOffsetCount = copy_src.dynamicOffsetCount; - pDynamicOffsets = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (descriptorSetCount && copy_src.pDescriptorSets) { - pDescriptorSets = new VkDescriptorSet[descriptorSetCount]; - for (uint32_t i = 0; i < descriptorSetCount; ++i) { - pDescriptorSets[i] = copy_src.pDescriptorSets[i]; - } - } - - if (copy_src.pDynamicOffsets) { - pDynamicOffsets = new uint32_t[copy_src.dynamicOffsetCount]; - memcpy((void*)pDynamicOffsets, (void*)copy_src.pDynamicOffsets, sizeof(uint32_t) * copy_src.dynamicOffsetCount); - } + useMinQIndex = copy_src.useMinQIndex; + minQIndex = copy_src.minQIndex; + useMaxQIndex = copy_src.useMaxQIndex; + maxQIndex = copy_src.maxQIndex; + useMaxFrameSize = copy_src.useMaxFrameSize; + maxFrameSize = copy_src.maxFrameSize; + pNext = SafePnextCopy(copy_src.pNext); } -safe_VkBindDescriptorSetsInfoKHR& safe_VkBindDescriptorSetsInfoKHR::operator=(const safe_VkBindDescriptorSetsInfoKHR& copy_src) { +safe_VkVideoEncodeAV1RateControlLayerInfoKHR& safe_VkVideoEncodeAV1RateControlLayerInfoKHR::operator=( + const safe_VkVideoEncodeAV1RateControlLayerInfoKHR& copy_src) { if (©_src == this) return *this; - if (pDescriptorSets) delete[] pDescriptorSets; - if (pDynamicOffsets) delete[] pDynamicOffsets; FreePnextChain(pNext); sType = copy_src.sType; - stageFlags = copy_src.stageFlags; - layout = copy_src.layout; - firstSet = copy_src.firstSet; - descriptorSetCount = copy_src.descriptorSetCount; - pDescriptorSets = nullptr; - dynamicOffsetCount = copy_src.dynamicOffsetCount; - pDynamicOffsets = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (descriptorSetCount && copy_src.pDescriptorSets) { - pDescriptorSets = new VkDescriptorSet[descriptorSetCount]; - for (uint32_t i = 0; i < descriptorSetCount; ++i) { - pDescriptorSets[i] = copy_src.pDescriptorSets[i]; - } - } - - if (copy_src.pDynamicOffsets) { - pDynamicOffsets = new uint32_t[copy_src.dynamicOffsetCount]; - memcpy((void*)pDynamicOffsets, (void*)copy_src.pDynamicOffsets, sizeof(uint32_t) * copy_src.dynamicOffsetCount); - } + useMinQIndex = copy_src.useMinQIndex; + minQIndex = copy_src.minQIndex; + useMaxQIndex = copy_src.useMaxQIndex; + maxQIndex = copy_src.maxQIndex; + useMaxFrameSize = copy_src.useMaxFrameSize; + maxFrameSize = copy_src.maxFrameSize; + pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkBindDescriptorSetsInfoKHR::~safe_VkBindDescriptorSetsInfoKHR() { - if (pDescriptorSets) delete[] pDescriptorSets; - if (pDynamicOffsets) delete[] pDynamicOffsets; - FreePnextChain(pNext); -} +safe_VkVideoEncodeAV1RateControlLayerInfoKHR::~safe_VkVideoEncodeAV1RateControlLayerInfoKHR() { FreePnextChain(pNext); } -void safe_VkBindDescriptorSetsInfoKHR::initialize(const VkBindDescriptorSetsInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pDescriptorSets) delete[] pDescriptorSets; - if (pDynamicOffsets) delete[] pDynamicOffsets; +void safe_VkVideoEncodeAV1RateControlLayerInfoKHR::initialize(const VkVideoEncodeAV1RateControlLayerInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - stageFlags = in_struct->stageFlags; - layout = in_struct->layout; - firstSet = in_struct->firstSet; - descriptorSetCount = in_struct->descriptorSetCount; - pDescriptorSets = nullptr; - dynamicOffsetCount = in_struct->dynamicOffsetCount; - pDynamicOffsets = nullptr; + useMinQIndex = in_struct->useMinQIndex; + minQIndex = in_struct->minQIndex; + useMaxQIndex = in_struct->useMaxQIndex; + maxQIndex = in_struct->maxQIndex; + useMaxFrameSize = in_struct->useMaxFrameSize; + maxFrameSize = in_struct->maxFrameSize; pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (descriptorSetCount && in_struct->pDescriptorSets) { - pDescriptorSets = new VkDescriptorSet[descriptorSetCount]; - for (uint32_t i = 0; i < descriptorSetCount; ++i) { - pDescriptorSets[i] = in_struct->pDescriptorSets[i]; - } - } - - if (in_struct->pDynamicOffsets) { - pDynamicOffsets = new uint32_t[in_struct->dynamicOffsetCount]; - memcpy((void*)pDynamicOffsets, (void*)in_struct->pDynamicOffsets, sizeof(uint32_t) * in_struct->dynamicOffsetCount); - } } -void safe_VkBindDescriptorSetsInfoKHR::initialize(const safe_VkBindDescriptorSetsInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeAV1RateControlLayerInfoKHR::initialize(const safe_VkVideoEncodeAV1RateControlLayerInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - stageFlags = copy_src->stageFlags; - layout = copy_src->layout; - firstSet = copy_src->firstSet; - descriptorSetCount = copy_src->descriptorSetCount; - pDescriptorSets = nullptr; - dynamicOffsetCount = copy_src->dynamicOffsetCount; - pDynamicOffsets = nullptr; + useMinQIndex = copy_src->useMinQIndex; + minQIndex = copy_src->minQIndex; + useMaxQIndex = copy_src->useMaxQIndex; + maxQIndex = copy_src->maxQIndex; + useMaxFrameSize = copy_src->useMaxFrameSize; + maxFrameSize = copy_src->maxFrameSize; pNext = SafePnextCopy(copy_src->pNext); - if (descriptorSetCount && copy_src->pDescriptorSets) { - pDescriptorSets = new VkDescriptorSet[descriptorSetCount]; - for (uint32_t i = 0; i < descriptorSetCount; ++i) { - pDescriptorSets[i] = copy_src->pDescriptorSets[i]; - } - } - - if (copy_src->pDynamicOffsets) { - pDynamicOffsets = new uint32_t[copy_src->dynamicOffsetCount]; - memcpy((void*)pDynamicOffsets, (void*)copy_src->pDynamicOffsets, sizeof(uint32_t) * copy_src->dynamicOffsetCount); - } } -safe_VkPushConstantsInfoKHR::safe_VkPushConstantsInfoKHR(const VkPushConstantsInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - layout(in_struct->layout), - stageFlags(in_struct->stageFlags), - offset(in_struct->offset), - size(in_struct->size), - pValues(in_struct->pValues) { +safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR( + const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), videoMaintenance1(in_struct->videoMaintenance1) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPushConstantsInfoKHR::safe_VkPushConstantsInfoKHR() - : sType(VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR), - pNext(nullptr), - layout(), - stageFlags(), - offset(), - size(), - pValues(nullptr) {} +safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR), pNext(nullptr), videoMaintenance1() {} -safe_VkPushConstantsInfoKHR::safe_VkPushConstantsInfoKHR(const safe_VkPushConstantsInfoKHR& copy_src) { +safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR( + const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src) { sType = copy_src.sType; - layout = copy_src.layout; - stageFlags = copy_src.stageFlags; - offset = copy_src.offset; - size = copy_src.size; - pValues = copy_src.pValues; + videoMaintenance1 = copy_src.videoMaintenance1; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPushConstantsInfoKHR& safe_VkPushConstantsInfoKHR::operator=(const safe_VkPushConstantsInfoKHR& copy_src) { +safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::operator=( + const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - layout = copy_src.layout; - stageFlags = copy_src.stageFlags; - offset = copy_src.offset; - size = copy_src.size; - pValues = copy_src.pValues; + videoMaintenance1 = copy_src.videoMaintenance1; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPushConstantsInfoKHR::~safe_VkPushConstantsInfoKHR() { FreePnextChain(pNext); } +safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::~safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR() { FreePnextChain(pNext); } -void safe_VkPushConstantsInfoKHR::initialize(const VkPushConstantsInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::initialize(const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - layout = in_struct->layout; - stageFlags = in_struct->stageFlags; - offset = in_struct->offset; - size = in_struct->size; - pValues = in_struct->pValues; + videoMaintenance1 = in_struct->videoMaintenance1; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPushConstantsInfoKHR::initialize(const safe_VkPushConstantsInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::initialize( + const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - layout = copy_src->layout; - stageFlags = copy_src->stageFlags; - offset = copy_src->offset; - size = copy_src->size; - pValues = copy_src->pValues; + videoMaintenance1 = copy_src->videoMaintenance1; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPushDescriptorSetInfoKHR::safe_VkPushDescriptorSetInfoKHR(const VkPushDescriptorSetInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkVideoInlineQueryInfoKHR::safe_VkVideoInlineQueryInfoKHR(const VkVideoInlineQueryInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), - stageFlags(in_struct->stageFlags), - layout(in_struct->layout), - set(in_struct->set), - descriptorWriteCount(in_struct->descriptorWriteCount), - pDescriptorWrites(nullptr) { + queryPool(in_struct->queryPool), + firstQuery(in_struct->firstQuery), + queryCount(in_struct->queryCount) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (descriptorWriteCount && in_struct->pDescriptorWrites) { - pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount]; - for (uint32_t i = 0; i < descriptorWriteCount; ++i) { - pDescriptorWrites[i].initialize(&in_struct->pDescriptorWrites[i]); - } - } } -safe_VkPushDescriptorSetInfoKHR::safe_VkPushDescriptorSetInfoKHR() - : sType(VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR), - pNext(nullptr), - stageFlags(), - layout(), - set(), - descriptorWriteCount(), - pDescriptorWrites(nullptr) {} +safe_VkVideoInlineQueryInfoKHR::safe_VkVideoInlineQueryInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR), pNext(nullptr), queryPool(), firstQuery(), queryCount() {} -safe_VkPushDescriptorSetInfoKHR::safe_VkPushDescriptorSetInfoKHR(const safe_VkPushDescriptorSetInfoKHR& copy_src) { +safe_VkVideoInlineQueryInfoKHR::safe_VkVideoInlineQueryInfoKHR(const safe_VkVideoInlineQueryInfoKHR& copy_src) { sType = copy_src.sType; - stageFlags = copy_src.stageFlags; - layout = copy_src.layout; - set = copy_src.set; - descriptorWriteCount = copy_src.descriptorWriteCount; - pDescriptorWrites = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (descriptorWriteCount && copy_src.pDescriptorWrites) { - pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount]; - for (uint32_t i = 0; i < descriptorWriteCount; ++i) { - pDescriptorWrites[i].initialize(©_src.pDescriptorWrites[i]); - } - } + queryPool = copy_src.queryPool; + firstQuery = copy_src.firstQuery; + queryCount = copy_src.queryCount; + pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPushDescriptorSetInfoKHR& safe_VkPushDescriptorSetInfoKHR::operator=(const safe_VkPushDescriptorSetInfoKHR& copy_src) { +safe_VkVideoInlineQueryInfoKHR& safe_VkVideoInlineQueryInfoKHR::operator=(const safe_VkVideoInlineQueryInfoKHR& copy_src) { if (©_src == this) return *this; - if (pDescriptorWrites) delete[] pDescriptorWrites; FreePnextChain(pNext); sType = copy_src.sType; - stageFlags = copy_src.stageFlags; - layout = copy_src.layout; - set = copy_src.set; - descriptorWriteCount = copy_src.descriptorWriteCount; - pDescriptorWrites = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (descriptorWriteCount && copy_src.pDescriptorWrites) { - pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount]; - for (uint32_t i = 0; i < descriptorWriteCount; ++i) { - pDescriptorWrites[i].initialize(©_src.pDescriptorWrites[i]); - } - } + queryPool = copy_src.queryPool; + firstQuery = copy_src.firstQuery; + queryCount = copy_src.queryCount; + pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPushDescriptorSetInfoKHR::~safe_VkPushDescriptorSetInfoKHR() { - if (pDescriptorWrites) delete[] pDescriptorWrites; - FreePnextChain(pNext); -} +safe_VkVideoInlineQueryInfoKHR::~safe_VkVideoInlineQueryInfoKHR() { FreePnextChain(pNext); } -void safe_VkPushDescriptorSetInfoKHR::initialize(const VkPushDescriptorSetInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pDescriptorWrites) delete[] pDescriptorWrites; +void safe_VkVideoInlineQueryInfoKHR::initialize(const VkVideoInlineQueryInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - stageFlags = in_struct->stageFlags; - layout = in_struct->layout; - set = in_struct->set; - descriptorWriteCount = in_struct->descriptorWriteCount; - pDescriptorWrites = nullptr; + queryPool = in_struct->queryPool; + firstQuery = in_struct->firstQuery; + queryCount = in_struct->queryCount; pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (descriptorWriteCount && in_struct->pDescriptorWrites) { - pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount]; - for (uint32_t i = 0; i < descriptorWriteCount; ++i) { - pDescriptorWrites[i].initialize(&in_struct->pDescriptorWrites[i]); - } - } } -void safe_VkPushDescriptorSetInfoKHR::initialize(const safe_VkPushDescriptorSetInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoInlineQueryInfoKHR::initialize(const safe_VkVideoInlineQueryInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - stageFlags = copy_src->stageFlags; - layout = copy_src->layout; - set = copy_src->set; - descriptorWriteCount = copy_src->descriptorWriteCount; - pDescriptorWrites = nullptr; + queryPool = copy_src->queryPool; + firstQuery = copy_src->firstQuery; + queryCount = copy_src->queryCount; pNext = SafePnextCopy(copy_src->pNext); - if (descriptorWriteCount && copy_src->pDescriptorWrites) { - pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount]; - for (uint32_t i = 0; i < descriptorWriteCount; ++i) { - pDescriptorWrites[i].initialize(©_src->pDescriptorWrites[i]); - } - } } -safe_VkPushDescriptorSetWithTemplateInfoKHR::safe_VkPushDescriptorSetWithTemplateInfoKHR( - const VkPushDescriptorSetWithTemplateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - descriptorUpdateTemplate(in_struct->descriptorUpdateTemplate), - layout(in_struct->layout), - set(in_struct->set), - pData(nullptr) { +safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR(const VkCalibratedTimestampInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), timeDomain(in_struct->timeDomain) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPushDescriptorSetWithTemplateInfoKHR::safe_VkPushDescriptorSetWithTemplateInfoKHR() - : sType(VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR), - pNext(nullptr), - descriptorUpdateTemplate(), - layout(), - set(), - pData(nullptr) {} +safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR() + : sType(VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR), pNext(nullptr), timeDomain() {} -safe_VkPushDescriptorSetWithTemplateInfoKHR::safe_VkPushDescriptorSetWithTemplateInfoKHR( - const safe_VkPushDescriptorSetWithTemplateInfoKHR& copy_src) { +safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR(const safe_VkCalibratedTimestampInfoKHR& copy_src) { sType = copy_src.sType; - descriptorUpdateTemplate = copy_src.descriptorUpdateTemplate; - layout = copy_src.layout; - set = copy_src.set; + timeDomain = copy_src.timeDomain; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPushDescriptorSetWithTemplateInfoKHR& safe_VkPushDescriptorSetWithTemplateInfoKHR::operator=( - const safe_VkPushDescriptorSetWithTemplateInfoKHR& copy_src) { +safe_VkCalibratedTimestampInfoKHR& safe_VkCalibratedTimestampInfoKHR::operator=(const safe_VkCalibratedTimestampInfoKHR& copy_src) { if (©_src == this) return *this; - if (pData != nullptr) { - auto temp = reinterpret_cast(pData); - delete[] temp; - } FreePnextChain(pNext); sType = copy_src.sType; - descriptorUpdateTemplate = copy_src.descriptorUpdateTemplate; - layout = copy_src.layout; - set = copy_src.set; + timeDomain = copy_src.timeDomain; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPushDescriptorSetWithTemplateInfoKHR::~safe_VkPushDescriptorSetWithTemplateInfoKHR() { - if (pData != nullptr) { - auto temp = reinterpret_cast(pData); - delete[] temp; - } - FreePnextChain(pNext); -} +safe_VkCalibratedTimestampInfoKHR::~safe_VkCalibratedTimestampInfoKHR() { FreePnextChain(pNext); } -void safe_VkPushDescriptorSetWithTemplateInfoKHR::initialize(const VkPushDescriptorSetWithTemplateInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pData != nullptr) { - auto temp = reinterpret_cast(pData); - delete[] temp; - } +void safe_VkCalibratedTimestampInfoKHR::initialize(const VkCalibratedTimestampInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - descriptorUpdateTemplate = in_struct->descriptorUpdateTemplate; - layout = in_struct->layout; - set = in_struct->set; + timeDomain = in_struct->timeDomain; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPushDescriptorSetWithTemplateInfoKHR::initialize(const safe_VkPushDescriptorSetWithTemplateInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkCalibratedTimestampInfoKHR::initialize(const safe_VkCalibratedTimestampInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - descriptorUpdateTemplate = copy_src->descriptorUpdateTemplate; - layout = copy_src->layout; - set = copy_src->set; + timeDomain = copy_src->timeDomain; pNext = SafePnextCopy(copy_src->pNext); } diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp index 1f1f6fe..660a5f0 100644 --- a/src/vulkan/vk_safe_struct_utils.cpp +++ b/src/vulkan/vk_safe_struct_utils.cpp @@ -387,6 +387,108 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: safe_pNext = new safe_VkPhysicalDeviceMaintenance4Properties(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceVulkan14Features(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceVulkan14Properties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: + safe_pNext = new safe_VkDeviceQueueGlobalPriorityCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceGlobalPriorityQueryFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: + safe_pNext = new safe_VkQueueFamilyGlobalPriorityProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceShaderSubgroupRotateFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceShaderFloatControls2Features(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceShaderExpectAssumeFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceLineRasterizationFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceLineRasterizationProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: + safe_pNext = new safe_VkPipelineRasterizationLineStateCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceVertexAttributeDivisorProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: + safe_pNext = new safe_VkPipelineVertexInputDivisorStateCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceVertexAttributeDivisorFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceIndexTypeUint8Features(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceMaintenance5Features(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceMaintenance5Properties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: + safe_pNext = new safe_VkPipelineCreateFlags2CreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: + safe_pNext = new safe_VkBufferUsageFlags2CreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: + safe_pNext = new safe_VkPhysicalDevicePushDescriptorProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: + safe_pNext = new safe_VkRenderingAttachmentLocationInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: + safe_pNext = new safe_VkRenderingInputAttachmentIndexInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceMaintenance6Features(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceMaintenance6Properties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: + safe_pNext = new safe_VkBindMemoryStatus(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: + safe_pNext = new safe_VkPhysicalDevicePipelineProtectedAccessFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: + safe_pNext = new safe_VkPhysicalDevicePipelineRobustnessFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: + safe_pNext = new safe_VkPhysicalDevicePipelineRobustnessProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: + safe_pNext = new safe_VkPipelineRobustnessCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceHostImageCopyFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceHostImageCopyProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: + safe_pNext = new safe_VkSubresourceHostMemcpySize(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: + safe_pNext = new safe_VkHostImageCopyDevicePerformanceQuery(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: safe_pNext = new safe_VkImageSwapchainCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -538,9 +640,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { safe_pNext = new safe_VkD3D12FenceSubmitInfoKHR(reinterpret_cast(pNext), copy_state, false); break; #endif // VK_USE_PLATFORM_WIN32_KHR - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: - safe_pNext = new safe_VkPhysicalDevicePushDescriptorPropertiesKHR(reinterpret_cast(pNext), copy_state, false); - break; case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: safe_pNext = new safe_VkPresentRegionsKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -593,15 +692,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: safe_pNext = new safe_VkVideoDecodeH265DpbSlotInfoKHR(reinterpret_cast(pNext), copy_state, false); break; - case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: - safe_pNext = new safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: - safe_pNext = new safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: - safe_pNext = new safe_VkQueueFamilyGlobalPriorityPropertiesKHR(reinterpret_cast(pNext), copy_state, false); - break; case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: safe_pNext = new safe_VkFragmentShadingRateAttachmentInfoKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -617,15 +707,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: safe_pNext = new safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(reinterpret_cast(pNext), copy_state, false); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR: - safe_pNext = new safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR: - safe_pNext = new safe_VkRenderingAttachmentLocationInfoKHR(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR: - safe_pNext = new safe_VkRenderingInputAttachmentIndexInfoKHR(reinterpret_cast(pNext), copy_state, false); - break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: safe_pNext = new safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -677,24 +758,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: safe_pNext = new safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(reinterpret_cast(pNext), copy_state, false); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR: - safe_pNext = new safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(reinterpret_cast(pNext), copy_state, false); - break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: safe_pNext = new safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(reinterpret_cast(pNext), copy_state, false); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: - safe_pNext = new safe_VkPhysicalDeviceMaintenance5FeaturesKHR(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: - safe_pNext = new safe_VkPhysicalDeviceMaintenance5PropertiesKHR(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: - safe_pNext = new safe_VkPipelineCreateFlags2CreateInfoKHR(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: - safe_pNext = new safe_VkBufferUsageFlags2CreateInfoKHR(reinterpret_cast(pNext), copy_state, false); - break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: safe_pNext = new safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -776,42 +842,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: safe_pNext = new safe_VkVideoInlineQueryInfoKHR(reinterpret_cast(pNext), copy_state, false); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: - safe_pNext = new safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: - safe_pNext = new safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: - safe_pNext = new safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR: - safe_pNext = new safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR: - safe_pNext = new safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: - safe_pNext = new safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: - safe_pNext = new safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: - safe_pNext = new safe_VkPipelineRasterizationLineStateCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR: - safe_pNext = new safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: - safe_pNext = new safe_VkPhysicalDeviceMaintenance6FeaturesKHR(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: - safe_pNext = new safe_VkPhysicalDeviceMaintenance6PropertiesKHR(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: - safe_pNext = new safe_VkBindMemoryStatusKHR(reinterpret_cast(pNext), copy_state, false); - break; case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR: safe_pNext = new safe_VkVideoEncodeQuantizationMapCapabilitiesKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -916,15 +946,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: safe_pNext = new safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(reinterpret_cast(pNext), copy_state, false); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: - safe_pNext = new safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: - safe_pNext = new safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: - safe_pNext = new safe_VkPipelineRobustnessCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: safe_pNext = new safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(reinterpret_cast(pNext), copy_state, false); break; @@ -1236,18 +1257,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: safe_pNext = new safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(reinterpret_cast(pNext), copy_state, false); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: - safe_pNext = new safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: - safe_pNext = new safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: - safe_pNext = new safe_VkSubresourceHostMemcpySizeEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: - safe_pNext = new safe_VkHostImageCopyDevicePerformanceQueryEXT(reinterpret_cast(pNext), copy_state, false); - break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: safe_pNext = new safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT(reinterpret_cast(pNext), copy_state, false); break; @@ -1758,9 +1767,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: safe_pNext = new safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT(reinterpret_cast(pNext), copy_state, false); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: - safe_pNext = new safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(reinterpret_cast(pNext), copy_state, false); - break; #ifdef VK_USE_PLATFORM_ANDROID_KHR case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID: safe_pNext = new safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID(reinterpret_cast(pNext), copy_state, false); @@ -2360,6 +2366,108 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: delete reinterpret_cast(header); break; @@ -2511,9 +2619,6 @@ void FreePnextChain(const void *pNext) { delete reinterpret_cast(header); break; #endif // VK_USE_PLATFORM_WIN32_KHR - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: - delete reinterpret_cast(header); - break; case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: delete reinterpret_cast(header); break; @@ -2566,15 +2671,6 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: delete reinterpret_cast(header); break; - case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: - delete reinterpret_cast(header); - break; case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: delete reinterpret_cast(header); break; @@ -2590,15 +2686,6 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: delete reinterpret_cast(header); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR: - delete reinterpret_cast(header); - break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: delete reinterpret_cast(header); break; @@ -2650,24 +2737,9 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: delete reinterpret_cast(header); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR: - delete reinterpret_cast(header); - break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: delete reinterpret_cast(header); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: - delete reinterpret_cast(header); - break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: delete reinterpret_cast(header); break; @@ -2749,42 +2821,6 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: delete reinterpret_cast(header); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: - delete reinterpret_cast(header); - break; case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR: delete reinterpret_cast(header); break; @@ -2889,15 +2925,6 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: delete reinterpret_cast(header); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: - delete reinterpret_cast(header); - break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: delete reinterpret_cast(header); break; @@ -3209,18 +3236,6 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: delete reinterpret_cast(header); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: - delete reinterpret_cast(header); - break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: delete reinterpret_cast(header); break; @@ -3731,9 +3746,6 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: delete reinterpret_cast(header); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: - delete reinterpret_cast(header); - break; #ifdef VK_USE_PLATFORM_ANDROID_KHR case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID: delete reinterpret_cast(header);