From bb9744e7d95ce4701272a86699d78bdd95405b75 Mon Sep 17 00:00:00 2001 From: Mike Schuchardt Date: Tue, 19 Dec 2023 11:34:40 -0800 Subject: [PATCH] build: Update to header 1.3.274 - Update known-good - Fix crash in extension_helper_generator when an extension has an explicit dependency on VK_VERSION_1_0 - Stub out safe struct constructor for VkPushDescriptorSetWithTemplateInfoKHR until it can be properly implemented #7169 - VUID renames: - VUID-VkDescriptorSetLayoutBinding-descriptorCount-00283 -> 09465 - UNASSIGNED-vkCmdDrawIndirectByteCountEXT-counterOffset -> 09474 - UNASSIGNED-vkCmdDrawIndirectByteCountEXT-vertexStride -> 09475 - Generate source --- layers/VkLayer_khronos_validation.json.in | 4 +- layers/core_checks/cc_drawdispatch.cpp | 4 +- layers/core_checks/cc_video.cpp | 4 +- layers/stateless/sl_descriptor.cpp | 2 +- layers/vulkan/generated/best_practices.cpp | 2 - layers/vulkan/generated/best_practices.h | 2 - layers/vulkan/generated/chassis.cpp | 157 +- layers/vulkan/generated/chassis.h | 39 +- .../generated/chassis_dispatch_helper.h | 38 +- .../vulkan/generated/command_validation.cpp | 42 + layers/vulkan/generated/enum_flag_bits.h | 20 +- .../generated/error_location_helper.cpp | 103 +- .../vulkan/generated/error_location_helper.h | 1370 +- .../generated/feature_requirements_helper.cpp | 56 + .../generated/feature_requirements_helper.h | 8 + .../generated/layer_chassis_dispatch.cpp | 197 +- .../vulkan/generated/layer_chassis_dispatch.h | 11 +- layers/vulkan/generated/object_tracker.cpp | 264 +- layers/vulkan/generated/object_tracker.h | 19 +- .../generated/pnext_chain_extraction.cpp | 299 +- .../vulkan/generated/state_tracker_helper.cpp | 19 + .../vulkan/generated/state_tracker_helper.h | 8 + .../generated/stateless_validation_helper.cpp | 947 +- .../generated/stateless_validation_helper.h | 19 +- layers/vulkan/generated/thread_safety.cpp | 86 +- .../vulkan/generated/thread_safety_commands.h | 46 +- layers/vulkan/generated/valid_enum_values.cpp | 2 - layers/vulkan/generated/valid_enum_values.h | 2 - .../generated/vk_dispatch_table_helper.h | 54 +- layers/vulkan/generated/vk_extension_helper.h | 41 +- .../vulkan/generated/vk_function_pointers.cpp | 28 +- .../vulkan/generated/vk_function_pointers.h | 8 +- .../generated/vk_layer_dispatch_table.h | 10 +- layers/vulkan/generated/vk_safe_struct.h | 5151 ++++---- .../vulkan/generated/vk_safe_struct_ext.cpp | 2582 +--- .../vulkan/generated/vk_safe_struct_khr.cpp | 11004 ++++++++++------ .../vulkan/generated/vk_safe_struct_utils.cpp | 362 +- .../generated/vk_safe_struct_vendor.cpp | 59 + .../generated/vk_validation_error_messages.h | 607 +- .../generators/extension_helper_generator.py | 6 + scripts/generators/safe_struct_generator.py | 6 +- scripts/known_good.json | 6 +- .../layers/VkLayer_device_profile_api.json.in | 2 +- tests/unit/descriptors.cpp | 2 +- tests/unit/transform_feedback.cpp | 6 +- 45 files changed, 13343 insertions(+), 10361 deletions(-) diff --git a/layers/VkLayer_khronos_validation.json.in b/layers/VkLayer_khronos_validation.json.in index bb7d9221f07..148af9ad1ad 100644 --- a/layers/VkLayer_khronos_validation.json.in +++ b/layers/VkLayer_khronos_validation.json.in @@ -4,7 +4,7 @@ "name": "VK_LAYER_KHRONOS_validation", "type": "GLOBAL", "library_path": "@JSON_LIBRARY_PATH@", - "api_version": "1.3.273", + "api_version": "1.3.274", "implementation_version": "1", "description": "Khronos Validation Layer", "introduction": "The main, comprehensive Khronos validation layer.\n\nVulkan is an Explicit API, enabling direct control over how GPUs actually work. By design, minimal error checking is done inside a Vulkan driver. Applications have full control and responsibility for correct operation. Any errors in how Vulkan is used can result in a crash. \n\nThe Khronos Valiation Layer can be enabled to assist development by enabling developers to verify their applications correctly use the Vulkan API.", @@ -1405,4 +1405,4 @@ ] } } -} +} \ No newline at end of file diff --git a/layers/core_checks/cc_drawdispatch.cpp b/layers/core_checks/cc_drawdispatch.cpp index 0ad3d244b25..5e6ec11561e 100644 --- a/layers/core_checks/cc_drawdispatch.cpp +++ b/layers/core_checks/cc_drawdispatch.cpp @@ -601,12 +601,12 @@ bool CoreChecks::PreCallValidateCmdDrawIndirectByteCountEXT(VkCommandBuffer comm } // VUs being added in https://gitlab.khronos.org/vulkan/vulkan/-/merge_requests/6310 if (SafeModulo(counterOffset, 4) != 0) { - skip |= LogError("UNASSIGNED-vkCmdDrawIndirectByteCountEXT-counterOffset", + skip |= LogError("VUID-vkCmdDrawIndirectByteCountEXT-counterOffset-09474", cb_state.GetObjectList(VK_PIPELINE_BIND_POINT_GRAPHICS), error_obj.location.dot(Field::counterOffset), "(%" PRIu32 ") must be a multiple of 4.", counterOffset); } if (SafeModulo(vertexStride, 4) != 0) { - skip |= LogError("UNASSIGNED-vkCmdDrawIndirectByteCountEXT-vertexStride", + skip |= LogError("VUID-vkCmdDrawIndirectByteCountEXT-vertexStride-09475", cb_state.GetObjectList(VK_PIPELINE_BIND_POINT_GRAPHICS), error_obj.location.dot(Field::vertexStride), "(%" PRIu32 ") must be a multiple of 4.", vertexStride); } diff --git a/layers/core_checks/cc_video.cpp b/layers/core_checks/cc_video.cpp index 6457bf5fa77..f7466592825 100644 --- a/layers/core_checks/cc_video.cpp +++ b/layers/core_checks/cc_video.cpp @@ -217,8 +217,8 @@ bool CoreChecks::ValidateVideoProfileListInfo(const VkVideoProfileListInfoKHR *p has_decode_profile = true; break; - case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT: - case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT: + case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: + case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: has_encode_profile = true; break; diff --git a/layers/stateless/sl_descriptor.cpp b/layers/stateless/sl_descriptor.cpp index ddde714c3b6..e440c1b17f6 100644 --- a/layers/stateless/sl_descriptor.cpp +++ b/layers/stateless/sl_descriptor.cpp @@ -502,7 +502,7 @@ bool StatelessValidation::manual_PreCallValidateCreateDescriptorSetLayout(VkDevi // If descriptorCount is not 0, stageFlags must be a valid combination of VkShaderStageFlagBits values if ((pCreateInfo->pBindings[i].stageFlags != 0) && ((pCreateInfo->pBindings[i].stageFlags & (~AllVkShaderStageFlagBits)) != 0)) { - skip |= LogError("VUID-VkDescriptorSetLayoutBinding-descriptorCount-00283", device, + skip |= LogError("VUID-VkDescriptorSetLayoutBinding-descriptorCount-09465", device, binding_loc.dot(Field::descriptorCount), "is %" PRIu32 " but stageFlags is invalid (0x%" PRIx32 ").", pCreateInfo->pBindings[i].descriptorCount, pCreateInfo->pBindings[i].stageFlags); diff --git a/layers/vulkan/generated/best_practices.cpp b/layers/vulkan/generated/best_practices.cpp index 0be801c6ca1..4f6e699bd0a 100644 --- a/layers/vulkan/generated/best_practices.cpp +++ b/layers/vulkan/generated/best_practices.cpp @@ -1569,7 +1569,6 @@ void BestPractices::PostCallRecordMapMemory2KHR(VkDevice device, const VkMemoryM } } -#ifdef VK_ENABLE_BETA_EXTENSIONS void BestPractices::PostCallRecordGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties, const RecordObject& record_obj) { @@ -1595,7 +1594,6 @@ void BestPractices::PostCallRecordGetEncodedVideoSessionParametersKHR( LogErrorCode(record_obj); } } -#endif // VK_ENABLE_BETA_EXTENSIONS void BestPractices::PostCallRecordQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence, const RecordObject& record_obj) { diff --git a/layers/vulkan/generated/best_practices.h b/layers/vulkan/generated/best_practices.h index a40aaab3aff..a2e77f6f713 100644 --- a/layers/vulkan/generated/best_practices.h +++ b/layers/vulkan/generated/best_practices.h @@ -533,7 +533,6 @@ void PostCallRecordGetPipelineExecutableInternalRepresentationsKHR( void PostCallRecordMapMemory2KHR(VkDevice device, const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData, const RecordObject& record_obj) override; -#ifdef VK_ENABLE_BETA_EXTENSIONS void PostCallRecordGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties, const RecordObject& record_obj) override; @@ -543,7 +542,6 @@ void PostCallRecordGetEncodedVideoSessionParametersKHR(VkDevice device, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData, const RecordObject& record_obj) override; -#endif // VK_ENABLE_BETA_EXTENSIONS void PostCallRecordQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence, const RecordObject& record_obj) override; diff --git a/layers/vulkan/generated/chassis.cpp b/layers/vulkan/generated/chassis.cpp index 925251ff79b..0a88b88c830 100644 --- a/layers/vulkan/generated/chassis.cpp +++ b/layers/vulkan/generated/chassis.cpp @@ -8760,7 +8760,6 @@ VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2KHR(VkDevice device, const VkMemoryUn return result; } -#ifdef VK_ENABLE_BETA_EXTENSIONS VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties) { @@ -8843,7 +8842,6 @@ VKAPI_ATTR void VKAPI_CALL CmdEncodeVideoKHR(VkCommandBuffer commandBuffer, cons } } -#endif // VK_ENABLE_BETA_EXTENSIONS VKAPI_ATTR void VKAPI_CALL CmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; @@ -9423,6 +9421,153 @@ VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsKHR(VkDevice device, uint3 return result; } +VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + bool skip = false; + ErrorObject error_obj(vvl::Func::vkCmdBindDescriptorSets2KHR, VulkanTypedHandle(commandBuffer, kVulkanObjectTypeCommandBuffer)); + for (const ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallValidateCmdBindDescriptorSets2KHR]) { + auto lock = intercept->ReadLock(); + skip |= intercept->PreCallValidateCmdBindDescriptorSets2KHR(commandBuffer, pBindDescriptorSetsInfo, error_obj); + if (skip) return; + } + RecordObject record_obj(vvl::Func::vkCmdBindDescriptorSets2KHR); + for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordCmdBindDescriptorSets2KHR]) { + auto lock = intercept->WriteLock(); + intercept->PreCallRecordCmdBindDescriptorSets2KHR(commandBuffer, pBindDescriptorSetsInfo, record_obj); + } + DispatchCmdBindDescriptorSets2KHR(commandBuffer, pBindDescriptorSetsInfo); + for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordCmdBindDescriptorSets2KHR]) { + auto lock = intercept->WriteLock(); + intercept->PostCallRecordCmdBindDescriptorSets2KHR(commandBuffer, pBindDescriptorSetsInfo, record_obj); + } +} + +VKAPI_ATTR void VKAPI_CALL CmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR* pPushConstantsInfo) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + bool skip = false; + ErrorObject error_obj(vvl::Func::vkCmdPushConstants2KHR, VulkanTypedHandle(commandBuffer, kVulkanObjectTypeCommandBuffer)); + for (const ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallValidateCmdPushConstants2KHR]) { + auto lock = intercept->ReadLock(); + skip |= intercept->PreCallValidateCmdPushConstants2KHR(commandBuffer, pPushConstantsInfo, error_obj); + if (skip) return; + } + RecordObject record_obj(vvl::Func::vkCmdPushConstants2KHR); + for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordCmdPushConstants2KHR]) { + auto lock = intercept->WriteLock(); + intercept->PreCallRecordCmdPushConstants2KHR(commandBuffer, pPushConstantsInfo, record_obj); + } + DispatchCmdPushConstants2KHR(commandBuffer, pPushConstantsInfo); + for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordCmdPushConstants2KHR]) { + auto lock = intercept->WriteLock(); + intercept->PostCallRecordCmdPushConstants2KHR(commandBuffer, pPushConstantsInfo, record_obj); + } +} + +VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + bool skip = false; + ErrorObject error_obj(vvl::Func::vkCmdPushDescriptorSet2KHR, VulkanTypedHandle(commandBuffer, kVulkanObjectTypeCommandBuffer)); + for (const ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallValidateCmdPushDescriptorSet2KHR]) { + auto lock = intercept->ReadLock(); + skip |= intercept->PreCallValidateCmdPushDescriptorSet2KHR(commandBuffer, pPushDescriptorSetInfo, error_obj); + if (skip) return; + } + RecordObject record_obj(vvl::Func::vkCmdPushDescriptorSet2KHR); + for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordCmdPushDescriptorSet2KHR]) { + auto lock = intercept->WriteLock(); + intercept->PreCallRecordCmdPushDescriptorSet2KHR(commandBuffer, pPushDescriptorSetInfo, record_obj); + } + DispatchCmdPushDescriptorSet2KHR(commandBuffer, pPushDescriptorSetInfo); + for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordCmdPushDescriptorSet2KHR]) { + auto lock = intercept->WriteLock(); + intercept->PostCallRecordCmdPushDescriptorSet2KHR(commandBuffer, pPushDescriptorSetInfo, record_obj); + } +} + +VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + bool skip = false; + ErrorObject error_obj(vvl::Func::vkCmdPushDescriptorSetWithTemplate2KHR, + VulkanTypedHandle(commandBuffer, kVulkanObjectTypeCommandBuffer)); + for (const ValidationObject* intercept : + layer_data->intercept_vectors[InterceptIdPreCallValidateCmdPushDescriptorSetWithTemplate2KHR]) { + auto lock = intercept->ReadLock(); + skip |= intercept->PreCallValidateCmdPushDescriptorSetWithTemplate2KHR(commandBuffer, pPushDescriptorSetWithTemplateInfo, + error_obj); + if (skip) return; + } + RecordObject record_obj(vvl::Func::vkCmdPushDescriptorSetWithTemplate2KHR); + for (ValidationObject* intercept : + layer_data->intercept_vectors[InterceptIdPreCallRecordCmdPushDescriptorSetWithTemplate2KHR]) { + auto lock = intercept->WriteLock(); + intercept->PreCallRecordCmdPushDescriptorSetWithTemplate2KHR(commandBuffer, pPushDescriptorSetWithTemplateInfo, record_obj); + } + DispatchCmdPushDescriptorSetWithTemplate2KHR(commandBuffer, pPushDescriptorSetWithTemplateInfo); + for (ValidationObject* intercept : + layer_data->intercept_vectors[InterceptIdPostCallRecordCmdPushDescriptorSetWithTemplate2KHR]) { + auto lock = intercept->WriteLock(); + intercept->PostCallRecordCmdPushDescriptorSetWithTemplate2KHR(commandBuffer, pPushDescriptorSetWithTemplateInfo, + record_obj); + } +} + +VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsets2EXT( + VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + bool skip = false; + ErrorObject error_obj(vvl::Func::vkCmdSetDescriptorBufferOffsets2EXT, + VulkanTypedHandle(commandBuffer, kVulkanObjectTypeCommandBuffer)); + for (const ValidationObject* intercept : + layer_data->intercept_vectors[InterceptIdPreCallValidateCmdSetDescriptorBufferOffsets2EXT]) { + auto lock = intercept->ReadLock(); + skip |= + intercept->PreCallValidateCmdSetDescriptorBufferOffsets2EXT(commandBuffer, pSetDescriptorBufferOffsetsInfo, error_obj); + if (skip) return; + } + RecordObject record_obj(vvl::Func::vkCmdSetDescriptorBufferOffsets2EXT); + for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordCmdSetDescriptorBufferOffsets2EXT]) { + auto lock = intercept->WriteLock(); + intercept->PreCallRecordCmdSetDescriptorBufferOffsets2EXT(commandBuffer, pSetDescriptorBufferOffsetsInfo, record_obj); + } + DispatchCmdSetDescriptorBufferOffsets2EXT(commandBuffer, pSetDescriptorBufferOffsetsInfo); + for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordCmdSetDescriptorBufferOffsets2EXT]) { + auto lock = intercept->WriteLock(); + intercept->PostCallRecordCmdSetDescriptorBufferOffsets2EXT(commandBuffer, pSetDescriptorBufferOffsetsInfo, record_obj); + } +} + +VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + bool skip = false; + ErrorObject error_obj(vvl::Func::vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, + VulkanTypedHandle(commandBuffer, kVulkanObjectTypeCommandBuffer)); + for (const ValidationObject* intercept : + layer_data->intercept_vectors[InterceptIdPreCallValidateCmdBindDescriptorBufferEmbeddedSamplers2EXT]) { + auto lock = intercept->ReadLock(); + skip |= intercept->PreCallValidateCmdBindDescriptorBufferEmbeddedSamplers2EXT( + commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo, error_obj); + if (skip) return; + } + RecordObject record_obj(vvl::Func::vkCmdBindDescriptorBufferEmbeddedSamplers2EXT); + for (ValidationObject* intercept : + layer_data->intercept_vectors[InterceptIdPreCallRecordCmdBindDescriptorBufferEmbeddedSamplers2EXT]) { + auto lock = intercept->WriteLock(); + intercept->PreCallRecordCmdBindDescriptorBufferEmbeddedSamplers2EXT(commandBuffer, + pBindDescriptorBufferEmbeddedSamplersInfo, record_obj); + } + DispatchCmdBindDescriptorBufferEmbeddedSamplers2EXT(commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo); + for (ValidationObject* intercept : + layer_data->intercept_vectors[InterceptIdPostCallRecordCmdBindDescriptorBufferEmbeddedSamplers2EXT]) { + auto lock = intercept->WriteLock(); + intercept->PostCallRecordCmdBindDescriptorBufferEmbeddedSamplers2EXT(commandBuffer, + pBindDescriptorBufferEmbeddedSamplersInfo, record_obj); + } +} + VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, @@ -17215,11 +17360,9 @@ const vvl::unordered_map name_to_funcptr_map = { {"vkGetPipelineExecutableInternalRepresentationsKHR", {kFuncTypeDev, (void*)GetPipelineExecutableInternalRepresentationsKHR}}, {"vkMapMemory2KHR", {kFuncTypeDev, (void*)MapMemory2KHR}}, {"vkUnmapMemory2KHR", {kFuncTypeDev, (void*)UnmapMemory2KHR}}, -#ifdef VK_ENABLE_BETA_EXTENSIONS {"vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR", {kFuncTypePdev, (void*)GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR}}, {"vkGetEncodedVideoSessionParametersKHR", {kFuncTypeDev, (void*)GetEncodedVideoSessionParametersKHR}}, {"vkCmdEncodeVideoKHR", {kFuncTypeDev, (void*)CmdEncodeVideoKHR}}, -#endif // VK_ENABLE_BETA_EXTENSIONS {"vkCmdSetEvent2KHR", {kFuncTypeDev, (void*)CmdSetEvent2KHR}}, {"vkCmdResetEvent2KHR", {kFuncTypeDev, (void*)CmdResetEvent2KHR}}, {"vkCmdWaitEvents2KHR", {kFuncTypeDev, (void*)CmdWaitEvents2KHR}}, @@ -17245,6 +17388,12 @@ const vvl::unordered_map name_to_funcptr_map = { {"vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", {kFuncTypePdev, (void*)GetPhysicalDeviceCooperativeMatrixPropertiesKHR}}, {"vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", {kFuncTypePdev, (void*)GetPhysicalDeviceCalibrateableTimeDomainsKHR}}, {"vkGetCalibratedTimestampsKHR", {kFuncTypeDev, (void*)GetCalibratedTimestampsKHR}}, + {"vkCmdBindDescriptorSets2KHR", {kFuncTypeDev, (void*)CmdBindDescriptorSets2KHR}}, + {"vkCmdPushConstants2KHR", {kFuncTypeDev, (void*)CmdPushConstants2KHR}}, + {"vkCmdPushDescriptorSet2KHR", {kFuncTypeDev, (void*)CmdPushDescriptorSet2KHR}}, + {"vkCmdPushDescriptorSetWithTemplate2KHR", {kFuncTypeDev, (void*)CmdPushDescriptorSetWithTemplate2KHR}}, + {"vkCmdSetDescriptorBufferOffsets2EXT", {kFuncTypeDev, (void*)CmdSetDescriptorBufferOffsets2EXT}}, + {"vkCmdBindDescriptorBufferEmbeddedSamplers2EXT", {kFuncTypeDev, (void*)CmdBindDescriptorBufferEmbeddedSamplers2EXT}}, {"vkCreateDebugReportCallbackEXT", {kFuncTypeInst, (void*)CreateDebugReportCallbackEXT}}, {"vkDestroyDebugReportCallbackEXT", {kFuncTypeInst, (void*)DestroyDebugReportCallbackEXT}}, {"vkDebugReportMessageEXT", {kFuncTypeInst, (void*)DebugReportMessageEXT}}, diff --git a/layers/vulkan/generated/chassis.h b/layers/vulkan/generated/chassis.h index d52eafe056c..be8276e04c2 100644 --- a/layers/vulkan/generated/chassis.h +++ b/layers/vulkan/generated/chassis.h @@ -1064,7 +1064,6 @@ VKAPI_ATTR VkResult VKAPI_CALL MapMemory2KHR(VkDevice device, const VkMemoryMapI VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo); -#ifdef VK_ENABLE_BETA_EXTENSIONS VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties); @@ -1075,7 +1074,6 @@ GetEncodedVideoSessionParametersKHR(VkDevice device, const VkVideoEncodeSessionP VKAPI_ATTR void VKAPI_CALL CmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo); -#endif // VK_ENABLE_BETA_EXTENSIONS VKAPI_ATTR void VKAPI_CALL CmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); VKAPI_ATTR void VKAPI_CALL CmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); @@ -1146,6 +1144,23 @@ VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsKHR(VkDevice device, uint3 const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); +VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo); + +VKAPI_ATTR void VKAPI_CALL CmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR* pPushConstantsInfo); + +VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo); + +VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo); + +VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsets2EXT( + VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo); + +VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo); + VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, @@ -3472,7 +3487,6 @@ class ValidationObject { virtual bool PreCallValidateUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo, const ErrorObject& error_obj) const { return false; }; virtual void PreCallRecordUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo, const RecordObject& record_obj) {}; virtual void PostCallRecordUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo, const RecordObject& record_obj) {}; -#ifdef VK_ENABLE_BETA_EXTENSIONS virtual bool PreCallValidateGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties, const ErrorObject& error_obj) const { return false; }; virtual void PreCallRecordGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties, const RecordObject& record_obj) {}; virtual void PostCallRecordGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties, const RecordObject& record_obj) {}; @@ -3482,7 +3496,6 @@ class ValidationObject { virtual bool PreCallValidateCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo, const ErrorObject& error_obj) const { return false; }; virtual void PreCallRecordCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo, const RecordObject& record_obj) {}; virtual void PostCallRecordCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo, const RecordObject& record_obj) {}; -#endif // VK_ENABLE_BETA_EXTENSIONS virtual bool PreCallValidateCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo, const ErrorObject& error_obj) const { return false; }; virtual void PreCallRecordCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo, const RecordObject& record_obj) {}; virtual void PostCallRecordCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo, const RecordObject& record_obj) {}; @@ -3558,6 +3571,24 @@ class ValidationObject { virtual bool PreCallValidateGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, const ErrorObject& error_obj) const { return false; }; virtual void PreCallRecordGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, const RecordObject& record_obj) {}; virtual void PostCallRecordGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, const RecordObject& record_obj) {}; + virtual bool PreCallValidateCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo, const ErrorObject& error_obj) const { return false; }; + virtual void PreCallRecordCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo, const RecordObject& record_obj) {}; + virtual void PostCallRecordCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo, const RecordObject& record_obj) {}; + virtual bool PreCallValidateCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR* pPushConstantsInfo, const ErrorObject& error_obj) const { return false; }; + virtual void PreCallRecordCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR* pPushConstantsInfo, const RecordObject& record_obj) {}; + virtual void PostCallRecordCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR* pPushConstantsInfo, const RecordObject& record_obj) {}; + virtual bool PreCallValidateCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo, const ErrorObject& error_obj) const { return false; }; + virtual void PreCallRecordCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo, const RecordObject& record_obj) {}; + virtual void PostCallRecordCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo, const RecordObject& record_obj) {}; + virtual bool PreCallValidateCmdPushDescriptorSetWithTemplate2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo, const ErrorObject& error_obj) const { return false; }; + virtual void PreCallRecordCmdPushDescriptorSetWithTemplate2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo, const RecordObject& record_obj) {}; + virtual void PostCallRecordCmdPushDescriptorSetWithTemplate2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo, const RecordObject& record_obj) {}; + virtual bool PreCallValidateCmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo, const ErrorObject& error_obj) const { return false; }; + virtual void PreCallRecordCmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo, const RecordObject& record_obj) {}; + virtual void PostCallRecordCmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo, const RecordObject& record_obj) {}; + virtual bool PreCallValidateCmdBindDescriptorBufferEmbeddedSamplers2EXT(VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo, const ErrorObject& error_obj) const { return false; }; + virtual void PreCallRecordCmdBindDescriptorBufferEmbeddedSamplers2EXT(VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo, const RecordObject& record_obj) {}; + virtual void PostCallRecordCmdBindDescriptorBufferEmbeddedSamplers2EXT(VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo, const RecordObject& record_obj) {}; virtual bool PreCallValidateCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback, const ErrorObject& error_obj) const { return false; }; virtual void PreCallRecordCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback, const RecordObject& record_obj) {}; virtual void PostCallRecordCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback, const RecordObject& record_obj) {}; diff --git a/layers/vulkan/generated/chassis_dispatch_helper.h b/layers/vulkan/generated/chassis_dispatch_helper.h index 2a72c5762d5..a628cb9e311 100644 --- a/layers/vulkan/generated/chassis_dispatch_helper.h +++ b/layers/vulkan/generated/chassis_dispatch_helper.h @@ -876,6 +876,24 @@ typedef enum InterceptId { InterceptIdPreCallValidateGetCalibratedTimestampsKHR, InterceptIdPreCallRecordGetCalibratedTimestampsKHR, InterceptIdPostCallRecordGetCalibratedTimestampsKHR, + InterceptIdPreCallValidateCmdBindDescriptorSets2KHR, + InterceptIdPreCallRecordCmdBindDescriptorSets2KHR, + InterceptIdPostCallRecordCmdBindDescriptorSets2KHR, + InterceptIdPreCallValidateCmdPushConstants2KHR, + InterceptIdPreCallRecordCmdPushConstants2KHR, + InterceptIdPostCallRecordCmdPushConstants2KHR, + InterceptIdPreCallValidateCmdPushDescriptorSet2KHR, + InterceptIdPreCallRecordCmdPushDescriptorSet2KHR, + InterceptIdPostCallRecordCmdPushDescriptorSet2KHR, + InterceptIdPreCallValidateCmdPushDescriptorSetWithTemplate2KHR, + InterceptIdPreCallRecordCmdPushDescriptorSetWithTemplate2KHR, + InterceptIdPostCallRecordCmdPushDescriptorSetWithTemplate2KHR, + InterceptIdPreCallValidateCmdSetDescriptorBufferOffsets2EXT, + InterceptIdPreCallRecordCmdSetDescriptorBufferOffsets2EXT, + InterceptIdPostCallRecordCmdSetDescriptorBufferOffsets2EXT, + InterceptIdPreCallValidateCmdBindDescriptorBufferEmbeddedSamplers2EXT, + InterceptIdPreCallRecordCmdBindDescriptorBufferEmbeddedSamplers2EXT, + InterceptIdPostCallRecordCmdBindDescriptorBufferEmbeddedSamplers2EXT, InterceptIdPreCallValidateDebugMarkerSetObjectTagEXT, InterceptIdPreCallRecordDebugMarkerSetObjectTagEXT, InterceptIdPostCallRecordDebugMarkerSetObjectTagEXT, @@ -2515,14 +2533,12 @@ void ValidationObject::InitObjectDispatchVectors() { BUILD_DISPATCH_VECTOR(PreCallValidateUnmapMemory2KHR); BUILD_DISPATCH_VECTOR(PreCallRecordUnmapMemory2KHR); BUILD_DISPATCH_VECTOR(PostCallRecordUnmapMemory2KHR); -#ifdef VK_ENABLE_BETA_EXTENSIONS BUILD_DISPATCH_VECTOR(PreCallValidateGetEncodedVideoSessionParametersKHR); BUILD_DISPATCH_VECTOR(PreCallRecordGetEncodedVideoSessionParametersKHR); BUILD_DISPATCH_VECTOR(PostCallRecordGetEncodedVideoSessionParametersKHR); BUILD_DISPATCH_VECTOR(PreCallValidateCmdEncodeVideoKHR); BUILD_DISPATCH_VECTOR(PreCallRecordCmdEncodeVideoKHR); BUILD_DISPATCH_VECTOR(PostCallRecordCmdEncodeVideoKHR); -#endif // VK_ENABLE_BETA_EXTENSIONS BUILD_DISPATCH_VECTOR(PreCallValidateCmdSetEvent2KHR); BUILD_DISPATCH_VECTOR(PreCallRecordCmdSetEvent2KHR); BUILD_DISPATCH_VECTOR(PostCallRecordCmdSetEvent2KHR); @@ -2592,6 +2608,24 @@ void ValidationObject::InitObjectDispatchVectors() { BUILD_DISPATCH_VECTOR(PreCallValidateGetCalibratedTimestampsKHR); BUILD_DISPATCH_VECTOR(PreCallRecordGetCalibratedTimestampsKHR); BUILD_DISPATCH_VECTOR(PostCallRecordGetCalibratedTimestampsKHR); + BUILD_DISPATCH_VECTOR(PreCallValidateCmdBindDescriptorSets2KHR); + BUILD_DISPATCH_VECTOR(PreCallRecordCmdBindDescriptorSets2KHR); + BUILD_DISPATCH_VECTOR(PostCallRecordCmdBindDescriptorSets2KHR); + BUILD_DISPATCH_VECTOR(PreCallValidateCmdPushConstants2KHR); + BUILD_DISPATCH_VECTOR(PreCallRecordCmdPushConstants2KHR); + BUILD_DISPATCH_VECTOR(PostCallRecordCmdPushConstants2KHR); + BUILD_DISPATCH_VECTOR(PreCallValidateCmdPushDescriptorSet2KHR); + BUILD_DISPATCH_VECTOR(PreCallRecordCmdPushDescriptorSet2KHR); + BUILD_DISPATCH_VECTOR(PostCallRecordCmdPushDescriptorSet2KHR); + BUILD_DISPATCH_VECTOR(PreCallValidateCmdPushDescriptorSetWithTemplate2KHR); + BUILD_DISPATCH_VECTOR(PreCallRecordCmdPushDescriptorSetWithTemplate2KHR); + BUILD_DISPATCH_VECTOR(PostCallRecordCmdPushDescriptorSetWithTemplate2KHR); + BUILD_DISPATCH_VECTOR(PreCallValidateCmdSetDescriptorBufferOffsets2EXT); + BUILD_DISPATCH_VECTOR(PreCallRecordCmdSetDescriptorBufferOffsets2EXT); + BUILD_DISPATCH_VECTOR(PostCallRecordCmdSetDescriptorBufferOffsets2EXT); + BUILD_DISPATCH_VECTOR(PreCallValidateCmdBindDescriptorBufferEmbeddedSamplers2EXT); + BUILD_DISPATCH_VECTOR(PreCallRecordCmdBindDescriptorBufferEmbeddedSamplers2EXT); + BUILD_DISPATCH_VECTOR(PostCallRecordCmdBindDescriptorBufferEmbeddedSamplers2EXT); BUILD_DISPATCH_VECTOR(PreCallValidateDebugMarkerSetObjectTagEXT); BUILD_DISPATCH_VECTOR(PreCallRecordDebugMarkerSetObjectTagEXT); BUILD_DISPATCH_VECTOR(PostCallRecordDebugMarkerSetObjectTagEXT); diff --git a/layers/vulkan/generated/command_validation.cpp b/layers/vulkan/generated/command_validation.cpp index 00f20579658..8c483eab6e9 100644 --- a/layers/vulkan/generated/command_validation.cpp +++ b/layers/vulkan/generated/command_validation.cpp @@ -813,6 +813,48 @@ static const vvl::unordered_map kCommandValidationT CMD_SCOPE_BOTH, "kVUIDUndefined", CMD_SCOPE_OUTSIDE, "VUID-vkCmdBindIndexBuffer2KHR-videocoding", }}, +{Func::vkCmdBindDescriptorSets2KHR, { + "VUID-vkCmdBindDescriptorSets2KHR-commandBuffer-recording", + nullptr, + VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, "VUID-vkCmdBindDescriptorSets2KHR-commandBuffer-cmdpool", + CMD_SCOPE_BOTH, "kVUIDUndefined", + CMD_SCOPE_OUTSIDE, "VUID-vkCmdBindDescriptorSets2KHR-videocoding", +}}, +{Func::vkCmdPushConstants2KHR, { + "VUID-vkCmdPushConstants2KHR-commandBuffer-recording", + nullptr, + VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, "VUID-vkCmdPushConstants2KHR-commandBuffer-cmdpool", + CMD_SCOPE_BOTH, "kVUIDUndefined", + CMD_SCOPE_OUTSIDE, "VUID-vkCmdPushConstants2KHR-videocoding", +}}, +{Func::vkCmdPushDescriptorSet2KHR, { + "VUID-vkCmdPushDescriptorSet2KHR-commandBuffer-recording", + nullptr, + VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, "VUID-vkCmdPushDescriptorSet2KHR-commandBuffer-cmdpool", + CMD_SCOPE_BOTH, "kVUIDUndefined", + CMD_SCOPE_OUTSIDE, "VUID-vkCmdPushDescriptorSet2KHR-videocoding", +}}, +{Func::vkCmdPushDescriptorSetWithTemplate2KHR, { + "VUID-vkCmdPushDescriptorSetWithTemplate2KHR-commandBuffer-recording", + nullptr, + VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, "VUID-vkCmdPushDescriptorSetWithTemplate2KHR-commandBuffer-cmdpool", + CMD_SCOPE_BOTH, "kVUIDUndefined", + CMD_SCOPE_OUTSIDE, "VUID-vkCmdPushDescriptorSetWithTemplate2KHR-videocoding", +}}, +{Func::vkCmdSetDescriptorBufferOffsets2EXT, { + "VUID-vkCmdSetDescriptorBufferOffsets2EXT-commandBuffer-recording", + nullptr, + VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, "VUID-vkCmdSetDescriptorBufferOffsets2EXT-commandBuffer-cmdpool", + CMD_SCOPE_BOTH, "kVUIDUndefined", + CMD_SCOPE_OUTSIDE, "VUID-vkCmdSetDescriptorBufferOffsets2EXT-videocoding", +}}, +{Func::vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, { + "VUID-vkCmdBindDescriptorBufferEmbeddedSamplers2EXT-commandBuffer-recording", + nullptr, + VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, "VUID-vkCmdBindDescriptorBufferEmbeddedSamplers2EXT-commandBuffer-cmdpool", + CMD_SCOPE_BOTH, "kVUIDUndefined", + CMD_SCOPE_OUTSIDE, "VUID-vkCmdBindDescriptorBufferEmbeddedSamplers2EXT-videocoding", +}}, {Func::vkCmdDebugMarkerBeginEXT, { "VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-recording", nullptr, diff --git a/layers/vulkan/generated/enum_flag_bits.h b/layers/vulkan/generated/enum_flag_bits.h index 6b07dd8d752..5c036684060 100644 --- a/layers/vulkan/generated/enum_flag_bits.h +++ b/layers/vulkan/generated/enum_flag_bits.h @@ -24,7 +24,7 @@ #include #include "vulkan/vulkan.h" // clang-format off -const uint32_t GeneratedVulkanHeaderVersion = 273; +const uint32_t GeneratedVulkanHeaderVersion = 274; const VkAccessFlags AllVkAccessFlagBits = VK_ACCESS_INDIRECT_COMMAND_READ_BIT|VK_ACCESS_INDEX_READ_BIT|VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT|VK_ACCESS_UNIFORM_READ_BIT|VK_ACCESS_INPUT_ATTACHMENT_READ_BIT|VK_ACCESS_SHADER_READ_BIT|VK_ACCESS_SHADER_WRITE_BIT|VK_ACCESS_COLOR_ATTACHMENT_READ_BIT|VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT|VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT|VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT|VK_ACCESS_TRANSFER_READ_BIT|VK_ACCESS_TRANSFER_WRITE_BIT|VK_ACCESS_HOST_READ_BIT|VK_ACCESS_HOST_WRITE_BIT|VK_ACCESS_MEMORY_READ_BIT|VK_ACCESS_MEMORY_WRITE_BIT|VK_ACCESS_NONE|VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT|VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT|VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT|VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT|VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT|VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR|VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR|VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT|VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR|VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV|VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV; const VkImageAspectFlags AllVkImageAspectFlagBits = VK_IMAGE_ASPECT_COLOR_BIT|VK_IMAGE_ASPECT_DEPTH_BIT|VK_IMAGE_ASPECT_STENCIL_BIT|VK_IMAGE_ASPECT_METADATA_BIT|VK_IMAGE_ASPECT_PLANE_0_BIT|VK_IMAGE_ASPECT_PLANE_1_BIT|VK_IMAGE_ASPECT_PLANE_2_BIT|VK_IMAGE_ASPECT_NONE|VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT|VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT|VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT|VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT; const VkInstanceCreateFlags AllVkInstanceCreateFlagBits = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR; @@ -34,9 +34,9 @@ const VkSparseMemoryBindFlags AllVkSparseMemoryBindFlagBits = VK_SPARSE_MEMORY_B const VkFenceCreateFlags AllVkFenceCreateFlagBits = VK_FENCE_CREATE_SIGNALED_BIT; const VkEventCreateFlags AllVkEventCreateFlagBits = VK_EVENT_CREATE_DEVICE_ONLY_BIT; const VkQueryPipelineStatisticFlags AllVkQueryPipelineStatisticFlagBits = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT|VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT|VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT|VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT|VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT|VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT|VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT|VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI; -const VkBufferCreateFlags AllVkBufferCreateFlagBits = VK_BUFFER_CREATE_SPARSE_BINDING_BIT|VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT|VK_BUFFER_CREATE_SPARSE_ALIASED_BIT|VK_BUFFER_CREATE_PROTECTED_BIT|VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT|VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT; +const VkBufferCreateFlags AllVkBufferCreateFlagBits = VK_BUFFER_CREATE_SPARSE_BINDING_BIT|VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT|VK_BUFFER_CREATE_SPARSE_ALIASED_BIT|VK_BUFFER_CREATE_PROTECTED_BIT|VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT|VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT|VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR; const VkBufferUsageFlags AllVkBufferUsageFlagBits = VK_BUFFER_USAGE_TRANSFER_SRC_BIT|VK_BUFFER_USAGE_TRANSFER_DST_BIT|VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT|VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT|VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT|VK_BUFFER_USAGE_STORAGE_BUFFER_BIT|VK_BUFFER_USAGE_INDEX_BUFFER_BIT|VK_BUFFER_USAGE_VERTEX_BUFFER_BIT|VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT|VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT|VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR|VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR|VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT|VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT|VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT|VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX|VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR|VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR|VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR|VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR|VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR|VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT|VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT|VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT|VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT|VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT; -const VkImageCreateFlags AllVkImageCreateFlagBits = VK_IMAGE_CREATE_SPARSE_BINDING_BIT|VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT|VK_IMAGE_CREATE_SPARSE_ALIASED_BIT|VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT|VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT|VK_IMAGE_CREATE_ALIAS_BIT|VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT|VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT|VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT|VK_IMAGE_CREATE_EXTENDED_USAGE_BIT|VK_IMAGE_CREATE_PROTECTED_BIT|VK_IMAGE_CREATE_DISJOINT_BIT|VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV|VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT|VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT|VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT|VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT|VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT|VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM; +const VkImageCreateFlags AllVkImageCreateFlagBits = VK_IMAGE_CREATE_SPARSE_BINDING_BIT|VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT|VK_IMAGE_CREATE_SPARSE_ALIASED_BIT|VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT|VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT|VK_IMAGE_CREATE_ALIAS_BIT|VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT|VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT|VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT|VK_IMAGE_CREATE_EXTENDED_USAGE_BIT|VK_IMAGE_CREATE_PROTECTED_BIT|VK_IMAGE_CREATE_DISJOINT_BIT|VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV|VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT|VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT|VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT|VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT|VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT|VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM|VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR; const VkSampleCountFlags AllVkSampleCountFlagBits = VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_2_BIT|VK_SAMPLE_COUNT_4_BIT|VK_SAMPLE_COUNT_8_BIT|VK_SAMPLE_COUNT_16_BIT|VK_SAMPLE_COUNT_32_BIT|VK_SAMPLE_COUNT_64_BIT; const VkImageUsageFlags AllVkImageUsageFlagBits = VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_STORAGE_BIT|VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT|VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT|VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR|VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR|VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR|VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT|VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR|VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT|VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR|VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR|VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR|VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT|VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI|VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM|VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM; const VkImageViewCreateFlags AllVkImageViewCreateFlagBits = VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT|VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT|VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT; @@ -51,7 +51,7 @@ const VkPipelineColorBlendStateCreateFlags AllVkPipelineColorBlendStateCreateFla const VkPipelineLayoutCreateFlags AllVkPipelineLayoutCreateFlagBits = VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT; const VkSamplerCreateFlags AllVkSamplerCreateFlagBits = VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT|VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT|VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT|VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT|VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM; const VkDescriptorPoolCreateFlags AllVkDescriptorPoolCreateFlagBits = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT|VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT|VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT|VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV|VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV; -const VkDescriptorSetLayoutCreateFlags AllVkDescriptorSetLayoutCreateFlagBits = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT|VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR|VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT|VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT|VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV|VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT; +const VkDescriptorSetLayoutCreateFlags AllVkDescriptorSetLayoutCreateFlagBits = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT|VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR|VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT|VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT|VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV|VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT|VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV; const VkAttachmentDescriptionFlags AllVkAttachmentDescriptionFlagBits = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT; const VkFramebufferCreateFlags AllVkFramebufferCreateFlagBits = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT; const VkSubpassDescriptionFlags AllVkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX|VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX|VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM|VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM|VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT|VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT|VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT|VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT; @@ -76,28 +76,24 @@ const VkSurfaceTransformFlagsKHR AllVkSurfaceTransformFlagBitsKHR = VK_SURFACE_T const VkCompositeAlphaFlagsKHR AllVkCompositeAlphaFlagBitsKHR = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR|VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR|VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR|VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR; const VkDeviceGroupPresentModeFlagsKHR AllVkDeviceGroupPresentModeFlagBitsKHR = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR|VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR|VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR|VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR; const VkDisplayPlaneAlphaFlagsKHR AllVkDisplayPlaneAlphaFlagBitsKHR = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR|VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR|VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR|VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR; -const VkVideoCodecOperationFlagsKHR AllVkVideoCodecOperationFlagBitsKHR = VK_VIDEO_CODEC_OPERATION_NONE_KHR|VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT|VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT|VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR|VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR; +const VkVideoCodecOperationFlagsKHR AllVkVideoCodecOperationFlagBitsKHR = VK_VIDEO_CODEC_OPERATION_NONE_KHR|VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR|VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR|VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR|VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR; const VkVideoChromaSubsamplingFlagsKHR AllVkVideoChromaSubsamplingFlagBitsKHR = VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR|VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR|VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR|VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR|VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR; const VkVideoComponentBitDepthFlagsKHR AllVkVideoComponentBitDepthFlagBitsKHR = VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR|VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR|VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR|VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR; -const VkVideoSessionCreateFlagsKHR AllVkVideoSessionCreateFlagBitsKHR = VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR|VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR; +const VkVideoSessionCreateFlagsKHR AllVkVideoSessionCreateFlagBitsKHR = VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR|VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR|VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR; const VkVideoCodingControlFlagsKHR AllVkVideoCodingControlFlagBitsKHR = VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR|VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR|VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR; const VkVideoDecodeUsageFlagsKHR AllVkVideoDecodeUsageFlagBitsKHR = VK_VIDEO_DECODE_USAGE_DEFAULT_KHR|VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR|VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR|VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR; +const VkVideoEncodeH264RateControlFlagsKHR AllVkVideoEncodeH264RateControlFlagBitsKHR = VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR|VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR|VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR|VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR|VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR; +const VkVideoEncodeH265RateControlFlagsKHR AllVkVideoEncodeH265RateControlFlagBitsKHR = VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR|VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR|VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR|VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR|VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR; const VkVideoDecodeH264PictureLayoutFlagsKHR AllVkVideoDecodeH264PictureLayoutFlagBitsKHR = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR|VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR|VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR; const VkSemaphoreImportFlags AllVkSemaphoreImportFlagBits = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT; const VkFenceImportFlags AllVkFenceImportFlagBits = VK_FENCE_IMPORT_TEMPORARY_BIT; -#ifdef VK_ENABLE_BETA_EXTENSIONS const VkVideoEncodeFeedbackFlagsKHR AllVkVideoEncodeFeedbackFlagBitsKHR = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR|VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR|VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR; const VkVideoEncodeUsageFlagsKHR AllVkVideoEncodeUsageFlagBitsKHR = VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR|VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR|VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR|VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR|VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR; const VkVideoEncodeContentFlagsKHR AllVkVideoEncodeContentFlagBitsKHR = VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR|VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR|VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR|VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR; const VkVideoEncodeRateControlModeFlagsKHR AllVkVideoEncodeRateControlModeFlagBitsKHR = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR|VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR|VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR|VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR; -#endif // VK_ENABLE_BETA_EXTENSIONS const VkPipelineCreateFlags2KHR AllVkPipelineCreateFlagBits2KHR = VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR|VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR|VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR|VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR|VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR|VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV|VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR|VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR|VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR|VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR|VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT|VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT|VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR|VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR|VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR|VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR|VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR|VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR|VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR|VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR|VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV|VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV|VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR|VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT|VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT|VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT|VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT|VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT|VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT|VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV|VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT; const VkBufferUsageFlags2KHR AllVkBufferUsageFlagBits2KHR = VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR|VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR|VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR|VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR|VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR|VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR|VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR|VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR|VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR|VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX|VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT|VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR|VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT|VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT|VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR|VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR|VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR|VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR|VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR|VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR|VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR|VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT|VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT|VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT|VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT|VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT; const VkDebugReportFlagsEXT AllVkDebugReportFlagBitsEXT = VK_DEBUG_REPORT_INFORMATION_BIT_EXT|VK_DEBUG_REPORT_WARNING_BIT_EXT|VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT|VK_DEBUG_REPORT_ERROR_BIT_EXT|VK_DEBUG_REPORT_DEBUG_BIT_EXT; -#ifdef VK_ENABLE_BETA_EXTENSIONS -const VkVideoEncodeH264RateControlFlagsEXT AllVkVideoEncodeH264RateControlFlagBitsEXT = VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT|VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_EXT|VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT|VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT|VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_EXT; -const VkVideoEncodeH265RateControlFlagsEXT AllVkVideoEncodeH265RateControlFlagBitsEXT = VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT|VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_EXT|VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT|VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT|VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_EXT; -#endif // VK_ENABLE_BETA_EXTENSIONS const VkExternalMemoryHandleTypeFlagsNV AllVkExternalMemoryHandleTypeFlagBitsNV = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV|VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV; const VkConditionalRenderingFlagsEXT AllVkConditionalRenderingFlagBitsEXT = VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT; const VkSurfaceCounterFlagsEXT AllVkSurfaceCounterFlagBitsEXT = VK_SURFACE_COUNTER_VBLANK_BIT_EXT; diff --git a/layers/vulkan/generated/error_location_helper.cpp b/layers/vulkan/generated/error_location_helper.cpp index 743cfac86d3..8dc9c69dcae 100644 --- a/layers/vulkan/generated/error_location_helper.cpp +++ b/layers/vulkan/generated/error_location_helper.cpp @@ -65,9 +65,11 @@ const char* String(Func func) { {"vkCmdBeginRenderingKHR", 23}, {"vkCmdBeginTransformFeedbackEXT", 31}, {"vkCmdBeginVideoCodingKHR", 25}, + {"vkCmdBindDescriptorBufferEmbeddedSamplers2EXT", 46}, {"vkCmdBindDescriptorBufferEmbeddedSamplersEXT", 45}, {"vkCmdBindDescriptorBuffersEXT", 30}, {"vkCmdBindDescriptorSets", 24}, + {"vkCmdBindDescriptorSets2KHR", 28}, {"vkCmdBindIndexBuffer", 21}, {"vkCmdBindIndexBuffer2KHR", 25}, {"vkCmdBindInvocationMaskHUAWEI", 30}, @@ -174,7 +176,10 @@ const char* String(Func func) { {"vkCmdPipelineBarrier2KHR", 25}, {"vkCmdPreprocessGeneratedCommandsNV", 35}, {"vkCmdPushConstants", 19}, + {"vkCmdPushConstants2KHR", 23}, + {"vkCmdPushDescriptorSet2KHR", 27}, {"vkCmdPushDescriptorSetKHR", 26}, + {"vkCmdPushDescriptorSetWithTemplate2KHR", 39}, {"vkCmdPushDescriptorSetWithTemplateKHR", 38}, {"vkCmdResetEvent", 16}, {"vkCmdResetEvent2", 17}, @@ -219,6 +224,7 @@ const char* String(Func func) { {"vkCmdSetDepthTestEnableEXT", 27}, {"vkCmdSetDepthWriteEnable", 25}, {"vkCmdSetDepthWriteEnableEXT", 28}, + {"vkCmdSetDescriptorBufferOffsets2EXT", 36}, {"vkCmdSetDescriptorBufferOffsetsEXT", 35}, {"vkCmdSetDeviceMask", 19}, {"vkCmdSetDeviceMaskKHR", 22}, @@ -758,11 +764,14 @@ const char* String(Struct structure) { {"VkBindAccelerationStructureMemoryInfoNV", 40}, {"VkBindBufferMemoryDeviceGroupInfo", 34}, {"VkBindBufferMemoryInfo", 23}, + {"VkBindDescriptorBufferEmbeddedSamplersInfoEXT", 46}, + {"VkBindDescriptorSetsInfoKHR", 28}, {"VkBindImageMemoryDeviceGroupInfo", 33}, {"VkBindImageMemoryInfo", 22}, {"VkBindImageMemorySwapchainInfoKHR", 34}, {"VkBindImagePlaneMemoryInfo", 27}, {"VkBindIndexBufferIndirectCommandNV", 35}, + {"VkBindMemoryStatusKHR", 22}, {"VkBindPipelineIndirectCommandNV", 32}, {"VkBindShaderGroupIndirectCommandNV", 35}, {"VkBindSparseInfo", 17}, @@ -1271,6 +1280,8 @@ const char* String(Struct structure) { {"VkPhysicalDeviceMaintenance4Properties", 39}, {"VkPhysicalDeviceMaintenance5FeaturesKHR", 40}, {"VkPhysicalDeviceMaintenance5PropertiesKHR", 42}, + {"VkPhysicalDeviceMaintenance6FeaturesKHR", 40}, + {"VkPhysicalDeviceMaintenance6PropertiesKHR", 42}, {"VkPhysicalDeviceMemoryBudgetPropertiesEXT", 42}, {"VkPhysicalDeviceMemoryDecompressionFeaturesNV", 46}, {"VkPhysicalDeviceMemoryDecompressionPropertiesNV", 48}, @@ -1299,6 +1310,7 @@ const char* String(Struct structure) { {"VkPhysicalDeviceOpticalFlowPropertiesNV", 40}, {"VkPhysicalDevicePCIBusInfoPropertiesEXT", 40}, {"VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT", 53}, + {"VkPhysicalDevicePerStageDescriptorSetFeaturesNV", 48}, {"VkPhysicalDevicePerformanceQueryFeaturesKHR", 44}, {"VkPhysicalDevicePerformanceQueryPropertiesKHR", 46}, {"VkPhysicalDevicePipelineCreationCacheControlFeatures", 53}, @@ -1409,6 +1421,7 @@ const char* String(Struct structure) { {"VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT", 51}, {"VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR", 47}, {"VkPhysicalDeviceVideoFormatInfoKHR", 35}, + {"VkPhysicalDeviceVideoMaintenance1FeaturesKHR", 45}, {"VkPhysicalDeviceVulkan11Features", 33}, {"VkPhysicalDeviceVulkan11Properties", 35}, {"VkPhysicalDeviceVulkan12Features", 33}, @@ -1487,6 +1500,9 @@ const char* String(Struct structure) { {"VkPrivateDataSlotCreateInfo", 28}, {"VkProtectedSubmitInfo", 22}, {"VkPushConstantRange", 20}, + {"VkPushConstantsInfoKHR", 23}, + {"VkPushDescriptorSetInfoKHR", 27}, + {"VkPushDescriptorSetWithTemplateInfoKHR", 39}, {"VkQueryLowLatencySupportNV", 27}, {"VkQueryPoolCreateInfo", 22}, {"VkQueryPoolPerformanceCreateInfoKHR", 36}, @@ -1556,6 +1572,7 @@ const char* String(Struct structure) { {"VkSemaphoreSubmitInfo", 22}, {"VkSemaphoreTypeCreateInfo", 26}, {"VkSemaphoreWaitInfo", 20}, + {"VkSetDescriptorBufferOffsetsInfoEXT", 36}, {"VkSetLatencyMarkerInfoNV", 25}, {"VkSetStateFlagsIndirectCommandNV", 33}, {"VkShaderCreateInfoEXT", 22}, @@ -1653,38 +1670,38 @@ const char* String(Struct structure) { {"VkVideoDecodeInfoKHR", 21}, {"VkVideoDecodeUsageInfoKHR", 26}, {"VkVideoEncodeCapabilitiesKHR", 29}, - {"VkVideoEncodeH264CapabilitiesEXT", 33}, - {"VkVideoEncodeH264DpbSlotInfoEXT", 32}, - {"VkVideoEncodeH264FrameSizeEXT", 30}, - {"VkVideoEncodeH264GopRemainingFrameInfoEXT", 42}, - {"VkVideoEncodeH264NaluSliceInfoEXT", 34}, - {"VkVideoEncodeH264PictureInfoEXT", 32}, - {"VkVideoEncodeH264ProfileInfoEXT", 32}, - {"VkVideoEncodeH264QpEXT", 23}, - {"VkVideoEncodeH264QualityLevelPropertiesEXT", 43}, - {"VkVideoEncodeH264RateControlInfoEXT", 36}, - {"VkVideoEncodeH264RateControlLayerInfoEXT", 41}, - {"VkVideoEncodeH264SessionCreateInfoEXT", 38}, - {"VkVideoEncodeH264SessionParametersAddInfoEXT", 45}, - {"VkVideoEncodeH264SessionParametersCreateInfoEXT", 48}, - {"VkVideoEncodeH264SessionParametersFeedbackInfoEXT", 50}, - {"VkVideoEncodeH264SessionParametersGetInfoEXT", 45}, - {"VkVideoEncodeH265CapabilitiesEXT", 33}, - {"VkVideoEncodeH265DpbSlotInfoEXT", 32}, - {"VkVideoEncodeH265FrameSizeEXT", 30}, - {"VkVideoEncodeH265GopRemainingFrameInfoEXT", 42}, - {"VkVideoEncodeH265NaluSliceSegmentInfoEXT", 41}, - {"VkVideoEncodeH265PictureInfoEXT", 32}, - {"VkVideoEncodeH265ProfileInfoEXT", 32}, - {"VkVideoEncodeH265QpEXT", 23}, - {"VkVideoEncodeH265QualityLevelPropertiesEXT", 43}, - {"VkVideoEncodeH265RateControlInfoEXT", 36}, - {"VkVideoEncodeH265RateControlLayerInfoEXT", 41}, - {"VkVideoEncodeH265SessionCreateInfoEXT", 38}, - {"VkVideoEncodeH265SessionParametersAddInfoEXT", 45}, - {"VkVideoEncodeH265SessionParametersCreateInfoEXT", 48}, - {"VkVideoEncodeH265SessionParametersFeedbackInfoEXT", 50}, - {"VkVideoEncodeH265SessionParametersGetInfoEXT", 45}, + {"VkVideoEncodeH264CapabilitiesKHR", 33}, + {"VkVideoEncodeH264DpbSlotInfoKHR", 32}, + {"VkVideoEncodeH264FrameSizeKHR", 30}, + {"VkVideoEncodeH264GopRemainingFrameInfoKHR", 42}, + {"VkVideoEncodeH264NaluSliceInfoKHR", 34}, + {"VkVideoEncodeH264PictureInfoKHR", 32}, + {"VkVideoEncodeH264ProfileInfoKHR", 32}, + {"VkVideoEncodeH264QpKHR", 23}, + {"VkVideoEncodeH264QualityLevelPropertiesKHR", 43}, + {"VkVideoEncodeH264RateControlInfoKHR", 36}, + {"VkVideoEncodeH264RateControlLayerInfoKHR", 41}, + {"VkVideoEncodeH264SessionCreateInfoKHR", 38}, + {"VkVideoEncodeH264SessionParametersAddInfoKHR", 45}, + {"VkVideoEncodeH264SessionParametersCreateInfoKHR", 48}, + {"VkVideoEncodeH264SessionParametersFeedbackInfoKHR", 50}, + {"VkVideoEncodeH264SessionParametersGetInfoKHR", 45}, + {"VkVideoEncodeH265CapabilitiesKHR", 33}, + {"VkVideoEncodeH265DpbSlotInfoKHR", 32}, + {"VkVideoEncodeH265FrameSizeKHR", 30}, + {"VkVideoEncodeH265GopRemainingFrameInfoKHR", 42}, + {"VkVideoEncodeH265NaluSliceSegmentInfoKHR", 41}, + {"VkVideoEncodeH265PictureInfoKHR", 32}, + {"VkVideoEncodeH265ProfileInfoKHR", 32}, + {"VkVideoEncodeH265QpKHR", 23}, + {"VkVideoEncodeH265QualityLevelPropertiesKHR", 43}, + {"VkVideoEncodeH265RateControlInfoKHR", 36}, + {"VkVideoEncodeH265RateControlLayerInfoKHR", 41}, + {"VkVideoEncodeH265SessionCreateInfoKHR", 38}, + {"VkVideoEncodeH265SessionParametersAddInfoKHR", 45}, + {"VkVideoEncodeH265SessionParametersCreateInfoKHR", 48}, + {"VkVideoEncodeH265SessionParametersFeedbackInfoKHR", 50}, + {"VkVideoEncodeH265SessionParametersGetInfoKHR", 45}, {"VkVideoEncodeInfoKHR", 21}, {"VkVideoEncodeQualityLevelInfoKHR", 33}, {"VkVideoEncodeQualityLevelPropertiesKHR", 39}, @@ -1695,6 +1712,7 @@ const char* String(Struct structure) { {"VkVideoEncodeUsageInfoKHR", 26}, {"VkVideoEndCodingInfoKHR", 24}, {"VkVideoFormatPropertiesKHR", 27}, + {"VkVideoInlineQueryInfoKHR", 26}, {"VkVideoPictureResourceInfoKHR", 30}, {"VkVideoProfileInfoKHR", 22}, {"VkVideoProfileListInfoKHR", 26}, @@ -1822,6 +1840,7 @@ const char* String(Field field) { {"blockDimX", 10}, {"blockDimY", 10}, {"blockDimZ", 10}, + {"blockTexelViewCompatibleMultipleLayers", 39}, {"borderColor", 12}, {"borderColorSwizzle", 19}, {"borderColorSwizzleFromImage", 28}, @@ -2154,6 +2173,7 @@ const char* String(Field field) { {"duration", 9}, {"dwAccess", 9}, {"dynamicOffsetCount", 19}, + {"dynamicPipelineLayout", 22}, {"dynamicPrimitiveTopologyUnrestricted", 37}, {"dynamicRendering", 17}, {"dynamicRenderingUnusedAttachments", 34}, @@ -2296,6 +2316,7 @@ const char* String(Field field) { {"fragmentShaderPixelInterlock", 29}, {"fragmentShaderSampleInterlock", 30}, {"fragmentShaderShadingRateInterlock", 35}, + {"fragmentShadingRateClampCombinerInputs", 39}, {"fragmentShadingRateEnums", 25}, {"fragmentShadingRateNonTrivialCombinerOps", 41}, {"fragmentShadingRateStrictMultiplyCombiner", 42}, @@ -2560,6 +2581,7 @@ const char* String(Field field) { {"magFilter", 10}, {"maintenance4", 13}, {"maintenance5", 13}, + {"maintenance6", 13}, {"major", 6}, {"mapEntryCount", 14}, {"marker", 7}, @@ -2581,6 +2603,7 @@ const char* String(Field field) { {"maxCodedExtent", 15}, {"maxColorAttachments", 20}, {"maxCombinedClipAndCullDistances", 32}, + {"maxCombinedImageSamplerDescriptorCount", 39}, {"maxCommandBufferNestingLevel", 29}, {"maxComputeSharedMemorySize", 27}, {"maxComputeWorkGroupCount", 25}, @@ -3003,6 +3026,8 @@ const char* String(Field field) { {"pAttachments", 13}, {"pAttributes", 12}, {"pBeginInfo", 11}, + {"pBindDescriptorBufferEmbeddedSamplersInfo", 42}, + {"pBindDescriptorSetsInfo", 24}, {"pBindInfo", 10}, {"pBindInfos", 11}, {"pBindSessionMemoryInfos", 24}, @@ -3306,6 +3331,9 @@ const char* String(Field field) { {"pPropertiesCount", 17}, {"pPropertyCount", 15}, {"pPushConstantRanges", 20}, + {"pPushConstantsInfo", 19}, + {"pPushDescriptorSetInfo", 23}, + {"pPushDescriptorSetWithTemplateInfo", 35}, {"pQualityLevelInfo", 18}, {"pQualityLevelProperties", 24}, {"pQueriedLowLatencyData", 23}, @@ -3337,6 +3365,7 @@ const char* String(Field field) { {"pRenderingInfo", 15}, {"pResolveAttachments", 20}, {"pResolveImageInfo", 18}, + {"pResult", 8}, {"pResults", 9}, {"pSampleLocations", 17}, {"pSampleLocationsInfo", 21}, @@ -3347,6 +3376,7 @@ const char* String(Field field) { {"pSemaphore", 11}, {"pSemaphores", 12}, {"pSession", 9}, + {"pSetDescriptorBufferOffsetsInfo", 32}, {"pSetLayout", 11}, {"pSetLayouts", 12}, {"pSettingName", 13}, @@ -3480,6 +3510,7 @@ const char* String(Field field) { {"pciDevice", 10}, {"pciDomain", 10}, {"pciFunction", 12}, + {"perStageDescriptorSet", 22}, {"perViewAttributes", 18}, {"perViewAttributesPositionXOnly", 31}, {"perViewPositionAllComponents", 29}, @@ -4234,6 +4265,7 @@ const char* String(Field field) { {"videoCodecOperation", 20}, {"videoCodecOperations", 21}, {"videoContentHints", 18}, + {"videoMaintenance1", 18}, {"videoSession", 13}, {"videoSessionParameters", 23}, {"videoSessionParametersTemplate", 31}, @@ -4325,6 +4357,8 @@ bool IsFieldPointer(Field field) { case Field::pAttachments: case Field::pAttributes: case Field::pBeginInfo: + case Field::pBindDescriptorBufferEmbeddedSamplersInfo: + case Field::pBindDescriptorSetsInfo: case Field::pBindInfo: case Field::pBindInfos: case Field::pBindSessionMemoryInfos: @@ -4628,6 +4662,9 @@ bool IsFieldPointer(Field field) { case Field::pPropertiesCount: case Field::pPropertyCount: case Field::pPushConstantRanges: + case Field::pPushConstantsInfo: + case Field::pPushDescriptorSetInfo: + case Field::pPushDescriptorSetWithTemplateInfo: case Field::pQualityLevelInfo: case Field::pQualityLevelProperties: case Field::pQueriedLowLatencyData: @@ -4659,6 +4696,7 @@ bool IsFieldPointer(Field field) { case Field::pRenderingInfo: case Field::pResolveAttachments: case Field::pResolveImageInfo: + case Field::pResult: case Field::pResults: case Field::pSampleLocations: case Field::pSampleLocationsInfo: @@ -4669,6 +4707,7 @@ bool IsFieldPointer(Field field) { case Field::pSemaphore: case Field::pSemaphores: case Field::pSession: + case Field::pSetDescriptorBufferOffsetsInfo: case Field::pSetLayout: case Field::pSetLayouts: case Field::pSettingName: diff --git a/layers/vulkan/generated/error_location_helper.h b/layers/vulkan/generated/error_location_helper.h index 41d2b9b047c..56511423a15 100644 --- a/layers/vulkan/generated/error_location_helper.h +++ b/layers/vulkan/generated/error_location_helper.h @@ -62,643 +62,649 @@ enum class Func { vkCmdBeginRenderingKHR = 32, vkCmdBeginTransformFeedbackEXT = 33, vkCmdBeginVideoCodingKHR = 34, - vkCmdBindDescriptorBufferEmbeddedSamplersEXT = 35, - vkCmdBindDescriptorBuffersEXT = 36, - vkCmdBindDescriptorSets = 37, - vkCmdBindIndexBuffer = 38, - vkCmdBindIndexBuffer2KHR = 39, - vkCmdBindInvocationMaskHUAWEI = 40, - vkCmdBindPipeline = 41, - vkCmdBindPipelineShaderGroupNV = 42, - vkCmdBindShadersEXT = 43, - vkCmdBindShadingRateImageNV = 44, - vkCmdBindTransformFeedbackBuffersEXT = 45, - vkCmdBindVertexBuffers = 46, - vkCmdBindVertexBuffers2 = 47, - vkCmdBindVertexBuffers2EXT = 48, - vkCmdBlitImage = 49, - vkCmdBlitImage2 = 50, - vkCmdBlitImage2KHR = 51, - vkCmdBuildAccelerationStructureNV = 52, - vkCmdBuildAccelerationStructuresIndirectKHR = 53, - vkCmdBuildAccelerationStructuresKHR = 54, - vkCmdBuildMicromapsEXT = 55, - vkCmdClearAttachments = 56, - vkCmdClearColorImage = 57, - vkCmdClearDepthStencilImage = 58, - vkCmdControlVideoCodingKHR = 59, - vkCmdCopyAccelerationStructureKHR = 60, - vkCmdCopyAccelerationStructureNV = 61, - vkCmdCopyAccelerationStructureToMemoryKHR = 62, - vkCmdCopyBuffer = 63, - vkCmdCopyBuffer2 = 64, - vkCmdCopyBuffer2KHR = 65, - vkCmdCopyBufferToImage = 66, - vkCmdCopyBufferToImage2 = 67, - vkCmdCopyBufferToImage2KHR = 68, - vkCmdCopyImage = 69, - vkCmdCopyImage2 = 70, - vkCmdCopyImage2KHR = 71, - vkCmdCopyImageToBuffer = 72, - vkCmdCopyImageToBuffer2 = 73, - vkCmdCopyImageToBuffer2KHR = 74, - vkCmdCopyMemoryIndirectNV = 75, - vkCmdCopyMemoryToAccelerationStructureKHR = 76, - vkCmdCopyMemoryToImageIndirectNV = 77, - vkCmdCopyMemoryToMicromapEXT = 78, - vkCmdCopyMicromapEXT = 79, - vkCmdCopyMicromapToMemoryEXT = 80, - vkCmdCopyQueryPoolResults = 81, - vkCmdCuLaunchKernelNVX = 82, - vkCmdCudaLaunchKernelNV = 83, - vkCmdDebugMarkerBeginEXT = 84, - vkCmdDebugMarkerEndEXT = 85, - vkCmdDebugMarkerInsertEXT = 86, - vkCmdDecodeVideoKHR = 87, - vkCmdDecompressMemoryIndirectCountNV = 88, - vkCmdDecompressMemoryNV = 89, - vkCmdDispatch = 90, - vkCmdDispatchBase = 91, - vkCmdDispatchBaseKHR = 92, - vkCmdDispatchGraphAMDX = 93, - vkCmdDispatchGraphIndirectAMDX = 94, - vkCmdDispatchGraphIndirectCountAMDX = 95, - vkCmdDispatchIndirect = 96, - vkCmdDraw = 97, - vkCmdDrawClusterHUAWEI = 98, - vkCmdDrawClusterIndirectHUAWEI = 99, - vkCmdDrawIndexed = 100, - vkCmdDrawIndexedIndirect = 101, - vkCmdDrawIndexedIndirectCount = 102, - vkCmdDrawIndexedIndirectCountAMD = 103, - vkCmdDrawIndexedIndirectCountKHR = 104, - vkCmdDrawIndirect = 105, - vkCmdDrawIndirectByteCountEXT = 106, - vkCmdDrawIndirectCount = 107, - vkCmdDrawIndirectCountAMD = 108, - vkCmdDrawIndirectCountKHR = 109, - vkCmdDrawMeshTasksEXT = 110, - vkCmdDrawMeshTasksIndirectCountEXT = 111, - vkCmdDrawMeshTasksIndirectCountNV = 112, - vkCmdDrawMeshTasksIndirectEXT = 113, - vkCmdDrawMeshTasksIndirectNV = 114, - vkCmdDrawMeshTasksNV = 115, - vkCmdDrawMultiEXT = 116, - vkCmdDrawMultiIndexedEXT = 117, - vkCmdEncodeVideoKHR = 118, - vkCmdEndConditionalRenderingEXT = 119, - vkCmdEndDebugUtilsLabelEXT = 120, - vkCmdEndQuery = 121, - vkCmdEndQueryIndexedEXT = 122, - vkCmdEndRenderPass = 123, - vkCmdEndRenderPass2 = 124, - vkCmdEndRenderPass2KHR = 125, - vkCmdEndRendering = 126, - vkCmdEndRenderingKHR = 127, - vkCmdEndTransformFeedbackEXT = 128, - vkCmdEndVideoCodingKHR = 129, - vkCmdExecuteCommands = 130, - vkCmdExecuteGeneratedCommandsNV = 131, - vkCmdFillBuffer = 132, - vkCmdInitializeGraphScratchMemoryAMDX = 133, - vkCmdInsertDebugUtilsLabelEXT = 134, - vkCmdNextSubpass = 135, - vkCmdNextSubpass2 = 136, - vkCmdNextSubpass2KHR = 137, - vkCmdOpticalFlowExecuteNV = 138, - vkCmdPipelineBarrier = 139, - vkCmdPipelineBarrier2 = 140, - vkCmdPipelineBarrier2KHR = 141, - vkCmdPreprocessGeneratedCommandsNV = 142, - vkCmdPushConstants = 143, - vkCmdPushDescriptorSetKHR = 144, - vkCmdPushDescriptorSetWithTemplateKHR = 145, - vkCmdResetEvent = 146, - vkCmdResetEvent2 = 147, - vkCmdResetEvent2KHR = 148, - vkCmdResetQueryPool = 149, - vkCmdResolveImage = 150, - vkCmdResolveImage2 = 151, - vkCmdResolveImage2KHR = 152, - vkCmdSetAlphaToCoverageEnableEXT = 153, - vkCmdSetAlphaToOneEnableEXT = 154, - vkCmdSetAttachmentFeedbackLoopEnableEXT = 155, - vkCmdSetBlendConstants = 156, - vkCmdSetCheckpointNV = 157, - vkCmdSetCoarseSampleOrderNV = 158, - vkCmdSetColorBlendAdvancedEXT = 159, - vkCmdSetColorBlendEnableEXT = 160, - vkCmdSetColorBlendEquationEXT = 161, - vkCmdSetColorWriteEnableEXT = 162, - vkCmdSetColorWriteMaskEXT = 163, - vkCmdSetConservativeRasterizationModeEXT = 164, - vkCmdSetCoverageModulationModeNV = 165, - vkCmdSetCoverageModulationTableEnableNV = 166, - vkCmdSetCoverageModulationTableNV = 167, - vkCmdSetCoverageReductionModeNV = 168, - vkCmdSetCoverageToColorEnableNV = 169, - vkCmdSetCoverageToColorLocationNV = 170, - vkCmdSetCullMode = 171, - vkCmdSetCullModeEXT = 172, - vkCmdSetDepthBias = 173, - vkCmdSetDepthBias2EXT = 174, - vkCmdSetDepthBiasEnable = 175, - vkCmdSetDepthBiasEnableEXT = 176, - vkCmdSetDepthBounds = 177, - vkCmdSetDepthBoundsTestEnable = 178, - vkCmdSetDepthBoundsTestEnableEXT = 179, - vkCmdSetDepthClampEnableEXT = 180, - vkCmdSetDepthClipEnableEXT = 181, - vkCmdSetDepthClipNegativeOneToOneEXT = 182, - vkCmdSetDepthCompareOp = 183, - vkCmdSetDepthCompareOpEXT = 184, - vkCmdSetDepthTestEnable = 185, - vkCmdSetDepthTestEnableEXT = 186, - vkCmdSetDepthWriteEnable = 187, - vkCmdSetDepthWriteEnableEXT = 188, - vkCmdSetDescriptorBufferOffsetsEXT = 189, - vkCmdSetDeviceMask = 190, - vkCmdSetDeviceMaskKHR = 191, - vkCmdSetDiscardRectangleEXT = 192, - vkCmdSetDiscardRectangleEnableEXT = 193, - vkCmdSetDiscardRectangleModeEXT = 194, - vkCmdSetEvent = 195, - vkCmdSetEvent2 = 196, - vkCmdSetEvent2KHR = 197, - vkCmdSetExclusiveScissorEnableNV = 198, - vkCmdSetExclusiveScissorNV = 199, - vkCmdSetExtraPrimitiveOverestimationSizeEXT = 200, - vkCmdSetFragmentShadingRateEnumNV = 201, - vkCmdSetFragmentShadingRateKHR = 202, - vkCmdSetFrontFace = 203, - vkCmdSetFrontFaceEXT = 204, - vkCmdSetLineRasterizationModeEXT = 205, - vkCmdSetLineStippleEXT = 206, - vkCmdSetLineStippleEnableEXT = 207, - vkCmdSetLineWidth = 208, - vkCmdSetLogicOpEXT = 209, - vkCmdSetLogicOpEnableEXT = 210, - vkCmdSetPatchControlPointsEXT = 211, - vkCmdSetPerformanceMarkerINTEL = 212, - vkCmdSetPerformanceOverrideINTEL = 213, - vkCmdSetPerformanceStreamMarkerINTEL = 214, - vkCmdSetPolygonModeEXT = 215, - vkCmdSetPrimitiveRestartEnable = 216, - vkCmdSetPrimitiveRestartEnableEXT = 217, - vkCmdSetPrimitiveTopology = 218, - vkCmdSetPrimitiveTopologyEXT = 219, - vkCmdSetProvokingVertexModeEXT = 220, - vkCmdSetRasterizationSamplesEXT = 221, - vkCmdSetRasterizationStreamEXT = 222, - vkCmdSetRasterizerDiscardEnable = 223, - vkCmdSetRasterizerDiscardEnableEXT = 224, - vkCmdSetRayTracingPipelineStackSizeKHR = 225, - vkCmdSetRepresentativeFragmentTestEnableNV = 226, - vkCmdSetSampleLocationsEXT = 227, - vkCmdSetSampleLocationsEnableEXT = 228, - vkCmdSetSampleMaskEXT = 229, - vkCmdSetScissor = 230, - vkCmdSetScissorWithCount = 231, - vkCmdSetScissorWithCountEXT = 232, - vkCmdSetShadingRateImageEnableNV = 233, - vkCmdSetStencilCompareMask = 234, - vkCmdSetStencilOp = 235, - vkCmdSetStencilOpEXT = 236, - vkCmdSetStencilReference = 237, - vkCmdSetStencilTestEnable = 238, - vkCmdSetStencilTestEnableEXT = 239, - vkCmdSetStencilWriteMask = 240, - vkCmdSetTessellationDomainOriginEXT = 241, - vkCmdSetVertexInputEXT = 242, - vkCmdSetViewport = 243, - vkCmdSetViewportShadingRatePaletteNV = 244, - vkCmdSetViewportSwizzleNV = 245, - vkCmdSetViewportWScalingEnableNV = 246, - vkCmdSetViewportWScalingNV = 247, - vkCmdSetViewportWithCount = 248, - vkCmdSetViewportWithCountEXT = 249, - vkCmdSubpassShadingHUAWEI = 250, - vkCmdTraceRaysIndirect2KHR = 251, - vkCmdTraceRaysIndirectKHR = 252, - vkCmdTraceRaysKHR = 253, - vkCmdTraceRaysNV = 254, - vkCmdUpdateBuffer = 255, - vkCmdUpdatePipelineIndirectBufferNV = 256, - vkCmdWaitEvents = 257, - vkCmdWaitEvents2 = 258, - vkCmdWaitEvents2KHR = 259, - vkCmdWriteAccelerationStructuresPropertiesKHR = 260, - vkCmdWriteAccelerationStructuresPropertiesNV = 261, - vkCmdWriteBufferMarker2AMD = 262, - vkCmdWriteBufferMarkerAMD = 263, - vkCmdWriteMicromapsPropertiesEXT = 264, - vkCmdWriteTimestamp = 265, - vkCmdWriteTimestamp2 = 266, - vkCmdWriteTimestamp2KHR = 267, - vkCompileDeferredNV = 268, - vkCopyAccelerationStructureKHR = 269, - vkCopyAccelerationStructureToMemoryKHR = 270, - vkCopyImageToImageEXT = 271, - vkCopyImageToMemoryEXT = 272, - vkCopyMemoryToAccelerationStructureKHR = 273, - vkCopyMemoryToImageEXT = 274, - vkCopyMemoryToMicromapEXT = 275, - vkCopyMicromapEXT = 276, - vkCopyMicromapToMemoryEXT = 277, - vkCreateAccelerationStructureKHR = 278, - vkCreateAccelerationStructureNV = 279, - vkCreateAndroidSurfaceKHR = 280, - vkCreateBuffer = 281, - vkCreateBufferCollectionFUCHSIA = 282, - vkCreateBufferView = 283, - vkCreateCommandPool = 284, - vkCreateComputePipelines = 285, - vkCreateCuFunctionNVX = 286, - vkCreateCuModuleNVX = 287, - vkCreateCudaFunctionNV = 288, - vkCreateCudaModuleNV = 289, - vkCreateDebugReportCallbackEXT = 290, - vkCreateDebugUtilsMessengerEXT = 291, - vkCreateDeferredOperationKHR = 292, - vkCreateDescriptorPool = 293, - vkCreateDescriptorSetLayout = 294, - vkCreateDescriptorUpdateTemplate = 295, - vkCreateDescriptorUpdateTemplateKHR = 296, - vkCreateDevice = 297, - vkCreateDirectFBSurfaceEXT = 298, - vkCreateDisplayModeKHR = 299, - vkCreateDisplayPlaneSurfaceKHR = 300, - vkCreateEvent = 301, - vkCreateExecutionGraphPipelinesAMDX = 302, - vkCreateFence = 303, - vkCreateFramebuffer = 304, - vkCreateGraphicsPipelines = 305, - vkCreateHeadlessSurfaceEXT = 306, - vkCreateIOSSurfaceMVK = 307, - vkCreateImage = 308, - vkCreateImagePipeSurfaceFUCHSIA = 309, - vkCreateImageView = 310, - vkCreateIndirectCommandsLayoutNV = 311, - vkCreateInstance = 312, - vkCreateMacOSSurfaceMVK = 313, - vkCreateMetalSurfaceEXT = 314, - vkCreateMicromapEXT = 315, - vkCreateOpticalFlowSessionNV = 316, - vkCreatePipelineCache = 317, - vkCreatePipelineLayout = 318, - vkCreatePrivateDataSlot = 319, - vkCreatePrivateDataSlotEXT = 320, - vkCreateQueryPool = 321, - vkCreateRayTracingPipelinesKHR = 322, - vkCreateRayTracingPipelinesNV = 323, - vkCreateRenderPass = 324, - vkCreateRenderPass2 = 325, - vkCreateRenderPass2KHR = 326, - vkCreateSampler = 327, - vkCreateSamplerYcbcrConversion = 328, - vkCreateSamplerYcbcrConversionKHR = 329, - vkCreateScreenSurfaceQNX = 330, - vkCreateSemaphore = 331, - vkCreateShaderModule = 332, - vkCreateShadersEXT = 333, - vkCreateSharedSwapchainsKHR = 334, - vkCreateStreamDescriptorSurfaceGGP = 335, - vkCreateSwapchainKHR = 336, - vkCreateValidationCacheEXT = 337, - vkCreateViSurfaceNN = 338, - vkCreateVideoSessionKHR = 339, - vkCreateVideoSessionParametersKHR = 340, - vkCreateWaylandSurfaceKHR = 341, - vkCreateWin32SurfaceKHR = 342, - vkCreateXcbSurfaceKHR = 343, - vkCreateXlibSurfaceKHR = 344, - vkDebugMarkerSetObjectNameEXT = 345, - vkDebugMarkerSetObjectTagEXT = 346, - vkDebugReportMessageEXT = 347, - vkDeferredOperationJoinKHR = 348, - vkDestroyAccelerationStructureKHR = 349, - vkDestroyAccelerationStructureNV = 350, - vkDestroyBuffer = 351, - vkDestroyBufferCollectionFUCHSIA = 352, - vkDestroyBufferView = 353, - vkDestroyCommandPool = 354, - vkDestroyCuFunctionNVX = 355, - vkDestroyCuModuleNVX = 356, - vkDestroyCudaFunctionNV = 357, - vkDestroyCudaModuleNV = 358, - vkDestroyDebugReportCallbackEXT = 359, - vkDestroyDebugUtilsMessengerEXT = 360, - vkDestroyDeferredOperationKHR = 361, - vkDestroyDescriptorPool = 362, - vkDestroyDescriptorSetLayout = 363, - vkDestroyDescriptorUpdateTemplate = 364, - vkDestroyDescriptorUpdateTemplateKHR = 365, - vkDestroyDevice = 366, - vkDestroyEvent = 367, - vkDestroyFence = 368, - vkDestroyFramebuffer = 369, - vkDestroyImage = 370, - vkDestroyImageView = 371, - vkDestroyIndirectCommandsLayoutNV = 372, - vkDestroyInstance = 373, - vkDestroyMicromapEXT = 374, - vkDestroyOpticalFlowSessionNV = 375, - vkDestroyPipeline = 376, - vkDestroyPipelineCache = 377, - vkDestroyPipelineLayout = 378, - vkDestroyPrivateDataSlot = 379, - vkDestroyPrivateDataSlotEXT = 380, - vkDestroyQueryPool = 381, - vkDestroyRenderPass = 382, - vkDestroySampler = 383, - vkDestroySamplerYcbcrConversion = 384, - vkDestroySamplerYcbcrConversionKHR = 385, - vkDestroySemaphore = 386, - vkDestroyShaderEXT = 387, - vkDestroyShaderModule = 388, - vkDestroySurfaceKHR = 389, - vkDestroySwapchainKHR = 390, - vkDestroyValidationCacheEXT = 391, - vkDestroyVideoSessionKHR = 392, - vkDestroyVideoSessionParametersKHR = 393, - vkDeviceWaitIdle = 394, - vkDisplayPowerControlEXT = 395, - vkEndCommandBuffer = 396, - vkEnumerateDeviceExtensionProperties = 397, - vkEnumerateDeviceLayerProperties = 398, - vkEnumerateInstanceExtensionProperties = 399, - vkEnumerateInstanceLayerProperties = 400, - vkEnumerateInstanceVersion = 401, - vkEnumeratePhysicalDeviceGroups = 402, - vkEnumeratePhysicalDeviceGroupsKHR = 403, - vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 404, - vkEnumeratePhysicalDevices = 405, - vkExportMetalObjectsEXT = 406, - vkFlushMappedMemoryRanges = 407, - vkFreeCommandBuffers = 408, - vkFreeDescriptorSets = 409, - vkFreeMemory = 410, - vkGetAccelerationStructureBuildSizesKHR = 411, - vkGetAccelerationStructureDeviceAddressKHR = 412, - vkGetAccelerationStructureHandleNV = 413, - vkGetAccelerationStructureMemoryRequirementsNV = 414, - vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = 415, - vkGetAndroidHardwareBufferPropertiesANDROID = 416, - vkGetBufferCollectionPropertiesFUCHSIA = 417, - vkGetBufferDeviceAddress = 418, - vkGetBufferDeviceAddressEXT = 419, - vkGetBufferDeviceAddressKHR = 420, - vkGetBufferMemoryRequirements = 421, - vkGetBufferMemoryRequirements2 = 422, - vkGetBufferMemoryRequirements2KHR = 423, - vkGetBufferOpaqueCaptureAddress = 424, - vkGetBufferOpaqueCaptureAddressKHR = 425, - vkGetBufferOpaqueCaptureDescriptorDataEXT = 426, - vkGetCalibratedTimestampsEXT = 427, - vkGetCalibratedTimestampsKHR = 428, - vkGetCudaModuleCacheNV = 429, - vkGetDeferredOperationMaxConcurrencyKHR = 430, - vkGetDeferredOperationResultKHR = 431, - vkGetDescriptorEXT = 432, - vkGetDescriptorSetHostMappingVALVE = 433, - vkGetDescriptorSetLayoutBindingOffsetEXT = 434, - vkGetDescriptorSetLayoutHostMappingInfoVALVE = 435, - vkGetDescriptorSetLayoutSizeEXT = 436, - vkGetDescriptorSetLayoutSupport = 437, - vkGetDescriptorSetLayoutSupportKHR = 438, - vkGetDeviceAccelerationStructureCompatibilityKHR = 439, - vkGetDeviceBufferMemoryRequirements = 440, - vkGetDeviceBufferMemoryRequirementsKHR = 441, - vkGetDeviceFaultInfoEXT = 442, - vkGetDeviceGroupPeerMemoryFeatures = 443, - vkGetDeviceGroupPeerMemoryFeaturesKHR = 444, - vkGetDeviceGroupPresentCapabilitiesKHR = 445, - vkGetDeviceGroupSurfacePresentModes2EXT = 446, - vkGetDeviceGroupSurfacePresentModesKHR = 447, - vkGetDeviceImageMemoryRequirements = 448, - vkGetDeviceImageMemoryRequirementsKHR = 449, - vkGetDeviceImageSparseMemoryRequirements = 450, - vkGetDeviceImageSparseMemoryRequirementsKHR = 451, - vkGetDeviceImageSubresourceLayoutKHR = 452, - vkGetDeviceMemoryCommitment = 453, - vkGetDeviceMemoryOpaqueCaptureAddress = 454, - vkGetDeviceMemoryOpaqueCaptureAddressKHR = 455, - vkGetDeviceMicromapCompatibilityEXT = 456, - vkGetDeviceProcAddr = 457, - vkGetDeviceQueue = 458, - vkGetDeviceQueue2 = 459, - vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 460, - vkGetDisplayModeProperties2KHR = 461, - vkGetDisplayModePropertiesKHR = 462, - vkGetDisplayPlaneCapabilities2KHR = 463, - vkGetDisplayPlaneCapabilitiesKHR = 464, - vkGetDisplayPlaneSupportedDisplaysKHR = 465, - vkGetDrmDisplayEXT = 466, - vkGetDynamicRenderingTilePropertiesQCOM = 467, - vkGetEncodedVideoSessionParametersKHR = 468, - vkGetEventStatus = 469, - vkGetExecutionGraphPipelineNodeIndexAMDX = 470, - vkGetExecutionGraphPipelineScratchSizeAMDX = 471, - vkGetFenceFdKHR = 472, - vkGetFenceStatus = 473, - vkGetFenceWin32HandleKHR = 474, - vkGetFramebufferTilePropertiesQCOM = 475, - vkGetGeneratedCommandsMemoryRequirementsNV = 476, - vkGetImageDrmFormatModifierPropertiesEXT = 477, - vkGetImageMemoryRequirements = 478, - vkGetImageMemoryRequirements2 = 479, - vkGetImageMemoryRequirements2KHR = 480, - vkGetImageOpaqueCaptureDescriptorDataEXT = 481, - vkGetImageSparseMemoryRequirements = 482, - vkGetImageSparseMemoryRequirements2 = 483, - vkGetImageSparseMemoryRequirements2KHR = 484, - vkGetImageSubresourceLayout = 485, - vkGetImageSubresourceLayout2EXT = 486, - vkGetImageSubresourceLayout2KHR = 487, - vkGetImageViewAddressNVX = 488, - vkGetImageViewHandleNVX = 489, - vkGetImageViewOpaqueCaptureDescriptorDataEXT = 490, - vkGetInstanceProcAddr = 491, - vkGetLatencyTimingsNV = 492, - vkGetMemoryAndroidHardwareBufferANDROID = 493, - vkGetMemoryFdKHR = 494, - vkGetMemoryFdPropertiesKHR = 495, - vkGetMemoryHostPointerPropertiesEXT = 496, - vkGetMemoryRemoteAddressNV = 497, - vkGetMemoryWin32HandleKHR = 498, - vkGetMemoryWin32HandleNV = 499, - vkGetMemoryWin32HandlePropertiesKHR = 500, - vkGetMemoryZirconHandleFUCHSIA = 501, - vkGetMemoryZirconHandlePropertiesFUCHSIA = 502, - vkGetMicromapBuildSizesEXT = 503, - vkGetPastPresentationTimingGOOGLE = 504, - vkGetPerformanceParameterINTEL = 505, - vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 506, - vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 507, - vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = 508, - vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 509, - vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 510, - vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 511, - vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 512, - vkGetPhysicalDeviceDisplayProperties2KHR = 513, - vkGetPhysicalDeviceDisplayPropertiesKHR = 514, - vkGetPhysicalDeviceExternalBufferProperties = 515, - vkGetPhysicalDeviceExternalBufferPropertiesKHR = 516, - vkGetPhysicalDeviceExternalFenceProperties = 517, - vkGetPhysicalDeviceExternalFencePropertiesKHR = 518, - vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 519, - vkGetPhysicalDeviceExternalSemaphoreProperties = 520, - vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 521, - vkGetPhysicalDeviceFeatures = 522, - vkGetPhysicalDeviceFeatures2 = 523, - vkGetPhysicalDeviceFeatures2KHR = 524, - vkGetPhysicalDeviceFormatProperties = 525, - vkGetPhysicalDeviceFormatProperties2 = 526, - vkGetPhysicalDeviceFormatProperties2KHR = 527, - vkGetPhysicalDeviceFragmentShadingRatesKHR = 528, - vkGetPhysicalDeviceImageFormatProperties = 529, - vkGetPhysicalDeviceImageFormatProperties2 = 530, - vkGetPhysicalDeviceImageFormatProperties2KHR = 531, - vkGetPhysicalDeviceMemoryProperties = 532, - vkGetPhysicalDeviceMemoryProperties2 = 533, - vkGetPhysicalDeviceMemoryProperties2KHR = 534, - vkGetPhysicalDeviceMultisamplePropertiesEXT = 535, - vkGetPhysicalDeviceOpticalFlowImageFormatsNV = 536, - vkGetPhysicalDevicePresentRectanglesKHR = 537, - vkGetPhysicalDeviceProperties = 538, - vkGetPhysicalDeviceProperties2 = 539, - vkGetPhysicalDeviceProperties2KHR = 540, - vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 541, - vkGetPhysicalDeviceQueueFamilyProperties = 542, - vkGetPhysicalDeviceQueueFamilyProperties2 = 543, - vkGetPhysicalDeviceQueueFamilyProperties2KHR = 544, - vkGetPhysicalDeviceScreenPresentationSupportQNX = 545, - vkGetPhysicalDeviceSparseImageFormatProperties = 546, - vkGetPhysicalDeviceSparseImageFormatProperties2 = 547, - vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 548, - vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 549, - vkGetPhysicalDeviceSurfaceCapabilities2EXT = 550, - vkGetPhysicalDeviceSurfaceCapabilities2KHR = 551, - vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 552, - vkGetPhysicalDeviceSurfaceFormats2KHR = 553, - vkGetPhysicalDeviceSurfaceFormatsKHR = 554, - vkGetPhysicalDeviceSurfacePresentModes2EXT = 555, - vkGetPhysicalDeviceSurfacePresentModesKHR = 556, - vkGetPhysicalDeviceSurfaceSupportKHR = 557, - vkGetPhysicalDeviceToolProperties = 558, - vkGetPhysicalDeviceToolPropertiesEXT = 559, - vkGetPhysicalDeviceVideoCapabilitiesKHR = 560, - vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = 561, - vkGetPhysicalDeviceVideoFormatPropertiesKHR = 562, - vkGetPhysicalDeviceWaylandPresentationSupportKHR = 563, - vkGetPhysicalDeviceWin32PresentationSupportKHR = 564, - vkGetPhysicalDeviceXcbPresentationSupportKHR = 565, - vkGetPhysicalDeviceXlibPresentationSupportKHR = 566, - vkGetPipelineCacheData = 567, - vkGetPipelineExecutableInternalRepresentationsKHR = 568, - vkGetPipelineExecutablePropertiesKHR = 569, - vkGetPipelineExecutableStatisticsKHR = 570, - vkGetPipelineIndirectDeviceAddressNV = 571, - vkGetPipelineIndirectMemoryRequirementsNV = 572, - vkGetPipelinePropertiesEXT = 573, - vkGetPrivateData = 574, - vkGetPrivateDataEXT = 575, - vkGetQueryPoolResults = 576, - vkGetQueueCheckpointData2NV = 577, - vkGetQueueCheckpointDataNV = 578, - vkGetRandROutputDisplayEXT = 579, - vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 580, - vkGetRayTracingShaderGroupHandlesKHR = 581, - vkGetRayTracingShaderGroupHandlesNV = 582, - vkGetRayTracingShaderGroupStackSizeKHR = 583, - vkGetRefreshCycleDurationGOOGLE = 584, - vkGetRenderAreaGranularity = 585, - vkGetRenderingAreaGranularityKHR = 586, - vkGetSamplerOpaqueCaptureDescriptorDataEXT = 587, - vkGetScreenBufferPropertiesQNX = 588, - vkGetSemaphoreCounterValue = 589, - vkGetSemaphoreCounterValueKHR = 590, - vkGetSemaphoreFdKHR = 591, - vkGetSemaphoreWin32HandleKHR = 592, - vkGetSemaphoreZirconHandleFUCHSIA = 593, - vkGetShaderBinaryDataEXT = 594, - vkGetShaderInfoAMD = 595, - vkGetShaderModuleCreateInfoIdentifierEXT = 596, - vkGetShaderModuleIdentifierEXT = 597, - vkGetSwapchainCounterEXT = 598, - vkGetSwapchainImagesKHR = 599, - vkGetSwapchainStatusKHR = 600, - vkGetValidationCacheDataEXT = 601, - vkGetVideoSessionMemoryRequirementsKHR = 602, - vkGetWinrtDisplayNV = 603, - vkImportFenceFdKHR = 604, - vkImportFenceWin32HandleKHR = 605, - vkImportSemaphoreFdKHR = 606, - vkImportSemaphoreWin32HandleKHR = 607, - vkImportSemaphoreZirconHandleFUCHSIA = 608, - vkInitializePerformanceApiINTEL = 609, - vkInvalidateMappedMemoryRanges = 610, - vkLatencySleepNV = 611, - vkMapMemory = 612, - vkMapMemory2KHR = 613, - vkMergePipelineCaches = 614, - vkMergeValidationCachesEXT = 615, - vkQueueBeginDebugUtilsLabelEXT = 616, - vkQueueBindSparse = 617, - vkQueueEndDebugUtilsLabelEXT = 618, - vkQueueInsertDebugUtilsLabelEXT = 619, - vkQueueNotifyOutOfBandNV = 620, - vkQueuePresentKHR = 621, - vkQueueSetPerformanceConfigurationINTEL = 622, - vkQueueSubmit = 623, - vkQueueSubmit2 = 624, - vkQueueSubmit2KHR = 625, - vkQueueWaitIdle = 626, - vkRegisterDeviceEventEXT = 627, - vkRegisterDisplayEventEXT = 628, - vkReleaseDisplayEXT = 629, - vkReleaseFullScreenExclusiveModeEXT = 630, - vkReleasePerformanceConfigurationINTEL = 631, - vkReleaseProfilingLockKHR = 632, - vkReleaseSwapchainImagesEXT = 633, - vkResetCommandBuffer = 634, - vkResetCommandPool = 635, - vkResetDescriptorPool = 636, - vkResetEvent = 637, - vkResetFences = 638, - vkResetQueryPool = 639, - vkResetQueryPoolEXT = 640, - vkSetBufferCollectionBufferConstraintsFUCHSIA = 641, - vkSetBufferCollectionImageConstraintsFUCHSIA = 642, - vkSetDebugUtilsObjectNameEXT = 643, - vkSetDebugUtilsObjectTagEXT = 644, - vkSetDeviceMemoryPriorityEXT = 645, - vkSetEvent = 646, - vkSetHdrMetadataEXT = 647, - vkSetLatencyMarkerNV = 648, - vkSetLatencySleepModeNV = 649, - vkSetLocalDimmingAMD = 650, - vkSetPrivateData = 651, - vkSetPrivateDataEXT = 652, - vkSignalSemaphore = 653, - vkSignalSemaphoreKHR = 654, - vkSubmitDebugUtilsMessageEXT = 655, - vkTransitionImageLayoutEXT = 656, - vkTrimCommandPool = 657, - vkTrimCommandPoolKHR = 658, - vkUninitializePerformanceApiINTEL = 659, - vkUnmapMemory = 660, - vkUnmapMemory2KHR = 661, - vkUpdateDescriptorSetWithTemplate = 662, - vkUpdateDescriptorSetWithTemplateKHR = 663, - vkUpdateDescriptorSets = 664, - vkUpdateVideoSessionParametersKHR = 665, - vkWaitForFences = 666, - vkWaitForPresentKHR = 667, - vkWaitSemaphores = 668, - vkWaitSemaphoresKHR = 669, - vkWriteAccelerationStructuresPropertiesKHR = 670, - vkWriteMicromapsPropertiesEXT = 671, + vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = 35, + vkCmdBindDescriptorBufferEmbeddedSamplersEXT = 36, + vkCmdBindDescriptorBuffersEXT = 37, + vkCmdBindDescriptorSets = 38, + vkCmdBindDescriptorSets2KHR = 39, + vkCmdBindIndexBuffer = 40, + vkCmdBindIndexBuffer2KHR = 41, + vkCmdBindInvocationMaskHUAWEI = 42, + vkCmdBindPipeline = 43, + vkCmdBindPipelineShaderGroupNV = 44, + vkCmdBindShadersEXT = 45, + vkCmdBindShadingRateImageNV = 46, + vkCmdBindTransformFeedbackBuffersEXT = 47, + vkCmdBindVertexBuffers = 48, + vkCmdBindVertexBuffers2 = 49, + vkCmdBindVertexBuffers2EXT = 50, + vkCmdBlitImage = 51, + vkCmdBlitImage2 = 52, + vkCmdBlitImage2KHR = 53, + vkCmdBuildAccelerationStructureNV = 54, + vkCmdBuildAccelerationStructuresIndirectKHR = 55, + vkCmdBuildAccelerationStructuresKHR = 56, + vkCmdBuildMicromapsEXT = 57, + vkCmdClearAttachments = 58, + vkCmdClearColorImage = 59, + vkCmdClearDepthStencilImage = 60, + vkCmdControlVideoCodingKHR = 61, + vkCmdCopyAccelerationStructureKHR = 62, + vkCmdCopyAccelerationStructureNV = 63, + vkCmdCopyAccelerationStructureToMemoryKHR = 64, + vkCmdCopyBuffer = 65, + vkCmdCopyBuffer2 = 66, + vkCmdCopyBuffer2KHR = 67, + vkCmdCopyBufferToImage = 68, + vkCmdCopyBufferToImage2 = 69, + vkCmdCopyBufferToImage2KHR = 70, + vkCmdCopyImage = 71, + vkCmdCopyImage2 = 72, + vkCmdCopyImage2KHR = 73, + vkCmdCopyImageToBuffer = 74, + vkCmdCopyImageToBuffer2 = 75, + vkCmdCopyImageToBuffer2KHR = 76, + vkCmdCopyMemoryIndirectNV = 77, + vkCmdCopyMemoryToAccelerationStructureKHR = 78, + vkCmdCopyMemoryToImageIndirectNV = 79, + vkCmdCopyMemoryToMicromapEXT = 80, + vkCmdCopyMicromapEXT = 81, + vkCmdCopyMicromapToMemoryEXT = 82, + vkCmdCopyQueryPoolResults = 83, + vkCmdCuLaunchKernelNVX = 84, + vkCmdCudaLaunchKernelNV = 85, + vkCmdDebugMarkerBeginEXT = 86, + vkCmdDebugMarkerEndEXT = 87, + vkCmdDebugMarkerInsertEXT = 88, + vkCmdDecodeVideoKHR = 89, + vkCmdDecompressMemoryIndirectCountNV = 90, + vkCmdDecompressMemoryNV = 91, + vkCmdDispatch = 92, + vkCmdDispatchBase = 93, + vkCmdDispatchBaseKHR = 94, + vkCmdDispatchGraphAMDX = 95, + vkCmdDispatchGraphIndirectAMDX = 96, + vkCmdDispatchGraphIndirectCountAMDX = 97, + vkCmdDispatchIndirect = 98, + vkCmdDraw = 99, + vkCmdDrawClusterHUAWEI = 100, + vkCmdDrawClusterIndirectHUAWEI = 101, + vkCmdDrawIndexed = 102, + vkCmdDrawIndexedIndirect = 103, + vkCmdDrawIndexedIndirectCount = 104, + vkCmdDrawIndexedIndirectCountAMD = 105, + vkCmdDrawIndexedIndirectCountKHR = 106, + vkCmdDrawIndirect = 107, + vkCmdDrawIndirectByteCountEXT = 108, + vkCmdDrawIndirectCount = 109, + vkCmdDrawIndirectCountAMD = 110, + vkCmdDrawIndirectCountKHR = 111, + vkCmdDrawMeshTasksEXT = 112, + vkCmdDrawMeshTasksIndirectCountEXT = 113, + vkCmdDrawMeshTasksIndirectCountNV = 114, + vkCmdDrawMeshTasksIndirectEXT = 115, + vkCmdDrawMeshTasksIndirectNV = 116, + vkCmdDrawMeshTasksNV = 117, + vkCmdDrawMultiEXT = 118, + vkCmdDrawMultiIndexedEXT = 119, + vkCmdEncodeVideoKHR = 120, + vkCmdEndConditionalRenderingEXT = 121, + vkCmdEndDebugUtilsLabelEXT = 122, + vkCmdEndQuery = 123, + vkCmdEndQueryIndexedEXT = 124, + vkCmdEndRenderPass = 125, + vkCmdEndRenderPass2 = 126, + vkCmdEndRenderPass2KHR = 127, + vkCmdEndRendering = 128, + vkCmdEndRenderingKHR = 129, + vkCmdEndTransformFeedbackEXT = 130, + vkCmdEndVideoCodingKHR = 131, + vkCmdExecuteCommands = 132, + vkCmdExecuteGeneratedCommandsNV = 133, + vkCmdFillBuffer = 134, + vkCmdInitializeGraphScratchMemoryAMDX = 135, + vkCmdInsertDebugUtilsLabelEXT = 136, + vkCmdNextSubpass = 137, + vkCmdNextSubpass2 = 138, + vkCmdNextSubpass2KHR = 139, + vkCmdOpticalFlowExecuteNV = 140, + vkCmdPipelineBarrier = 141, + vkCmdPipelineBarrier2 = 142, + vkCmdPipelineBarrier2KHR = 143, + vkCmdPreprocessGeneratedCommandsNV = 144, + vkCmdPushConstants = 145, + vkCmdPushConstants2KHR = 146, + vkCmdPushDescriptorSet2KHR = 147, + vkCmdPushDescriptorSetKHR = 148, + vkCmdPushDescriptorSetWithTemplate2KHR = 149, + vkCmdPushDescriptorSetWithTemplateKHR = 150, + vkCmdResetEvent = 151, + vkCmdResetEvent2 = 152, + vkCmdResetEvent2KHR = 153, + vkCmdResetQueryPool = 154, + vkCmdResolveImage = 155, + vkCmdResolveImage2 = 156, + vkCmdResolveImage2KHR = 157, + vkCmdSetAlphaToCoverageEnableEXT = 158, + vkCmdSetAlphaToOneEnableEXT = 159, + vkCmdSetAttachmentFeedbackLoopEnableEXT = 160, + vkCmdSetBlendConstants = 161, + vkCmdSetCheckpointNV = 162, + vkCmdSetCoarseSampleOrderNV = 163, + vkCmdSetColorBlendAdvancedEXT = 164, + vkCmdSetColorBlendEnableEXT = 165, + vkCmdSetColorBlendEquationEXT = 166, + vkCmdSetColorWriteEnableEXT = 167, + vkCmdSetColorWriteMaskEXT = 168, + vkCmdSetConservativeRasterizationModeEXT = 169, + vkCmdSetCoverageModulationModeNV = 170, + vkCmdSetCoverageModulationTableEnableNV = 171, + vkCmdSetCoverageModulationTableNV = 172, + vkCmdSetCoverageReductionModeNV = 173, + vkCmdSetCoverageToColorEnableNV = 174, + vkCmdSetCoverageToColorLocationNV = 175, + vkCmdSetCullMode = 176, + vkCmdSetCullModeEXT = 177, + vkCmdSetDepthBias = 178, + vkCmdSetDepthBias2EXT = 179, + vkCmdSetDepthBiasEnable = 180, + vkCmdSetDepthBiasEnableEXT = 181, + vkCmdSetDepthBounds = 182, + vkCmdSetDepthBoundsTestEnable = 183, + vkCmdSetDepthBoundsTestEnableEXT = 184, + vkCmdSetDepthClampEnableEXT = 185, + vkCmdSetDepthClipEnableEXT = 186, + vkCmdSetDepthClipNegativeOneToOneEXT = 187, + vkCmdSetDepthCompareOp = 188, + vkCmdSetDepthCompareOpEXT = 189, + vkCmdSetDepthTestEnable = 190, + vkCmdSetDepthTestEnableEXT = 191, + vkCmdSetDepthWriteEnable = 192, + vkCmdSetDepthWriteEnableEXT = 193, + vkCmdSetDescriptorBufferOffsets2EXT = 194, + vkCmdSetDescriptorBufferOffsetsEXT = 195, + vkCmdSetDeviceMask = 196, + vkCmdSetDeviceMaskKHR = 197, + vkCmdSetDiscardRectangleEXT = 198, + vkCmdSetDiscardRectangleEnableEXT = 199, + vkCmdSetDiscardRectangleModeEXT = 200, + vkCmdSetEvent = 201, + vkCmdSetEvent2 = 202, + vkCmdSetEvent2KHR = 203, + vkCmdSetExclusiveScissorEnableNV = 204, + vkCmdSetExclusiveScissorNV = 205, + vkCmdSetExtraPrimitiveOverestimationSizeEXT = 206, + vkCmdSetFragmentShadingRateEnumNV = 207, + vkCmdSetFragmentShadingRateKHR = 208, + vkCmdSetFrontFace = 209, + vkCmdSetFrontFaceEXT = 210, + vkCmdSetLineRasterizationModeEXT = 211, + vkCmdSetLineStippleEXT = 212, + vkCmdSetLineStippleEnableEXT = 213, + vkCmdSetLineWidth = 214, + vkCmdSetLogicOpEXT = 215, + vkCmdSetLogicOpEnableEXT = 216, + vkCmdSetPatchControlPointsEXT = 217, + vkCmdSetPerformanceMarkerINTEL = 218, + vkCmdSetPerformanceOverrideINTEL = 219, + vkCmdSetPerformanceStreamMarkerINTEL = 220, + vkCmdSetPolygonModeEXT = 221, + vkCmdSetPrimitiveRestartEnable = 222, + vkCmdSetPrimitiveRestartEnableEXT = 223, + vkCmdSetPrimitiveTopology = 224, + vkCmdSetPrimitiveTopologyEXT = 225, + vkCmdSetProvokingVertexModeEXT = 226, + vkCmdSetRasterizationSamplesEXT = 227, + vkCmdSetRasterizationStreamEXT = 228, + vkCmdSetRasterizerDiscardEnable = 229, + vkCmdSetRasterizerDiscardEnableEXT = 230, + vkCmdSetRayTracingPipelineStackSizeKHR = 231, + vkCmdSetRepresentativeFragmentTestEnableNV = 232, + vkCmdSetSampleLocationsEXT = 233, + vkCmdSetSampleLocationsEnableEXT = 234, + vkCmdSetSampleMaskEXT = 235, + vkCmdSetScissor = 236, + vkCmdSetScissorWithCount = 237, + vkCmdSetScissorWithCountEXT = 238, + vkCmdSetShadingRateImageEnableNV = 239, + vkCmdSetStencilCompareMask = 240, + vkCmdSetStencilOp = 241, + vkCmdSetStencilOpEXT = 242, + vkCmdSetStencilReference = 243, + vkCmdSetStencilTestEnable = 244, + vkCmdSetStencilTestEnableEXT = 245, + vkCmdSetStencilWriteMask = 246, + vkCmdSetTessellationDomainOriginEXT = 247, + vkCmdSetVertexInputEXT = 248, + vkCmdSetViewport = 249, + vkCmdSetViewportShadingRatePaletteNV = 250, + vkCmdSetViewportSwizzleNV = 251, + vkCmdSetViewportWScalingEnableNV = 252, + vkCmdSetViewportWScalingNV = 253, + vkCmdSetViewportWithCount = 254, + vkCmdSetViewportWithCountEXT = 255, + vkCmdSubpassShadingHUAWEI = 256, + vkCmdTraceRaysIndirect2KHR = 257, + vkCmdTraceRaysIndirectKHR = 258, + vkCmdTraceRaysKHR = 259, + vkCmdTraceRaysNV = 260, + vkCmdUpdateBuffer = 261, + vkCmdUpdatePipelineIndirectBufferNV = 262, + vkCmdWaitEvents = 263, + vkCmdWaitEvents2 = 264, + vkCmdWaitEvents2KHR = 265, + vkCmdWriteAccelerationStructuresPropertiesKHR = 266, + vkCmdWriteAccelerationStructuresPropertiesNV = 267, + vkCmdWriteBufferMarker2AMD = 268, + vkCmdWriteBufferMarkerAMD = 269, + vkCmdWriteMicromapsPropertiesEXT = 270, + vkCmdWriteTimestamp = 271, + vkCmdWriteTimestamp2 = 272, + vkCmdWriteTimestamp2KHR = 273, + vkCompileDeferredNV = 274, + vkCopyAccelerationStructureKHR = 275, + vkCopyAccelerationStructureToMemoryKHR = 276, + vkCopyImageToImageEXT = 277, + vkCopyImageToMemoryEXT = 278, + vkCopyMemoryToAccelerationStructureKHR = 279, + vkCopyMemoryToImageEXT = 280, + vkCopyMemoryToMicromapEXT = 281, + vkCopyMicromapEXT = 282, + vkCopyMicromapToMemoryEXT = 283, + vkCreateAccelerationStructureKHR = 284, + vkCreateAccelerationStructureNV = 285, + vkCreateAndroidSurfaceKHR = 286, + vkCreateBuffer = 287, + vkCreateBufferCollectionFUCHSIA = 288, + vkCreateBufferView = 289, + vkCreateCommandPool = 290, + vkCreateComputePipelines = 291, + vkCreateCuFunctionNVX = 292, + vkCreateCuModuleNVX = 293, + vkCreateCudaFunctionNV = 294, + vkCreateCudaModuleNV = 295, + vkCreateDebugReportCallbackEXT = 296, + vkCreateDebugUtilsMessengerEXT = 297, + vkCreateDeferredOperationKHR = 298, + vkCreateDescriptorPool = 299, + vkCreateDescriptorSetLayout = 300, + vkCreateDescriptorUpdateTemplate = 301, + vkCreateDescriptorUpdateTemplateKHR = 302, + vkCreateDevice = 303, + vkCreateDirectFBSurfaceEXT = 304, + vkCreateDisplayModeKHR = 305, + vkCreateDisplayPlaneSurfaceKHR = 306, + vkCreateEvent = 307, + vkCreateExecutionGraphPipelinesAMDX = 308, + vkCreateFence = 309, + vkCreateFramebuffer = 310, + vkCreateGraphicsPipelines = 311, + vkCreateHeadlessSurfaceEXT = 312, + vkCreateIOSSurfaceMVK = 313, + vkCreateImage = 314, + vkCreateImagePipeSurfaceFUCHSIA = 315, + vkCreateImageView = 316, + vkCreateIndirectCommandsLayoutNV = 317, + vkCreateInstance = 318, + vkCreateMacOSSurfaceMVK = 319, + vkCreateMetalSurfaceEXT = 320, + vkCreateMicromapEXT = 321, + vkCreateOpticalFlowSessionNV = 322, + vkCreatePipelineCache = 323, + vkCreatePipelineLayout = 324, + vkCreatePrivateDataSlot = 325, + vkCreatePrivateDataSlotEXT = 326, + vkCreateQueryPool = 327, + vkCreateRayTracingPipelinesKHR = 328, + vkCreateRayTracingPipelinesNV = 329, + vkCreateRenderPass = 330, + vkCreateRenderPass2 = 331, + vkCreateRenderPass2KHR = 332, + vkCreateSampler = 333, + vkCreateSamplerYcbcrConversion = 334, + vkCreateSamplerYcbcrConversionKHR = 335, + vkCreateScreenSurfaceQNX = 336, + vkCreateSemaphore = 337, + vkCreateShaderModule = 338, + vkCreateShadersEXT = 339, + vkCreateSharedSwapchainsKHR = 340, + vkCreateStreamDescriptorSurfaceGGP = 341, + vkCreateSwapchainKHR = 342, + vkCreateValidationCacheEXT = 343, + vkCreateViSurfaceNN = 344, + vkCreateVideoSessionKHR = 345, + vkCreateVideoSessionParametersKHR = 346, + vkCreateWaylandSurfaceKHR = 347, + vkCreateWin32SurfaceKHR = 348, + vkCreateXcbSurfaceKHR = 349, + vkCreateXlibSurfaceKHR = 350, + vkDebugMarkerSetObjectNameEXT = 351, + vkDebugMarkerSetObjectTagEXT = 352, + vkDebugReportMessageEXT = 353, + vkDeferredOperationJoinKHR = 354, + vkDestroyAccelerationStructureKHR = 355, + vkDestroyAccelerationStructureNV = 356, + vkDestroyBuffer = 357, + vkDestroyBufferCollectionFUCHSIA = 358, + vkDestroyBufferView = 359, + vkDestroyCommandPool = 360, + vkDestroyCuFunctionNVX = 361, + vkDestroyCuModuleNVX = 362, + vkDestroyCudaFunctionNV = 363, + vkDestroyCudaModuleNV = 364, + vkDestroyDebugReportCallbackEXT = 365, + vkDestroyDebugUtilsMessengerEXT = 366, + vkDestroyDeferredOperationKHR = 367, + vkDestroyDescriptorPool = 368, + vkDestroyDescriptorSetLayout = 369, + vkDestroyDescriptorUpdateTemplate = 370, + vkDestroyDescriptorUpdateTemplateKHR = 371, + vkDestroyDevice = 372, + vkDestroyEvent = 373, + vkDestroyFence = 374, + vkDestroyFramebuffer = 375, + vkDestroyImage = 376, + vkDestroyImageView = 377, + vkDestroyIndirectCommandsLayoutNV = 378, + vkDestroyInstance = 379, + vkDestroyMicromapEXT = 380, + vkDestroyOpticalFlowSessionNV = 381, + vkDestroyPipeline = 382, + vkDestroyPipelineCache = 383, + vkDestroyPipelineLayout = 384, + vkDestroyPrivateDataSlot = 385, + vkDestroyPrivateDataSlotEXT = 386, + vkDestroyQueryPool = 387, + vkDestroyRenderPass = 388, + vkDestroySampler = 389, + vkDestroySamplerYcbcrConversion = 390, + vkDestroySamplerYcbcrConversionKHR = 391, + vkDestroySemaphore = 392, + vkDestroyShaderEXT = 393, + vkDestroyShaderModule = 394, + vkDestroySurfaceKHR = 395, + vkDestroySwapchainKHR = 396, + vkDestroyValidationCacheEXT = 397, + vkDestroyVideoSessionKHR = 398, + vkDestroyVideoSessionParametersKHR = 399, + vkDeviceWaitIdle = 400, + vkDisplayPowerControlEXT = 401, + vkEndCommandBuffer = 402, + vkEnumerateDeviceExtensionProperties = 403, + vkEnumerateDeviceLayerProperties = 404, + vkEnumerateInstanceExtensionProperties = 405, + vkEnumerateInstanceLayerProperties = 406, + vkEnumerateInstanceVersion = 407, + vkEnumeratePhysicalDeviceGroups = 408, + vkEnumeratePhysicalDeviceGroupsKHR = 409, + vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 410, + vkEnumeratePhysicalDevices = 411, + vkExportMetalObjectsEXT = 412, + vkFlushMappedMemoryRanges = 413, + vkFreeCommandBuffers = 414, + vkFreeDescriptorSets = 415, + vkFreeMemory = 416, + vkGetAccelerationStructureBuildSizesKHR = 417, + vkGetAccelerationStructureDeviceAddressKHR = 418, + vkGetAccelerationStructureHandleNV = 419, + vkGetAccelerationStructureMemoryRequirementsNV = 420, + vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = 421, + vkGetAndroidHardwareBufferPropertiesANDROID = 422, + vkGetBufferCollectionPropertiesFUCHSIA = 423, + vkGetBufferDeviceAddress = 424, + vkGetBufferDeviceAddressEXT = 425, + vkGetBufferDeviceAddressKHR = 426, + vkGetBufferMemoryRequirements = 427, + vkGetBufferMemoryRequirements2 = 428, + vkGetBufferMemoryRequirements2KHR = 429, + vkGetBufferOpaqueCaptureAddress = 430, + vkGetBufferOpaqueCaptureAddressKHR = 431, + vkGetBufferOpaqueCaptureDescriptorDataEXT = 432, + vkGetCalibratedTimestampsEXT = 433, + vkGetCalibratedTimestampsKHR = 434, + vkGetCudaModuleCacheNV = 435, + vkGetDeferredOperationMaxConcurrencyKHR = 436, + vkGetDeferredOperationResultKHR = 437, + vkGetDescriptorEXT = 438, + vkGetDescriptorSetHostMappingVALVE = 439, + vkGetDescriptorSetLayoutBindingOffsetEXT = 440, + vkGetDescriptorSetLayoutHostMappingInfoVALVE = 441, + vkGetDescriptorSetLayoutSizeEXT = 442, + vkGetDescriptorSetLayoutSupport = 443, + vkGetDescriptorSetLayoutSupportKHR = 444, + vkGetDeviceAccelerationStructureCompatibilityKHR = 445, + vkGetDeviceBufferMemoryRequirements = 446, + vkGetDeviceBufferMemoryRequirementsKHR = 447, + vkGetDeviceFaultInfoEXT = 448, + vkGetDeviceGroupPeerMemoryFeatures = 449, + vkGetDeviceGroupPeerMemoryFeaturesKHR = 450, + vkGetDeviceGroupPresentCapabilitiesKHR = 451, + vkGetDeviceGroupSurfacePresentModes2EXT = 452, + vkGetDeviceGroupSurfacePresentModesKHR = 453, + vkGetDeviceImageMemoryRequirements = 454, + vkGetDeviceImageMemoryRequirementsKHR = 455, + vkGetDeviceImageSparseMemoryRequirements = 456, + vkGetDeviceImageSparseMemoryRequirementsKHR = 457, + vkGetDeviceImageSubresourceLayoutKHR = 458, + vkGetDeviceMemoryCommitment = 459, + vkGetDeviceMemoryOpaqueCaptureAddress = 460, + vkGetDeviceMemoryOpaqueCaptureAddressKHR = 461, + vkGetDeviceMicromapCompatibilityEXT = 462, + vkGetDeviceProcAddr = 463, + vkGetDeviceQueue = 464, + vkGetDeviceQueue2 = 465, + vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 466, + vkGetDisplayModeProperties2KHR = 467, + vkGetDisplayModePropertiesKHR = 468, + vkGetDisplayPlaneCapabilities2KHR = 469, + vkGetDisplayPlaneCapabilitiesKHR = 470, + vkGetDisplayPlaneSupportedDisplaysKHR = 471, + vkGetDrmDisplayEXT = 472, + vkGetDynamicRenderingTilePropertiesQCOM = 473, + vkGetEncodedVideoSessionParametersKHR = 474, + vkGetEventStatus = 475, + vkGetExecutionGraphPipelineNodeIndexAMDX = 476, + vkGetExecutionGraphPipelineScratchSizeAMDX = 477, + vkGetFenceFdKHR = 478, + vkGetFenceStatus = 479, + vkGetFenceWin32HandleKHR = 480, + vkGetFramebufferTilePropertiesQCOM = 481, + vkGetGeneratedCommandsMemoryRequirementsNV = 482, + vkGetImageDrmFormatModifierPropertiesEXT = 483, + vkGetImageMemoryRequirements = 484, + vkGetImageMemoryRequirements2 = 485, + vkGetImageMemoryRequirements2KHR = 486, + vkGetImageOpaqueCaptureDescriptorDataEXT = 487, + vkGetImageSparseMemoryRequirements = 488, + vkGetImageSparseMemoryRequirements2 = 489, + vkGetImageSparseMemoryRequirements2KHR = 490, + vkGetImageSubresourceLayout = 491, + vkGetImageSubresourceLayout2EXT = 492, + vkGetImageSubresourceLayout2KHR = 493, + vkGetImageViewAddressNVX = 494, + vkGetImageViewHandleNVX = 495, + vkGetImageViewOpaqueCaptureDescriptorDataEXT = 496, + vkGetInstanceProcAddr = 497, + vkGetLatencyTimingsNV = 498, + vkGetMemoryAndroidHardwareBufferANDROID = 499, + vkGetMemoryFdKHR = 500, + vkGetMemoryFdPropertiesKHR = 501, + vkGetMemoryHostPointerPropertiesEXT = 502, + vkGetMemoryRemoteAddressNV = 503, + vkGetMemoryWin32HandleKHR = 504, + vkGetMemoryWin32HandleNV = 505, + vkGetMemoryWin32HandlePropertiesKHR = 506, + vkGetMemoryZirconHandleFUCHSIA = 507, + vkGetMemoryZirconHandlePropertiesFUCHSIA = 508, + vkGetMicromapBuildSizesEXT = 509, + vkGetPastPresentationTimingGOOGLE = 510, + vkGetPerformanceParameterINTEL = 511, + vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 512, + vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 513, + vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = 514, + vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 515, + vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 516, + vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 517, + vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 518, + vkGetPhysicalDeviceDisplayProperties2KHR = 519, + vkGetPhysicalDeviceDisplayPropertiesKHR = 520, + vkGetPhysicalDeviceExternalBufferProperties = 521, + vkGetPhysicalDeviceExternalBufferPropertiesKHR = 522, + vkGetPhysicalDeviceExternalFenceProperties = 523, + vkGetPhysicalDeviceExternalFencePropertiesKHR = 524, + vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 525, + vkGetPhysicalDeviceExternalSemaphoreProperties = 526, + vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 527, + vkGetPhysicalDeviceFeatures = 528, + vkGetPhysicalDeviceFeatures2 = 529, + vkGetPhysicalDeviceFeatures2KHR = 530, + vkGetPhysicalDeviceFormatProperties = 531, + vkGetPhysicalDeviceFormatProperties2 = 532, + vkGetPhysicalDeviceFormatProperties2KHR = 533, + vkGetPhysicalDeviceFragmentShadingRatesKHR = 534, + vkGetPhysicalDeviceImageFormatProperties = 535, + vkGetPhysicalDeviceImageFormatProperties2 = 536, + vkGetPhysicalDeviceImageFormatProperties2KHR = 537, + vkGetPhysicalDeviceMemoryProperties = 538, + vkGetPhysicalDeviceMemoryProperties2 = 539, + vkGetPhysicalDeviceMemoryProperties2KHR = 540, + vkGetPhysicalDeviceMultisamplePropertiesEXT = 541, + vkGetPhysicalDeviceOpticalFlowImageFormatsNV = 542, + vkGetPhysicalDevicePresentRectanglesKHR = 543, + vkGetPhysicalDeviceProperties = 544, + vkGetPhysicalDeviceProperties2 = 545, + vkGetPhysicalDeviceProperties2KHR = 546, + vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 547, + vkGetPhysicalDeviceQueueFamilyProperties = 548, + vkGetPhysicalDeviceQueueFamilyProperties2 = 549, + vkGetPhysicalDeviceQueueFamilyProperties2KHR = 550, + vkGetPhysicalDeviceScreenPresentationSupportQNX = 551, + vkGetPhysicalDeviceSparseImageFormatProperties = 552, + vkGetPhysicalDeviceSparseImageFormatProperties2 = 553, + vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 554, + vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 555, + vkGetPhysicalDeviceSurfaceCapabilities2EXT = 556, + vkGetPhysicalDeviceSurfaceCapabilities2KHR = 557, + vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 558, + vkGetPhysicalDeviceSurfaceFormats2KHR = 559, + vkGetPhysicalDeviceSurfaceFormatsKHR = 560, + vkGetPhysicalDeviceSurfacePresentModes2EXT = 561, + vkGetPhysicalDeviceSurfacePresentModesKHR = 562, + vkGetPhysicalDeviceSurfaceSupportKHR = 563, + vkGetPhysicalDeviceToolProperties = 564, + vkGetPhysicalDeviceToolPropertiesEXT = 565, + vkGetPhysicalDeviceVideoCapabilitiesKHR = 566, + vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = 567, + vkGetPhysicalDeviceVideoFormatPropertiesKHR = 568, + vkGetPhysicalDeviceWaylandPresentationSupportKHR = 569, + vkGetPhysicalDeviceWin32PresentationSupportKHR = 570, + vkGetPhysicalDeviceXcbPresentationSupportKHR = 571, + vkGetPhysicalDeviceXlibPresentationSupportKHR = 572, + vkGetPipelineCacheData = 573, + vkGetPipelineExecutableInternalRepresentationsKHR = 574, + vkGetPipelineExecutablePropertiesKHR = 575, + vkGetPipelineExecutableStatisticsKHR = 576, + vkGetPipelineIndirectDeviceAddressNV = 577, + vkGetPipelineIndirectMemoryRequirementsNV = 578, + vkGetPipelinePropertiesEXT = 579, + vkGetPrivateData = 580, + vkGetPrivateDataEXT = 581, + vkGetQueryPoolResults = 582, + vkGetQueueCheckpointData2NV = 583, + vkGetQueueCheckpointDataNV = 584, + vkGetRandROutputDisplayEXT = 585, + vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 586, + vkGetRayTracingShaderGroupHandlesKHR = 587, + vkGetRayTracingShaderGroupHandlesNV = 588, + vkGetRayTracingShaderGroupStackSizeKHR = 589, + vkGetRefreshCycleDurationGOOGLE = 590, + vkGetRenderAreaGranularity = 591, + vkGetRenderingAreaGranularityKHR = 592, + vkGetSamplerOpaqueCaptureDescriptorDataEXT = 593, + vkGetScreenBufferPropertiesQNX = 594, + vkGetSemaphoreCounterValue = 595, + vkGetSemaphoreCounterValueKHR = 596, + vkGetSemaphoreFdKHR = 597, + vkGetSemaphoreWin32HandleKHR = 598, + vkGetSemaphoreZirconHandleFUCHSIA = 599, + vkGetShaderBinaryDataEXT = 600, + vkGetShaderInfoAMD = 601, + vkGetShaderModuleCreateInfoIdentifierEXT = 602, + vkGetShaderModuleIdentifierEXT = 603, + vkGetSwapchainCounterEXT = 604, + vkGetSwapchainImagesKHR = 605, + vkGetSwapchainStatusKHR = 606, + vkGetValidationCacheDataEXT = 607, + vkGetVideoSessionMemoryRequirementsKHR = 608, + vkGetWinrtDisplayNV = 609, + vkImportFenceFdKHR = 610, + vkImportFenceWin32HandleKHR = 611, + vkImportSemaphoreFdKHR = 612, + vkImportSemaphoreWin32HandleKHR = 613, + vkImportSemaphoreZirconHandleFUCHSIA = 614, + vkInitializePerformanceApiINTEL = 615, + vkInvalidateMappedMemoryRanges = 616, + vkLatencySleepNV = 617, + vkMapMemory = 618, + vkMapMemory2KHR = 619, + vkMergePipelineCaches = 620, + vkMergeValidationCachesEXT = 621, + vkQueueBeginDebugUtilsLabelEXT = 622, + vkQueueBindSparse = 623, + vkQueueEndDebugUtilsLabelEXT = 624, + vkQueueInsertDebugUtilsLabelEXT = 625, + vkQueueNotifyOutOfBandNV = 626, + vkQueuePresentKHR = 627, + vkQueueSetPerformanceConfigurationINTEL = 628, + vkQueueSubmit = 629, + vkQueueSubmit2 = 630, + vkQueueSubmit2KHR = 631, + vkQueueWaitIdle = 632, + vkRegisterDeviceEventEXT = 633, + vkRegisterDisplayEventEXT = 634, + vkReleaseDisplayEXT = 635, + vkReleaseFullScreenExclusiveModeEXT = 636, + vkReleasePerformanceConfigurationINTEL = 637, + vkReleaseProfilingLockKHR = 638, + vkReleaseSwapchainImagesEXT = 639, + vkResetCommandBuffer = 640, + vkResetCommandPool = 641, + vkResetDescriptorPool = 642, + vkResetEvent = 643, + vkResetFences = 644, + vkResetQueryPool = 645, + vkResetQueryPoolEXT = 646, + vkSetBufferCollectionBufferConstraintsFUCHSIA = 647, + vkSetBufferCollectionImageConstraintsFUCHSIA = 648, + vkSetDebugUtilsObjectNameEXT = 649, + vkSetDebugUtilsObjectTagEXT = 650, + vkSetDeviceMemoryPriorityEXT = 651, + vkSetEvent = 652, + vkSetHdrMetadataEXT = 653, + vkSetLatencyMarkerNV = 654, + vkSetLatencySleepModeNV = 655, + vkSetLocalDimmingAMD = 656, + vkSetPrivateData = 657, + vkSetPrivateDataEXT = 658, + vkSignalSemaphore = 659, + vkSignalSemaphoreKHR = 660, + vkSubmitDebugUtilsMessageEXT = 661, + vkTransitionImageLayoutEXT = 662, + vkTrimCommandPool = 663, + vkTrimCommandPoolKHR = 664, + vkUninitializePerformanceApiINTEL = 665, + vkUnmapMemory = 666, + vkUnmapMemory2KHR = 667, + vkUpdateDescriptorSetWithTemplate = 668, + vkUpdateDescriptorSetWithTemplateKHR = 669, + vkUpdateDescriptorSets = 670, + vkUpdateVideoSessionParametersKHR = 671, + vkWaitForFences = 672, + vkWaitForPresentKHR = 673, + vkWaitSemaphores = 674, + vkWaitSemaphoresKHR = 675, + vkWriteAccelerationStructuresPropertiesKHR = 676, + vkWriteMicromapsPropertiesEXT = 677, }; enum class Struct { @@ -752,11 +758,14 @@ enum class Struct { VkBindAccelerationStructureMemoryInfoNV, VkBindBufferMemoryDeviceGroupInfo, VkBindBufferMemoryInfo, + VkBindDescriptorBufferEmbeddedSamplersInfoEXT, + VkBindDescriptorSetsInfoKHR, VkBindImageMemoryDeviceGroupInfo, VkBindImageMemoryInfo, VkBindImageMemorySwapchainInfoKHR, VkBindImagePlaneMemoryInfo, VkBindIndexBufferIndirectCommandNV, + VkBindMemoryStatusKHR, VkBindPipelineIndirectCommandNV, VkBindShaderGroupIndirectCommandNV, VkBindSparseInfo, @@ -1265,6 +1274,8 @@ enum class Struct { VkPhysicalDeviceMaintenance4Properties, VkPhysicalDeviceMaintenance5FeaturesKHR, VkPhysicalDeviceMaintenance5PropertiesKHR, + VkPhysicalDeviceMaintenance6FeaturesKHR, + VkPhysicalDeviceMaintenance6PropertiesKHR, VkPhysicalDeviceMemoryBudgetPropertiesEXT, VkPhysicalDeviceMemoryDecompressionFeaturesNV, VkPhysicalDeviceMemoryDecompressionPropertiesNV, @@ -1293,6 +1304,7 @@ enum class Struct { VkPhysicalDeviceOpticalFlowPropertiesNV, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, + VkPhysicalDevicePerStageDescriptorSetFeaturesNV, VkPhysicalDevicePerformanceQueryFeaturesKHR, VkPhysicalDevicePerformanceQueryPropertiesKHR, VkPhysicalDevicePipelineCreationCacheControlFeatures, @@ -1403,6 +1415,7 @@ enum class Struct { VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT, VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR, VkPhysicalDeviceVideoFormatInfoKHR, + VkPhysicalDeviceVideoMaintenance1FeaturesKHR, VkPhysicalDeviceVulkan11Features, VkPhysicalDeviceVulkan11Properties, VkPhysicalDeviceVulkan12Features, @@ -1481,6 +1494,9 @@ enum class Struct { VkPrivateDataSlotCreateInfo, VkProtectedSubmitInfo, VkPushConstantRange, + VkPushConstantsInfoKHR, + VkPushDescriptorSetInfoKHR, + VkPushDescriptorSetWithTemplateInfoKHR, VkQueryLowLatencySupportNV, VkQueryPoolCreateInfo, VkQueryPoolPerformanceCreateInfoKHR, @@ -1550,6 +1566,7 @@ enum class Struct { VkSemaphoreSubmitInfo, VkSemaphoreTypeCreateInfo, VkSemaphoreWaitInfo, + VkSetDescriptorBufferOffsetsInfoEXT, VkSetLatencyMarkerInfoNV, VkSetStateFlagsIndirectCommandNV, VkShaderCreateInfoEXT, @@ -1647,38 +1664,38 @@ enum class Struct { VkVideoDecodeInfoKHR, VkVideoDecodeUsageInfoKHR, VkVideoEncodeCapabilitiesKHR, - VkVideoEncodeH264CapabilitiesEXT, - VkVideoEncodeH264DpbSlotInfoEXT, - VkVideoEncodeH264FrameSizeEXT, - VkVideoEncodeH264GopRemainingFrameInfoEXT, - VkVideoEncodeH264NaluSliceInfoEXT, - VkVideoEncodeH264PictureInfoEXT, - VkVideoEncodeH264ProfileInfoEXT, - VkVideoEncodeH264QpEXT, - VkVideoEncodeH264QualityLevelPropertiesEXT, - VkVideoEncodeH264RateControlInfoEXT, - VkVideoEncodeH264RateControlLayerInfoEXT, - VkVideoEncodeH264SessionCreateInfoEXT, - VkVideoEncodeH264SessionParametersAddInfoEXT, - VkVideoEncodeH264SessionParametersCreateInfoEXT, - VkVideoEncodeH264SessionParametersFeedbackInfoEXT, - VkVideoEncodeH264SessionParametersGetInfoEXT, - VkVideoEncodeH265CapabilitiesEXT, - VkVideoEncodeH265DpbSlotInfoEXT, - VkVideoEncodeH265FrameSizeEXT, - VkVideoEncodeH265GopRemainingFrameInfoEXT, - VkVideoEncodeH265NaluSliceSegmentInfoEXT, - VkVideoEncodeH265PictureInfoEXT, - VkVideoEncodeH265ProfileInfoEXT, - VkVideoEncodeH265QpEXT, - VkVideoEncodeH265QualityLevelPropertiesEXT, - VkVideoEncodeH265RateControlInfoEXT, - VkVideoEncodeH265RateControlLayerInfoEXT, - VkVideoEncodeH265SessionCreateInfoEXT, - VkVideoEncodeH265SessionParametersAddInfoEXT, - VkVideoEncodeH265SessionParametersCreateInfoEXT, - VkVideoEncodeH265SessionParametersFeedbackInfoEXT, - VkVideoEncodeH265SessionParametersGetInfoEXT, + VkVideoEncodeH264CapabilitiesKHR, + VkVideoEncodeH264DpbSlotInfoKHR, + VkVideoEncodeH264FrameSizeKHR, + VkVideoEncodeH264GopRemainingFrameInfoKHR, + VkVideoEncodeH264NaluSliceInfoKHR, + VkVideoEncodeH264PictureInfoKHR, + VkVideoEncodeH264ProfileInfoKHR, + VkVideoEncodeH264QpKHR, + VkVideoEncodeH264QualityLevelPropertiesKHR, + VkVideoEncodeH264RateControlInfoKHR, + VkVideoEncodeH264RateControlLayerInfoKHR, + VkVideoEncodeH264SessionCreateInfoKHR, + VkVideoEncodeH264SessionParametersAddInfoKHR, + VkVideoEncodeH264SessionParametersCreateInfoKHR, + VkVideoEncodeH264SessionParametersFeedbackInfoKHR, + VkVideoEncodeH264SessionParametersGetInfoKHR, + VkVideoEncodeH265CapabilitiesKHR, + VkVideoEncodeH265DpbSlotInfoKHR, + VkVideoEncodeH265FrameSizeKHR, + VkVideoEncodeH265GopRemainingFrameInfoKHR, + VkVideoEncodeH265NaluSliceSegmentInfoKHR, + VkVideoEncodeH265PictureInfoKHR, + VkVideoEncodeH265ProfileInfoKHR, + VkVideoEncodeH265QpKHR, + VkVideoEncodeH265QualityLevelPropertiesKHR, + VkVideoEncodeH265RateControlInfoKHR, + VkVideoEncodeH265RateControlLayerInfoKHR, + VkVideoEncodeH265SessionCreateInfoKHR, + VkVideoEncodeH265SessionParametersAddInfoKHR, + VkVideoEncodeH265SessionParametersCreateInfoKHR, + VkVideoEncodeH265SessionParametersFeedbackInfoKHR, + VkVideoEncodeH265SessionParametersGetInfoKHR, VkVideoEncodeInfoKHR, VkVideoEncodeQualityLevelInfoKHR, VkVideoEncodeQualityLevelPropertiesKHR, @@ -1689,6 +1706,7 @@ enum class Struct { VkVideoEncodeUsageInfoKHR, VkVideoEndCodingInfoKHR, VkVideoFormatPropertiesKHR, + VkVideoInlineQueryInfoKHR, VkVideoPictureResourceInfoKHR, VkVideoProfileInfoKHR, VkVideoProfileListInfoKHR, @@ -1813,6 +1831,7 @@ enum class Field { blockDimX, blockDimY, blockDimZ, + blockTexelViewCompatibleMultipleLayers, borderColor, borderColorSwizzle, borderColorSwizzleFromImage, @@ -2145,6 +2164,7 @@ enum class Field { duration, dwAccess, dynamicOffsetCount, + dynamicPipelineLayout, dynamicPrimitiveTopologyUnrestricted, dynamicRendering, dynamicRenderingUnusedAttachments, @@ -2287,6 +2307,7 @@ enum class Field { fragmentShaderPixelInterlock, fragmentShaderSampleInterlock, fragmentShaderShadingRateInterlock, + fragmentShadingRateClampCombinerInputs, fragmentShadingRateEnums, fragmentShadingRateNonTrivialCombinerOps, fragmentShadingRateStrictMultiplyCombiner, @@ -2551,6 +2572,7 @@ enum class Field { magFilter, maintenance4, maintenance5, + maintenance6, major, mapEntryCount, marker, @@ -2572,6 +2594,7 @@ enum class Field { maxCodedExtent, maxColorAttachments, maxCombinedClipAndCullDistances, + maxCombinedImageSamplerDescriptorCount, maxCommandBufferNestingLevel, maxComputeSharedMemorySize, maxComputeWorkGroupCount, @@ -2994,6 +3017,8 @@ enum class Field { pAttachments, pAttributes, pBeginInfo, + pBindDescriptorBufferEmbeddedSamplersInfo, + pBindDescriptorSetsInfo, pBindInfo, pBindInfos, pBindSessionMemoryInfos, @@ -3297,6 +3322,9 @@ enum class Field { pPropertiesCount, pPropertyCount, pPushConstantRanges, + pPushConstantsInfo, + pPushDescriptorSetInfo, + pPushDescriptorSetWithTemplateInfo, pQualityLevelInfo, pQualityLevelProperties, pQueriedLowLatencyData, @@ -3328,6 +3356,7 @@ enum class Field { pRenderingInfo, pResolveAttachments, pResolveImageInfo, + pResult, pResults, pSampleLocations, pSampleLocationsInfo, @@ -3338,6 +3367,7 @@ enum class Field { pSemaphore, pSemaphores, pSession, + pSetDescriptorBufferOffsetsInfo, pSetLayout, pSetLayouts, pSettingName, @@ -3471,6 +3501,7 @@ enum class Field { pciDevice, pciDomain, pciFunction, + perStageDescriptorSet, perViewAttributes, perViewAttributesPositionXOnly, perViewPositionAllComponents, @@ -4225,6 +4256,7 @@ enum class Field { videoCodecOperation, videoCodecOperations, videoContentHints, + videoMaintenance1, videoSession, videoSessionParameters, videoSessionParametersTemplate, diff --git a/layers/vulkan/generated/feature_requirements_helper.cpp b/layers/vulkan/generated/feature_requirements_helper.cpp index 9cd76921dca..f048cf52081 100644 --- a/layers/vulkan/generated/feature_requirements_helper.cpp +++ b/layers/vulkan/generated/feature_requirements_helper.cpp @@ -3141,6 +3141,20 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i } return {&vk_struct->maintenance5, "VkPhysicalDeviceMaintenance5FeaturesKHR::maintenance5"}; } + case Feature::maintenance6: { + auto vk_struct = const_cast( + vku::FindStructInPNextChain(*inout_pnext_chain)); + if (!vk_struct) { + vk_struct = new VkPhysicalDeviceMaintenance6FeaturesKHR; + *vk_struct = vku::InitStructHelper(); + if (*inout_pnext_chain) { + vvl::PnextChainAdd(*inout_pnext_chain, vk_struct); + } else { + *inout_pnext_chain = vk_struct; + } + } + return {&vk_struct->maintenance6, "VkPhysicalDeviceMaintenance6FeaturesKHR::maintenance6"}; + } case Feature::memoryDecompression: { auto vk_struct = const_cast( vku::FindStructInPNextChain(*inout_pnext_chain)); @@ -3527,6 +3541,34 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i return {&vk_struct->pageableDeviceLocalMemory, "VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::pageableDeviceLocalMemory"}; } + case Feature::dynamicPipelineLayout: { + auto vk_struct = const_cast( + vku::FindStructInPNextChain(*inout_pnext_chain)); + if (!vk_struct) { + vk_struct = new VkPhysicalDevicePerStageDescriptorSetFeaturesNV; + *vk_struct = vku::InitStructHelper(); + if (*inout_pnext_chain) { + vvl::PnextChainAdd(*inout_pnext_chain, vk_struct); + } else { + *inout_pnext_chain = vk_struct; + } + } + return {&vk_struct->dynamicPipelineLayout, "VkPhysicalDevicePerStageDescriptorSetFeaturesNV::dynamicPipelineLayout"}; + } + case Feature::perStageDescriptorSet: { + auto vk_struct = const_cast( + vku::FindStructInPNextChain(*inout_pnext_chain)); + if (!vk_struct) { + vk_struct = new VkPhysicalDevicePerStageDescriptorSetFeaturesNV; + *vk_struct = vku::InitStructHelper(); + if (*inout_pnext_chain) { + vvl::PnextChainAdd(*inout_pnext_chain, vk_struct); + } else { + *inout_pnext_chain = vk_struct; + } + } + return {&vk_struct->perStageDescriptorSet, "VkPhysicalDevicePerStageDescriptorSetFeaturesNV::perStageDescriptorSet"}; + } case Feature::performanceCounterMultipleQueryPools: { auto vk_struct = const_cast( vku::FindStructInPNextChain(*inout_pnext_chain)); @@ -5799,6 +5841,20 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i return {&vk_struct->vertexInputDynamicState, "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::vertexInputDynamicState"}; } + case Feature::videoMaintenance1: { + auto vk_struct = const_cast( + vku::FindStructInPNextChain(*inout_pnext_chain)); + if (!vk_struct) { + vk_struct = new VkPhysicalDeviceVideoMaintenance1FeaturesKHR; + *vk_struct = vku::InitStructHelper(); + if (*inout_pnext_chain) { + vvl::PnextChainAdd(*inout_pnext_chain, vk_struct); + } else { + *inout_pnext_chain = vk_struct; + } + } + return {&vk_struct->videoMaintenance1, "VkPhysicalDeviceVideoMaintenance1FeaturesKHR::videoMaintenance1"}; + } case Feature::descriptorIndexing: { auto vk_struct = const_cast( vku::FindStructInPNextChain(*inout_pnext_chain)); diff --git a/layers/vulkan/generated/feature_requirements_helper.h b/layers/vulkan/generated/feature_requirements_helper.h index bdb1961b49a..4d77c8dfe0c 100644 --- a/layers/vulkan/generated/feature_requirements_helper.h +++ b/layers/vulkan/generated/feature_requirements_helper.h @@ -488,6 +488,8 @@ enum class Feature { maintenance4, // VkPhysicalDeviceMaintenance5FeaturesKHR maintenance5, + // VkPhysicalDeviceMaintenance6FeaturesKHR + maintenance6, // VkPhysicalDeviceMemoryDecompressionFeaturesNV memoryDecompression, // VkPhysicalDeviceMemoryPriorityFeaturesEXT @@ -536,6 +538,10 @@ enum class Feature { opticalFlow, // VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT pageableDeviceLocalMemory, + // VkPhysicalDevicePerStageDescriptorSetFeaturesNV + dynamicPipelineLayout, + // VkPhysicalDevicePerStageDescriptorSetFeaturesNV + perStageDescriptorSet, // VkPhysicalDevicePerformanceQueryFeaturesKHR performanceCounterMultipleQueryPools, // VkPhysicalDevicePerformanceQueryFeaturesKHR @@ -796,6 +802,8 @@ enum class Feature { vertexAttributeInstanceRateZeroDivisor, // VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT vertexInputDynamicState, + // VkPhysicalDeviceVideoMaintenance1FeaturesKHR + videoMaintenance1, // VkPhysicalDeviceVulkan12Features descriptorIndexing, // VkPhysicalDeviceVulkan12Features diff --git a/layers/vulkan/generated/layer_chassis_dispatch.cpp b/layers/vulkan/generated/layer_chassis_dispatch.cpp index 26f3892d9d1..b5c2fa4ae2a 100644 --- a/layers/vulkan/generated/layer_chassis_dispatch.cpp +++ b/layers/vulkan/generated/layer_chassis_dispatch.cpp @@ -263,6 +263,21 @@ void WrapPnextChainHandles(ValidationObject* layer_data, const void* pNext) { } } } break; + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: { + safe_VkVideoInlineQueryInfoKHR* safe_struct = reinterpret_cast(cur_pnext); + + if (safe_struct->queryPool) { + safe_struct->queryPool = layer_data->Unwrap(safe_struct->queryPool); + } + } break; + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: { + safe_VkPipelineLayoutCreateInfo* safe_struct = reinterpret_cast(cur_pnext); + if (safe_struct->pSetLayouts) { + for (uint32_t index0 = 0; index0 < safe_struct->setLayoutCount; ++index0) { + safe_struct->pSetLayouts[index0] = layer_data->Unwrap(safe_struct->pSetLayouts[index0]); + } + } + } break; #ifdef VK_USE_PLATFORM_METAL_EXT case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: { safe_VkExportMetalBufferInfoEXT* safe_struct = reinterpret_cast(cur_pnext); @@ -3488,6 +3503,7 @@ void DispatchCmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecod } } } + WrapPnextChainHandles(layer_data, local_pDecodeInfo->pNext); } } layer_data->device_dispatch_table.CmdDecodeVideoKHR(commandBuffer, (const VkVideoDecodeInfoKHR*)local_pDecodeInfo); @@ -4606,7 +4622,6 @@ VkResult DispatchUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKHR* pM return result; } -#ifdef VK_ENABLE_BETA_EXTENSIONS VkResult DispatchGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, @@ -4682,11 +4697,11 @@ void DispatchCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncod } } } + WrapPnextChainHandles(layer_data, local_pEncodeInfo->pNext); } } layer_data->device_dispatch_table.CmdEncodeVideoKHR(commandBuffer, (const VkVideoEncodeInfoKHR*)local_pEncodeInfo); } -#endif // VK_ENABLE_BETA_EXTENSIONS void DispatchCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); @@ -5086,6 +5101,184 @@ VkResult DispatchGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampC return result; } +void DispatchCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + if (!wrap_handles) return layer_data->device_dispatch_table.CmdBindDescriptorSets2KHR(commandBuffer, pBindDescriptorSetsInfo); + safe_VkBindDescriptorSetsInfoKHR var_local_pBindDescriptorSetsInfo; + safe_VkBindDescriptorSetsInfoKHR* local_pBindDescriptorSetsInfo = nullptr; + { + if (pBindDescriptorSetsInfo) { + local_pBindDescriptorSetsInfo = &var_local_pBindDescriptorSetsInfo; + local_pBindDescriptorSetsInfo->initialize(pBindDescriptorSetsInfo); + + if (pBindDescriptorSetsInfo->layout) { + local_pBindDescriptorSetsInfo->layout = layer_data->Unwrap(pBindDescriptorSetsInfo->layout); + } + if (local_pBindDescriptorSetsInfo->pDescriptorSets) { + for (uint32_t index1 = 0; index1 < local_pBindDescriptorSetsInfo->descriptorSetCount; ++index1) { + local_pBindDescriptorSetsInfo->pDescriptorSets[index1] = + layer_data->Unwrap(local_pBindDescriptorSetsInfo->pDescriptorSets[index1]); + } + } + WrapPnextChainHandles(layer_data, local_pBindDescriptorSetsInfo->pNext); + } + } + layer_data->device_dispatch_table.CmdBindDescriptorSets2KHR(commandBuffer, + (const VkBindDescriptorSetsInfoKHR*)local_pBindDescriptorSetsInfo); +} + +void DispatchCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR* pPushConstantsInfo) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + if (!wrap_handles) return layer_data->device_dispatch_table.CmdPushConstants2KHR(commandBuffer, pPushConstantsInfo); + safe_VkPushConstantsInfoKHR var_local_pPushConstantsInfo; + safe_VkPushConstantsInfoKHR* local_pPushConstantsInfo = nullptr; + { + if (pPushConstantsInfo) { + local_pPushConstantsInfo = &var_local_pPushConstantsInfo; + local_pPushConstantsInfo->initialize(pPushConstantsInfo); + + if (pPushConstantsInfo->layout) { + local_pPushConstantsInfo->layout = layer_data->Unwrap(pPushConstantsInfo->layout); + } + WrapPnextChainHandles(layer_data, local_pPushConstantsInfo->pNext); + } + } + layer_data->device_dispatch_table.CmdPushConstants2KHR(commandBuffer, (const VkPushConstantsInfoKHR*)local_pPushConstantsInfo); +} + +void DispatchCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + if (!wrap_handles) return layer_data->device_dispatch_table.CmdPushDescriptorSet2KHR(commandBuffer, pPushDescriptorSetInfo); + safe_VkPushDescriptorSetInfoKHR var_local_pPushDescriptorSetInfo; + safe_VkPushDescriptorSetInfoKHR* local_pPushDescriptorSetInfo = nullptr; + { + if (pPushDescriptorSetInfo) { + local_pPushDescriptorSetInfo = &var_local_pPushDescriptorSetInfo; + local_pPushDescriptorSetInfo->initialize(pPushDescriptorSetInfo); + + if (pPushDescriptorSetInfo->layout) { + local_pPushDescriptorSetInfo->layout = layer_data->Unwrap(pPushDescriptorSetInfo->layout); + } + if (local_pPushDescriptorSetInfo->pDescriptorWrites) { + for (uint32_t index1 = 0; index1 < local_pPushDescriptorSetInfo->descriptorWriteCount; ++index1) { + if (pPushDescriptorSetInfo->pDescriptorWrites[index1].dstSet) { + local_pPushDescriptorSetInfo->pDescriptorWrites[index1].dstSet = + layer_data->Unwrap(pPushDescriptorSetInfo->pDescriptorWrites[index1].dstSet); + } + if (local_pPushDescriptorSetInfo->pDescriptorWrites[index1].pImageInfo) { + for (uint32_t index2 = 0; index2 < local_pPushDescriptorSetInfo->pDescriptorWrites[index1].descriptorCount; + ++index2) { + if (pPushDescriptorSetInfo->pDescriptorWrites[index1].pImageInfo[index2].sampler) { + local_pPushDescriptorSetInfo->pDescriptorWrites[index1].pImageInfo[index2].sampler = + layer_data->Unwrap( + pPushDescriptorSetInfo->pDescriptorWrites[index1].pImageInfo[index2].sampler); + } + if (pPushDescriptorSetInfo->pDescriptorWrites[index1].pImageInfo[index2].imageView) { + local_pPushDescriptorSetInfo->pDescriptorWrites[index1].pImageInfo[index2].imageView = + layer_data->Unwrap( + pPushDescriptorSetInfo->pDescriptorWrites[index1].pImageInfo[index2].imageView); + } + } + } + if (local_pPushDescriptorSetInfo->pDescriptorWrites[index1].pBufferInfo) { + for (uint32_t index2 = 0; index2 < local_pPushDescriptorSetInfo->pDescriptorWrites[index1].descriptorCount; + ++index2) { + if (pPushDescriptorSetInfo->pDescriptorWrites[index1].pBufferInfo[index2].buffer) { + local_pPushDescriptorSetInfo->pDescriptorWrites[index1].pBufferInfo[index2].buffer = + layer_data->Unwrap( + pPushDescriptorSetInfo->pDescriptorWrites[index1].pBufferInfo[index2].buffer); + } + } + } + if (local_pPushDescriptorSetInfo->pDescriptorWrites[index1].pTexelBufferView) { + for (uint32_t index2 = 0; index2 < local_pPushDescriptorSetInfo->pDescriptorWrites[index1].descriptorCount; + ++index2) { + local_pPushDescriptorSetInfo->pDescriptorWrites[index1].pTexelBufferView[index2] = layer_data->Unwrap( + local_pPushDescriptorSetInfo->pDescriptorWrites[index1].pTexelBufferView[index2]); + } + } + } + } + WrapPnextChainHandles(layer_data, local_pPushDescriptorSetInfo->pNext); + } + } + layer_data->device_dispatch_table.CmdPushDescriptorSet2KHR(commandBuffer, + (const VkPushDescriptorSetInfoKHR*)local_pPushDescriptorSetInfo); +} + +void DispatchCmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + if (!wrap_handles) + return layer_data->device_dispatch_table.CmdPushDescriptorSetWithTemplate2KHR(commandBuffer, + pPushDescriptorSetWithTemplateInfo); + safe_VkPushDescriptorSetWithTemplateInfoKHR var_local_pPushDescriptorSetWithTemplateInfo; + safe_VkPushDescriptorSetWithTemplateInfoKHR* local_pPushDescriptorSetWithTemplateInfo = nullptr; + { + if (pPushDescriptorSetWithTemplateInfo) { + local_pPushDescriptorSetWithTemplateInfo = &var_local_pPushDescriptorSetWithTemplateInfo; + local_pPushDescriptorSetWithTemplateInfo->initialize(pPushDescriptorSetWithTemplateInfo); + + if (pPushDescriptorSetWithTemplateInfo->descriptorUpdateTemplate) { + local_pPushDescriptorSetWithTemplateInfo->descriptorUpdateTemplate = + layer_data->Unwrap(pPushDescriptorSetWithTemplateInfo->descriptorUpdateTemplate); + } + if (pPushDescriptorSetWithTemplateInfo->layout) { + local_pPushDescriptorSetWithTemplateInfo->layout = layer_data->Unwrap(pPushDescriptorSetWithTemplateInfo->layout); + } + WrapPnextChainHandles(layer_data, local_pPushDescriptorSetWithTemplateInfo->pNext); + } + } + layer_data->device_dispatch_table.CmdPushDescriptorSetWithTemplate2KHR( + commandBuffer, (const VkPushDescriptorSetWithTemplateInfoKHR*)local_pPushDescriptorSetWithTemplateInfo); +} + +void DispatchCmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, + const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + if (!wrap_handles) + return layer_data->device_dispatch_table.CmdSetDescriptorBufferOffsets2EXT(commandBuffer, pSetDescriptorBufferOffsetsInfo); + safe_VkSetDescriptorBufferOffsetsInfoEXT var_local_pSetDescriptorBufferOffsetsInfo; + safe_VkSetDescriptorBufferOffsetsInfoEXT* local_pSetDescriptorBufferOffsetsInfo = nullptr; + { + if (pSetDescriptorBufferOffsetsInfo) { + local_pSetDescriptorBufferOffsetsInfo = &var_local_pSetDescriptorBufferOffsetsInfo; + local_pSetDescriptorBufferOffsetsInfo->initialize(pSetDescriptorBufferOffsetsInfo); + + if (pSetDescriptorBufferOffsetsInfo->layout) { + local_pSetDescriptorBufferOffsetsInfo->layout = layer_data->Unwrap(pSetDescriptorBufferOffsetsInfo->layout); + } + WrapPnextChainHandles(layer_data, local_pSetDescriptorBufferOffsetsInfo->pNext); + } + } + layer_data->device_dispatch_table.CmdSetDescriptorBufferOffsets2EXT( + commandBuffer, (const VkSetDescriptorBufferOffsetsInfoEXT*)local_pSetDescriptorBufferOffsetsInfo); +} + +void DispatchCmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) { + auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + if (!wrap_handles) + return layer_data->device_dispatch_table.CmdBindDescriptorBufferEmbeddedSamplers2EXT( + commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo); + safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT var_local_pBindDescriptorBufferEmbeddedSamplersInfo; + safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT* local_pBindDescriptorBufferEmbeddedSamplersInfo = nullptr; + { + if (pBindDescriptorBufferEmbeddedSamplersInfo) { + local_pBindDescriptorBufferEmbeddedSamplersInfo = &var_local_pBindDescriptorBufferEmbeddedSamplersInfo; + local_pBindDescriptorBufferEmbeddedSamplersInfo->initialize(pBindDescriptorBufferEmbeddedSamplersInfo); + + if (pBindDescriptorBufferEmbeddedSamplersInfo->layout) { + local_pBindDescriptorBufferEmbeddedSamplersInfo->layout = + layer_data->Unwrap(pBindDescriptorBufferEmbeddedSamplersInfo->layout); + } + WrapPnextChainHandles(layer_data, local_pBindDescriptorBufferEmbeddedSamplersInfo->pNext); + } + } + layer_data->device_dispatch_table.CmdBindDescriptorBufferEmbeddedSamplers2EXT( + commandBuffer, (const VkBindDescriptorBufferEmbeddedSamplersInfoEXT*)local_pBindDescriptorBufferEmbeddedSamplersInfo); +} + VkResult DispatchCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); diff --git a/layers/vulkan/generated/layer_chassis_dispatch.h b/layers/vulkan/generated/layer_chassis_dispatch.h index 9d960cfcf92..9c7d4e96356 100644 --- a/layers/vulkan/generated/layer_chassis_dispatch.h +++ b/layers/vulkan/generated/layer_chassis_dispatch.h @@ -605,7 +605,6 @@ VkResult DispatchGetPipelineExecutableInternalRepresentationsKHR( VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); VkResult DispatchMapMemory2KHR(VkDevice device, const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData); VkResult DispatchUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo); -#ifdef VK_ENABLE_BETA_EXTENSIONS VkResult DispatchGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties); @@ -614,7 +613,6 @@ VkResult DispatchGetEncodedVideoSessionParametersKHR(VkDevice device, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData); void DispatchCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo); -#endif // VK_ENABLE_BETA_EXTENSIONS void DispatchCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); void DispatchCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); void DispatchCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, @@ -655,6 +653,15 @@ VkResult DispatchGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice p VkResult DispatchGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); +void DispatchCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo); +void DispatchCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR* pPushConstantsInfo); +void DispatchCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo); +void DispatchCmdPushDescriptorSetWithTemplate2KHR(VkCommandBuffer commandBuffer, + const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo); +void DispatchCmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, + const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo); +void DispatchCmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo); VkResult DispatchCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); void DispatchDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, diff --git a/layers/vulkan/generated/object_tracker.cpp b/layers/vulkan/generated/object_tracker.cpp index e80c1e50a90..3a7487fd0f0 100644 --- a/layers/vulkan/generated/object_tracker.cpp +++ b/layers/vulkan/generated/object_tracker.cpp @@ -1456,7 +1456,7 @@ bool ObjectLifetimes::PreCallValidateCmdBindIndexBuffer(VkCommandBuffer commandB bool skip = false; // Checked by chassis: commandBuffer: "VUID-vkCmdBindIndexBuffer-commandBuffer-parameter" // Checked by chassis: commandBuffer: "VUID-vkCmdBindIndexBuffer-commonparent" - skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdBindIndexBuffer-buffer-parameter", + skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, true, "VUID-vkCmdBindIndexBuffer-buffer-parameter", "VUID-vkCmdBindIndexBuffer-commonparent", error_obj.location.dot(Field::buffer)); return skip; @@ -3390,6 +3390,12 @@ bool ObjectLifetimes::PreCallValidateCmdDecodeVideoKHR(VkCommandBuffer commandBu } } } + if (auto pNext = vku::FindStructInPNextChain(pDecodeInfo->pNext)) { + const Location pNext_loc = pDecodeInfo_loc.pNext(Struct::VkVideoInlineQueryInfoKHR); + skip |= ValidateObject(pNext->queryPool, kVulkanObjectTypeQueryPool, true, + "VUID-VkVideoInlineQueryInfoKHR-queryPool-parameter", + "UNASSIGNED-VkVideoInlineQueryInfoKHR-queryPool-parent", pNext_loc.dot(Field::queryPool)); + } } return skip; @@ -4015,7 +4021,6 @@ bool ObjectLifetimes::PreCallValidateUnmapMemory2KHR(VkDevice device, const VkMe return skip; } -#ifdef VK_ENABLE_BETA_EXTENSIONS // vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR: // Checked by chassis: physicalDevice: "VUID-vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR-physicalDevice-parameter" @@ -4072,11 +4077,16 @@ bool ObjectLifetimes::PreCallValidateCmdEncodeVideoKHR(VkCommandBuffer commandBu } } } + if (auto pNext = vku::FindStructInPNextChain(pEncodeInfo->pNext)) { + const Location pNext_loc = pEncodeInfo_loc.pNext(Struct::VkVideoInlineQueryInfoKHR); + skip |= ValidateObject(pNext->queryPool, kVulkanObjectTypeQueryPool, true, + "VUID-VkVideoInlineQueryInfoKHR-queryPool-parameter", + "UNASSIGNED-VkVideoInlineQueryInfoKHR-queryPool-parent", pNext_loc.dot(Field::queryPool)); + } } return skip; } -#endif // VK_ENABLE_BETA_EXTENSIONS bool ObjectLifetimes::PreCallValidateCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo, const ErrorObject& error_obj) const { @@ -4176,7 +4186,7 @@ bool ObjectLifetimes::PreCallValidateCmdBindIndexBuffer2KHR(VkCommandBuffer comm bool skip = false; // Checked by chassis: commandBuffer: "VUID-vkCmdBindIndexBuffer2KHR-commandBuffer-parameter" // Checked by chassis: commandBuffer: "VUID-vkCmdBindIndexBuffer2KHR-commonparent" - skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdBindIndexBuffer2KHR-buffer-parameter", + skip |= ValidateObject(buffer, kVulkanObjectTypeBuffer, true, "VUID-vkCmdBindIndexBuffer2KHR-buffer-parameter", "VUID-vkCmdBindIndexBuffer2KHR-commonparent", error_obj.location.dot(Field::buffer)); return skip; @@ -4209,6 +4219,252 @@ bool ObjectLifetimes::PreCallValidateGetImageSubresourceLayout2KHR(VkDevice devi // vkGetCalibratedTimestampsKHR: // Checked by chassis: device: "VUID-vkGetCalibratedTimestampsKHR-device-parameter" +bool ObjectLifetimes::PreCallValidateCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo, + const ErrorObject& error_obj) const { + bool skip = false; + // Checked by chassis: commandBuffer: "VUID-vkCmdBindDescriptorSets2KHR-commandBuffer-parameter" + if (pBindDescriptorSetsInfo) { + [[maybe_unused]] const Location pBindDescriptorSetsInfo_loc = error_obj.location.dot(Field::pBindDescriptorSetsInfo); + skip |= ValidateObject(pBindDescriptorSetsInfo->layout, kVulkanObjectTypePipelineLayout, true, + "VUID-VkBindDescriptorSetsInfoKHR-layout-parameter", "VUID-VkBindDescriptorSetsInfoKHR-commonparent", + pBindDescriptorSetsInfo_loc.dot(Field::layout)); + + if ((pBindDescriptorSetsInfo->descriptorSetCount > 0) && (pBindDescriptorSetsInfo->pDescriptorSets)) { + for (uint32_t index1 = 0; index1 < pBindDescriptorSetsInfo->descriptorSetCount; ++index1) { + skip |= ValidateObject(pBindDescriptorSetsInfo->pDescriptorSets[index1], kVulkanObjectTypeDescriptorSet, false, + "VUID-VkBindDescriptorSetsInfoKHR-pDescriptorSets-parameter", + "VUID-VkBindDescriptorSetsInfoKHR-commonparent", + pBindDescriptorSetsInfo_loc.dot(Field::pDescriptorSets, index1)); + } + } + if (auto pNext = vku::FindStructInPNextChain(pBindDescriptorSetsInfo->pNext)) { + const Location pNext_loc = pBindDescriptorSetsInfo_loc.pNext(Struct::VkPipelineLayoutCreateInfo); + + if ((pNext->setLayoutCount > 0) && (pNext->pSetLayouts)) { + for (uint32_t index2 = 0; index2 < pNext->setLayoutCount; ++index2) { + skip |= ValidateObject(pNext->pSetLayouts[index2], kVulkanObjectTypeDescriptorSetLayout, true, + "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-parameter", kVUIDUndefined, + pNext_loc.dot(Field::pSetLayouts, index2)); + } + } + } + } + + return skip; +} + +bool ObjectLifetimes::PreCallValidateCmdPushConstants2KHR(VkCommandBuffer commandBuffer, + const VkPushConstantsInfoKHR* pPushConstantsInfo, + const ErrorObject& error_obj) const { + bool skip = false; + // Checked by chassis: commandBuffer: "VUID-vkCmdPushConstants2KHR-commandBuffer-parameter" + if (pPushConstantsInfo) { + [[maybe_unused]] const Location pPushConstantsInfo_loc = error_obj.location.dot(Field::pPushConstantsInfo); + skip |= ValidateObject(pPushConstantsInfo->layout, kVulkanObjectTypePipelineLayout, true, + "VUID-VkPushConstantsInfoKHR-layout-parameter", "UNASSIGNED-VkPushConstantsInfoKHR-layout-parent", + pPushConstantsInfo_loc.dot(Field::layout)); + if (auto pNext = vku::FindStructInPNextChain(pPushConstantsInfo->pNext)) { + const Location pNext_loc = pPushConstantsInfo_loc.pNext(Struct::VkPipelineLayoutCreateInfo); + + if ((pNext->setLayoutCount > 0) && (pNext->pSetLayouts)) { + for (uint32_t index2 = 0; index2 < pNext->setLayoutCount; ++index2) { + skip |= ValidateObject(pNext->pSetLayouts[index2], kVulkanObjectTypeDescriptorSetLayout, true, + "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-parameter", kVUIDUndefined, + pNext_loc.dot(Field::pSetLayouts, index2)); + } + } + } + } + + return skip; +} + +bool ObjectLifetimes::PreCallValidateCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo, + const ErrorObject& error_obj) const { + bool skip = false; + // Checked by chassis: commandBuffer: "VUID-vkCmdPushDescriptorSet2KHR-commandBuffer-parameter" + if (pPushDescriptorSetInfo) { + [[maybe_unused]] const Location pPushDescriptorSetInfo_loc = error_obj.location.dot(Field::pPushDescriptorSetInfo); + skip |= + ValidateObject(pPushDescriptorSetInfo->layout, kVulkanObjectTypePipelineLayout, true, + "VUID-VkPushDescriptorSetInfoKHR-layout-parameter", + "UNASSIGNED-VkPushDescriptorSetInfoKHR-layout-parent", pPushDescriptorSetInfo_loc.dot(Field::layout)); + if (pPushDescriptorSetInfo->pDescriptorWrites) { + for (uint32_t index1 = 0; index1 < pPushDescriptorSetInfo->descriptorWriteCount; ++index1) { + [[maybe_unused]] const Location index1_loc = pPushDescriptorSetInfo_loc.dot(Field::pDescriptorWrites, index1); + skip |= + ValidateObject(pPushDescriptorSetInfo->pDescriptorWrites[index1].dstSet, kVulkanObjectTypeDescriptorSet, true, + kVUIDUndefined, "VUID-VkWriteDescriptorSet-commonparent", index1_loc.dot(Field::dstSet)); + if (pPushDescriptorSetInfo->pDescriptorWrites[index1].pImageInfo) { + for (uint32_t index2 = 0; index2 < pPushDescriptorSetInfo->pDescriptorWrites[index1].descriptorCount; + ++index2) { + [[maybe_unused]] const Location index2_loc = index1_loc.dot(Field::pImageInfo, index2); + skip |= ValidateObject(pPushDescriptorSetInfo->pDescriptorWrites[index1].pImageInfo[index2].sampler, + kVulkanObjectTypeSampler, true, kVUIDUndefined, + "VUID-VkDescriptorImageInfo-commonparent", index2_loc.dot(Field::sampler)); + skip |= ValidateObject(pPushDescriptorSetInfo->pDescriptorWrites[index1].pImageInfo[index2].imageView, + kVulkanObjectTypeImageView, true, kVUIDUndefined, + "VUID-VkDescriptorImageInfo-commonparent", index2_loc.dot(Field::imageView)); + } + } + if (pPushDescriptorSetInfo->pDescriptorWrites[index1].pBufferInfo) { + for (uint32_t index2 = 0; index2 < pPushDescriptorSetInfo->pDescriptorWrites[index1].descriptorCount; + ++index2) { + [[maybe_unused]] const Location index2_loc = index1_loc.dot(Field::pBufferInfo, index2); + skip |= ValidateObject(pPushDescriptorSetInfo->pDescriptorWrites[index1].pBufferInfo[index2].buffer, + kVulkanObjectTypeBuffer, true, "VUID-VkDescriptorBufferInfo-buffer-parameter", + "UNASSIGNED-VkDescriptorBufferInfo-buffer-parent", index2_loc.dot(Field::buffer)); + } + } + + if ((pPushDescriptorSetInfo->pDescriptorWrites[index1].descriptorCount > 0) && + (pPushDescriptorSetInfo->pDescriptorWrites[index1].pTexelBufferView)) { + for (uint32_t index2 = 0; index2 < pPushDescriptorSetInfo->pDescriptorWrites[index1].descriptorCount; + ++index2) { + skip |= ValidateObject(pPushDescriptorSetInfo->pDescriptorWrites[index1].pTexelBufferView[index2], + kVulkanObjectTypeBufferView, true, kVUIDUndefined, + "VUID-VkWriteDescriptorSet-commonparent", + index1_loc.dot(Field::pTexelBufferView, index2)); + } + } + if (auto pNext = vku::FindStructInPNextChain( + pPushDescriptorSetInfo->pDescriptorWrites[index1].pNext)) { + const Location pNext_loc = index1_loc.pNext(Struct::VkWriteDescriptorSetAccelerationStructureKHR); + + if ((pNext->accelerationStructureCount > 0) && (pNext->pAccelerationStructures)) { + for (uint32_t index3 = 0; index3 < pNext->accelerationStructureCount; ++index3) { + skip |= ValidateObject( + pNext->pAccelerationStructures[index3], kVulkanObjectTypeAccelerationStructureKHR, true, + "VUID-VkWriteDescriptorSetAccelerationStructureKHR-pAccelerationStructures-parameter", + "UNASSIGNED-VkWriteDescriptorSetAccelerationStructureKHR-pAccelerationStructures-parent", + pNext_loc.dot(Field::pAccelerationStructures, index3)); + } + } + } + if (auto pNext = vku::FindStructInPNextChain( + pPushDescriptorSetInfo->pDescriptorWrites[index1].pNext)) { + const Location pNext_loc = index1_loc.pNext(Struct::VkWriteDescriptorSetAccelerationStructureNV); + + if ((pNext->accelerationStructureCount > 0) && (pNext->pAccelerationStructures)) { + for (uint32_t index3 = 0; index3 < pNext->accelerationStructureCount; ++index3) { + skip |= ValidateObject( + pNext->pAccelerationStructures[index3], kVulkanObjectTypeAccelerationStructureNV, true, + "VUID-VkWriteDescriptorSetAccelerationStructureNV-pAccelerationStructures-parameter", + "UNASSIGNED-VkWriteDescriptorSetAccelerationStructureNV-pAccelerationStructures-parent", + pNext_loc.dot(Field::pAccelerationStructures, index3)); + } + } + } + } + } + if (auto pNext = vku::FindStructInPNextChain(pPushDescriptorSetInfo->pNext)) { + const Location pNext_loc = pPushDescriptorSetInfo_loc.pNext(Struct::VkPipelineLayoutCreateInfo); + + if ((pNext->setLayoutCount > 0) && (pNext->pSetLayouts)) { + for (uint32_t index2 = 0; index2 < pNext->setLayoutCount; ++index2) { + skip |= ValidateObject(pNext->pSetLayouts[index2], kVulkanObjectTypeDescriptorSetLayout, true, + "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-parameter", kVUIDUndefined, + pNext_loc.dot(Field::pSetLayouts, index2)); + } + } + } + } + + return skip; +} + +bool ObjectLifetimes::PreCallValidateCmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo, + const ErrorObject& error_obj) const { + bool skip = false; + // Checked by chassis: commandBuffer: "VUID-vkCmdPushDescriptorSetWithTemplate2KHR-commandBuffer-parameter" + if (pPushDescriptorSetWithTemplateInfo) { + [[maybe_unused]] const Location pPushDescriptorSetWithTemplateInfo_loc = + error_obj.location.dot(Field::pPushDescriptorSetWithTemplateInfo); + skip |= + ValidateObject(pPushDescriptorSetWithTemplateInfo->descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, + false, "VUID-VkPushDescriptorSetWithTemplateInfoKHR-descriptorUpdateTemplate-parameter", + "VUID-VkPushDescriptorSetWithTemplateInfoKHR-commonparent", + pPushDescriptorSetWithTemplateInfo_loc.dot(Field::descriptorUpdateTemplate)); + skip |= ValidateObject(pPushDescriptorSetWithTemplateInfo->layout, kVulkanObjectTypePipelineLayout, true, + "VUID-VkPushDescriptorSetWithTemplateInfoKHR-layout-parameter", + "VUID-VkPushDescriptorSetWithTemplateInfoKHR-commonparent", + pPushDescriptorSetWithTemplateInfo_loc.dot(Field::layout)); + if (auto pNext = vku::FindStructInPNextChain(pPushDescriptorSetWithTemplateInfo->pNext)) { + const Location pNext_loc = pPushDescriptorSetWithTemplateInfo_loc.pNext(Struct::VkPipelineLayoutCreateInfo); + + if ((pNext->setLayoutCount > 0) && (pNext->pSetLayouts)) { + for (uint32_t index2 = 0; index2 < pNext->setLayoutCount; ++index2) { + skip |= ValidateObject(pNext->pSetLayouts[index2], kVulkanObjectTypeDescriptorSetLayout, true, + "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-parameter", kVUIDUndefined, + pNext_loc.dot(Field::pSetLayouts, index2)); + } + } + } + } + + return skip; +} + +bool ObjectLifetimes::PreCallValidateCmdSetDescriptorBufferOffsets2EXT( + VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo, + const ErrorObject& error_obj) const { + bool skip = false; + // Checked by chassis: commandBuffer: "VUID-vkCmdSetDescriptorBufferOffsets2EXT-commandBuffer-parameter" + if (pSetDescriptorBufferOffsetsInfo) { + [[maybe_unused]] const Location pSetDescriptorBufferOffsetsInfo_loc = + error_obj.location.dot(Field::pSetDescriptorBufferOffsetsInfo); + skip |= ValidateObject(pSetDescriptorBufferOffsetsInfo->layout, kVulkanObjectTypePipelineLayout, true, + "VUID-VkSetDescriptorBufferOffsetsInfoEXT-layout-parameter", + "UNASSIGNED-VkSetDescriptorBufferOffsetsInfoEXT-layout-parent", + pSetDescriptorBufferOffsetsInfo_loc.dot(Field::layout)); + if (auto pNext = vku::FindStructInPNextChain(pSetDescriptorBufferOffsetsInfo->pNext)) { + const Location pNext_loc = pSetDescriptorBufferOffsetsInfo_loc.pNext(Struct::VkPipelineLayoutCreateInfo); + + if ((pNext->setLayoutCount > 0) && (pNext->pSetLayouts)) { + for (uint32_t index2 = 0; index2 < pNext->setLayoutCount; ++index2) { + skip |= ValidateObject(pNext->pSetLayouts[index2], kVulkanObjectTypeDescriptorSetLayout, true, + "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-parameter", kVUIDUndefined, + pNext_loc.dot(Field::pSetLayouts, index2)); + } + } + } + } + + return skip; +} + +bool ObjectLifetimes::PreCallValidateCmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo, + const ErrorObject& error_obj) const { + bool skip = false; + // Checked by chassis: commandBuffer: "VUID-vkCmdBindDescriptorBufferEmbeddedSamplers2EXT-commandBuffer-parameter" + if (pBindDescriptorBufferEmbeddedSamplersInfo) { + [[maybe_unused]] const Location pBindDescriptorBufferEmbeddedSamplersInfo_loc = + error_obj.location.dot(Field::pBindDescriptorBufferEmbeddedSamplersInfo); + skip |= ValidateObject(pBindDescriptorBufferEmbeddedSamplersInfo->layout, kVulkanObjectTypePipelineLayout, true, + "VUID-VkBindDescriptorBufferEmbeddedSamplersInfoEXT-layout-parameter", + "UNASSIGNED-VkBindDescriptorBufferEmbeddedSamplersInfoEXT-layout-parent", + pBindDescriptorBufferEmbeddedSamplersInfo_loc.dot(Field::layout)); + if (auto pNext = + vku::FindStructInPNextChain(pBindDescriptorBufferEmbeddedSamplersInfo->pNext)) { + const Location pNext_loc = pBindDescriptorBufferEmbeddedSamplersInfo_loc.pNext(Struct::VkPipelineLayoutCreateInfo); + + if ((pNext->setLayoutCount > 0) && (pNext->pSetLayouts)) { + for (uint32_t index2 = 0; index2 < pNext->setLayoutCount; ++index2) { + skip |= ValidateObject(pNext->pSetLayouts[index2], kVulkanObjectTypeDescriptorSetLayout, true, + "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-parameter", kVUIDUndefined, + pNext_loc.dot(Field::pSetLayouts, index2)); + } + } + } + } + + return skip; +} + // vkCreateDebugReportCallbackEXT: // Checked by chassis: instance: "VUID-vkCreateDebugReportCallbackEXT-instance-parameter" diff --git a/layers/vulkan/generated/object_tracker.h b/layers/vulkan/generated/object_tracker.h index cf98dfbf2e3..00345297e4b 100644 --- a/layers/vulkan/generated/object_tracker.h +++ b/layers/vulkan/generated/object_tracker.h @@ -768,7 +768,6 @@ bool PreCallValidateMapMemory2KHR(VkDevice device, const VkMemoryMapInfoKHR* pMe const ErrorObject& error_obj) const override; bool PreCallValidateUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo, const ErrorObject& error_obj) const override; -#ifdef VK_ENABLE_BETA_EXTENSIONS bool PreCallValidateGetEncodedVideoSessionParametersKHR(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, @@ -776,7 +775,6 @@ bool PreCallValidateGetEncodedVideoSessionParametersKHR(VkDevice device, const ErrorObject& error_obj) const override; bool PreCallValidateCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo, const ErrorObject& error_obj) const override; -#endif // VK_ENABLE_BETA_EXTENSIONS bool PreCallValidateCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo, const ErrorObject& error_obj) const override; bool PreCallValidateCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask, @@ -807,6 +805,23 @@ bool PreCallValidateCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuff VkIndexType indexType, const ErrorObject& error_obj) const override; bool PreCallValidateGetImageSubresourceLayout2KHR(VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout, const ErrorObject& error_obj) const override; +bool PreCallValidateCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo, + const ErrorObject& error_obj) const override; +bool PreCallValidateCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR* pPushConstantsInfo, + const ErrorObject& error_obj) const override; +bool PreCallValidateCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo, + const ErrorObject& error_obj) const override; +bool PreCallValidateCmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo, + const ErrorObject& error_obj) const override; +bool PreCallValidateCmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, + const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo, + const ErrorObject& error_obj) const override; +bool PreCallValidateCmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo, + const ErrorObject& error_obj) const override; void PostCallRecordCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback, const RecordObject& record_obj) override; diff --git a/layers/vulkan/generated/pnext_chain_extraction.cpp b/layers/vulkan/generated/pnext_chain_extraction.cpp index 19c4b87f3da..6675d357320 100644 --- a/layers/vulkan/generated/pnext_chain_extraction.cpp +++ b/layers/vulkan/generated/pnext_chain_extraction.cpp @@ -60,6 +60,11 @@ void PnextChainFree(void *chain) { header->pNext = nullptr; delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: PnextChainFree(header->pNext); header->pNext = nullptr; @@ -645,6 +650,136 @@ void PnextChainFree(void *chain) { header->pNext = nullptr; delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: PnextChainFree(header->pNext); header->pNext = nullptr; @@ -883,7 +1018,6 @@ void PnextChainFree(void *chain) { header->pNext = nullptr; delete reinterpret_cast(header); break; -#ifdef VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: PnextChainFree(header->pNext); header->pNext = nullptr; @@ -909,7 +1043,6 @@ void PnextChainFree(void *chain) { header->pNext = nullptr; delete reinterpret_cast(header); break; -#endif // VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: PnextChainFree(header->pNext); header->pNext = nullptr; @@ -975,6 +1108,16 @@ void PnextChainFree(void *chain) { header->pNext = nullptr; delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: PnextChainFree(header->pNext); header->pNext = nullptr; @@ -990,6 +1133,21 @@ void PnextChainFree(void *chain) { header->pNext = nullptr; delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: PnextChainFree(header->pNext); header->pNext = nullptr; @@ -1030,138 +1188,6 @@ void PnextChainFree(void *chain) { header->pNext = nullptr; delete reinterpret_cast(header); break; -#ifdef VK_ENABLE_BETA_EXTENSIONS - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT: - PnextChainFree(header->pNext); - header->pNext = nullptr; - delete reinterpret_cast(header); - break; -#endif // VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: PnextChainFree(header->pNext); header->pNext = nullptr; @@ -2705,6 +2731,11 @@ void PnextChainFree(void *chain) { header->pNext = nullptr; delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + PnextChainFree(header->pNext); + header->pNext = nullptr; + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: PnextChainFree(header->pNext); header->pNext = nullptr; diff --git a/layers/vulkan/generated/state_tracker_helper.cpp b/layers/vulkan/generated/state_tracker_helper.cpp index 5a74b4471b3..bdc4214cb40 100644 --- a/layers/vulkan/generated/state_tracker_helper.cpp +++ b/layers/vulkan/generated/state_tracker_helper.cpp @@ -564,6 +564,12 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu features->cooperativeMatrixRobustBufferAccess |= enabled->cooperativeMatrixRobustBufferAccess == VK_TRUE; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: { + const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *enabled = + reinterpret_cast(pNext); + features->videoMaintenance1 |= enabled->videoMaintenance1 == VK_TRUE; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: { const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR *enabled = reinterpret_cast(pNext); @@ -571,6 +577,12 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu features->vertexAttributeInstanceRateZeroDivisor |= enabled->vertexAttributeInstanceRateZeroDivisor == VK_TRUE; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: { + const VkPhysicalDeviceMaintenance6FeaturesKHR *enabled = + reinterpret_cast(pNext); + features->maintenance6 |= enabled->maintenance6 == VK_TRUE; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: { const VkPhysicalDeviceTransformFeedbackFeaturesEXT *enabled = reinterpret_cast(pNext); @@ -1382,6 +1394,13 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu features->multiviewPerViewRenderAreas |= enabled->multiviewPerViewRenderAreas == VK_TRUE; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: { + const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *enabled = + reinterpret_cast(pNext); + features->perStageDescriptorSet |= enabled->perStageDescriptorSet == VK_TRUE; + features->dynamicPipelineLayout |= enabled->dynamicPipelineLayout == VK_TRUE; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: { const VkPhysicalDeviceImageProcessing2FeaturesQCOM *enabled = reinterpret_cast(pNext); diff --git a/layers/vulkan/generated/state_tracker_helper.h b/layers/vulkan/generated/state_tracker_helper.h index d0cc3eaeb72..ecbcab58097 100644 --- a/layers/vulkan/generated/state_tracker_helper.h +++ b/layers/vulkan/generated/state_tracker_helper.h @@ -493,6 +493,8 @@ struct DeviceFeatures { bool maintenance4; // VkPhysicalDeviceMaintenance5FeaturesKHR bool maintenance5; + // VkPhysicalDeviceMaintenance6FeaturesKHR + bool maintenance6; // VkPhysicalDeviceMemoryDecompressionFeaturesNV bool memoryDecompression; // VkPhysicalDeviceMemoryPriorityFeaturesEXT @@ -541,6 +543,10 @@ struct DeviceFeatures { bool opticalFlow; // VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT bool pageableDeviceLocalMemory; + // VkPhysicalDevicePerStageDescriptorSetFeaturesNV + bool dynamicPipelineLayout; + // VkPhysicalDevicePerStageDescriptorSetFeaturesNV + bool perStageDescriptorSet; // VkPhysicalDevicePerformanceQueryFeaturesKHR bool performanceCounterMultipleQueryPools; // VkPhysicalDevicePerformanceQueryFeaturesKHR @@ -801,6 +807,8 @@ struct DeviceFeatures { bool vertexAttributeInstanceRateZeroDivisor; // VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT bool vertexInputDynamicState; + // VkPhysicalDeviceVideoMaintenance1FeaturesKHR + bool videoMaintenance1; // VkPhysicalDeviceVulkan12Features bool descriptorIndexing; // VkPhysicalDeviceVulkan12Features diff --git a/layers/vulkan/generated/stateless_validation_helper.cpp b/layers/vulkan/generated/stateless_validation_helper.cpp index 752f64d3bbb..649f5e2c84c 100644 --- a/layers/vulkan/generated/stateless_validation_helper.cpp +++ b/layers/vulkan/generated/stateless_validation_helper.cpp @@ -45,6 +45,33 @@ bool StatelessValidation::ValidatePnextStructContents(const Location& loc, const } } break; + // Validation code for VkPipelineLayoutCreateInfo structure members + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: { // Covers VUID-VkPipelineLayoutCreateInfo-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPipelineLayoutCreateInfo); + VkPipelineLayoutCreateInfo* structure = (VkPipelineLayoutCreateInfo*)header; + skip |= + ValidateFlags(pNext_loc.dot(Field::flags), "VkPipelineLayoutCreateFlagBits", AllVkPipelineLayoutCreateFlagBits, + structure->flags, kOptionalFlags, "VUID-VkPipelineLayoutCreateInfo-flags-parameter"); + + skip |= ValidateArray(pNext_loc.dot(Field::pushConstantRangeCount), pNext_loc.dot(Field::pPushConstantRanges), + structure->pushConstantRangeCount, &structure->pPushConstantRanges, false, true, + kVUIDUndefined, "VUID-VkPipelineLayoutCreateInfo-pPushConstantRanges-parameter"); + + if (structure->pPushConstantRanges != nullptr) { + for (uint32_t pushConstantRangeIndex = 0; pushConstantRangeIndex < structure->pushConstantRangeCount; + ++pushConstantRangeIndex) { + [[maybe_unused]] const Location pPushConstantRanges_loc = + pNext_loc.dot(Field::pPushConstantRanges, pushConstantRangeIndex); + skip |= ValidateFlags( + pPushConstantRanges_loc.dot(Field::stageFlags), "VkShaderStageFlagBits", AllVkShaderStageFlagBits, + structure->pPushConstantRanges[pushConstantRangeIndex].stageFlags, kRequiredFlags, + "VUID-VkPushConstantRange-stageFlags-parameter", "VUID-VkPushConstantRange-stageFlags-requiredbitmask"); + } + } + } + } break; + // Validation code for VkPhysicalDeviceSubgroupProperties structure members case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: { // Covers VUID-VkPhysicalDeviceSubgroupProperties-sType-sType @@ -2486,6 +2513,273 @@ bool StatelessValidation::ValidatePnextStructContents(const Location& loc, const } } break; + // No Validation code for VkVideoEncodeH264CapabilitiesKHR structure members -- Covers + // VUID-VkVideoEncodeH264CapabilitiesKHR-sType-sType + + // No Validation code for VkVideoEncodeH264QualityLevelPropertiesKHR structure members -- Covers + // VUID-VkVideoEncodeH264QualityLevelPropertiesKHR-sType-sType + + // Validation code for VkVideoEncodeH264SessionCreateInfoKHR structure members + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: { // Covers + // VUID-VkVideoEncodeH264SessionCreateInfoKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH264SessionCreateInfoKHR); + VkVideoEncodeH264SessionCreateInfoKHR* structure = (VkVideoEncodeH264SessionCreateInfoKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::useMaxLevelIdc), structure->useMaxLevelIdc); + } + } break; + + // No Validation code for VkVideoEncodeH264SessionParametersAddInfoKHR structure members -- Covers + // VUID-VkVideoEncodeH264SessionParametersAddInfoKHR-sType-sType + + // Validation code for VkVideoEncodeH264SessionParametersCreateInfoKHR structure members + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: { // Covers + // VUID-VkVideoEncodeH264SessionParametersCreateInfoKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH264SessionParametersCreateInfoKHR); + VkVideoEncodeH264SessionParametersCreateInfoKHR* structure = + (VkVideoEncodeH264SessionParametersCreateInfoKHR*)header; + skip |= ValidateStructType( + pNext_loc.dot(Field::pParametersAddInfo), "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR", + structure->pParametersAddInfo, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR, false, + "VUID-VkVideoEncodeH264SessionParametersCreateInfoKHR-pParametersAddInfo-parameter", + "VUID-VkVideoEncodeH264SessionParametersAddInfoKHR-sType-sType"); + + if (structure->pParametersAddInfo != nullptr) { + [[maybe_unused]] const Location pParametersAddInfo_loc = pNext_loc.dot(Field::pParametersAddInfo); + } + } + } break; + + // Validation code for VkVideoEncodeH264SessionParametersGetInfoKHR structure members + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: { // Covers + // VUID-VkVideoEncodeH264SessionParametersGetInfoKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH264SessionParametersGetInfoKHR); + VkVideoEncodeH264SessionParametersGetInfoKHR* structure = (VkVideoEncodeH264SessionParametersGetInfoKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::writeStdSPS), structure->writeStdSPS); + + skip |= ValidateBool32(pNext_loc.dot(Field::writeStdPPS), structure->writeStdPPS); + } + } break; + + // No Validation code for VkVideoEncodeH264SessionParametersFeedbackInfoKHR structure members -- Covers + // VUID-VkVideoEncodeH264SessionParametersFeedbackInfoKHR-sType-sType + + // Validation code for VkVideoEncodeH264PictureInfoKHR structure members + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: { // Covers VUID-VkVideoEncodeH264PictureInfoKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH264PictureInfoKHR); + VkVideoEncodeH264PictureInfoKHR* structure = (VkVideoEncodeH264PictureInfoKHR*)header; + skip |= ValidateStructTypeArray(pNext_loc.dot(Field::naluSliceEntryCount), pNext_loc.dot(Field::pNaluSliceEntries), + "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR", + structure->naluSliceEntryCount, structure->pNaluSliceEntries, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR, true, true, + "VUID-VkVideoEncodeH264NaluSliceInfoKHR-sType-sType", + "VUID-VkVideoEncodeH264PictureInfoKHR-pNaluSliceEntries-parameter", + "VUID-VkVideoEncodeH264PictureInfoKHR-naluSliceEntryCount-arraylength"); + + if (structure->pNaluSliceEntries != nullptr) { + for (uint32_t naluSliceEntryIndex = 0; naluSliceEntryIndex < structure->naluSliceEntryCount; + ++naluSliceEntryIndex) { + [[maybe_unused]] const Location pNaluSliceEntries_loc = + pNext_loc.dot(Field::pNaluSliceEntries, naluSliceEntryIndex); + skip |= ValidateRequiredPointer(pNaluSliceEntries_loc.dot(Field::pStdSliceHeader), + structure->pNaluSliceEntries[naluSliceEntryIndex].pStdSliceHeader, + "VUID-VkVideoEncodeH264NaluSliceInfoKHR-pStdSliceHeader-parameter"); + } + } + + skip |= ValidateRequiredPointer(pNext_loc.dot(Field::pStdPictureInfo), structure->pStdPictureInfo, + "VUID-VkVideoEncodeH264PictureInfoKHR-pStdPictureInfo-parameter"); + + skip |= ValidateBool32(pNext_loc.dot(Field::generatePrefixNalu), structure->generatePrefixNalu); + } + } break; + + // Validation code for VkVideoEncodeH264DpbSlotInfoKHR structure members + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: { // Covers VUID-VkVideoEncodeH264DpbSlotInfoKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH264DpbSlotInfoKHR); + VkVideoEncodeH264DpbSlotInfoKHR* structure = (VkVideoEncodeH264DpbSlotInfoKHR*)header; + skip |= ValidateRequiredPointer(pNext_loc.dot(Field::pStdReferenceInfo), structure->pStdReferenceInfo, + "VUID-VkVideoEncodeH264DpbSlotInfoKHR-pStdReferenceInfo-parameter"); + } + } break; + + // No Validation code for VkVideoEncodeH264ProfileInfoKHR structure members -- Covers + // VUID-VkVideoEncodeH264ProfileInfoKHR-sType-sType + + // Validation code for VkVideoEncodeH264RateControlInfoKHR structure members + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: { // Covers + // VUID-VkVideoEncodeH264RateControlInfoKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH264RateControlInfoKHR); + VkVideoEncodeH264RateControlInfoKHR* structure = (VkVideoEncodeH264RateControlInfoKHR*)header; + skip |= ValidateFlags(pNext_loc.dot(Field::flags), "VkVideoEncodeH264RateControlFlagBitsKHR", + AllVkVideoEncodeH264RateControlFlagBitsKHR, structure->flags, kOptionalFlags, + "VUID-VkVideoEncodeH264RateControlInfoKHR-flags-parameter"); + } + } break; + + // Validation code for VkVideoEncodeH264RateControlLayerInfoKHR structure members + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: { // Covers + // VUID-VkVideoEncodeH264RateControlLayerInfoKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH264RateControlLayerInfoKHR); + VkVideoEncodeH264RateControlLayerInfoKHR* structure = (VkVideoEncodeH264RateControlLayerInfoKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::useMinQp), structure->useMinQp); + + skip |= ValidateBool32(pNext_loc.dot(Field::useMaxQp), structure->useMaxQp); + + skip |= ValidateBool32(pNext_loc.dot(Field::useMaxFrameSize), structure->useMaxFrameSize); + } + } break; + + // Validation code for VkVideoEncodeH264GopRemainingFrameInfoKHR structure members + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: { // Covers + // VUID-VkVideoEncodeH264GopRemainingFrameInfoKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH264GopRemainingFrameInfoKHR); + VkVideoEncodeH264GopRemainingFrameInfoKHR* structure = (VkVideoEncodeH264GopRemainingFrameInfoKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::useGopRemainingFrames), structure->useGopRemainingFrames); + } + } break; + + // No Validation code for VkVideoEncodeH265CapabilitiesKHR structure members -- Covers + // VUID-VkVideoEncodeH265CapabilitiesKHR-sType-sType + + // Validation code for VkVideoEncodeH265SessionCreateInfoKHR structure members + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: { // Covers + // VUID-VkVideoEncodeH265SessionCreateInfoKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH265SessionCreateInfoKHR); + VkVideoEncodeH265SessionCreateInfoKHR* structure = (VkVideoEncodeH265SessionCreateInfoKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::useMaxLevelIdc), structure->useMaxLevelIdc); + } + } break; + + // No Validation code for VkVideoEncodeH265QualityLevelPropertiesKHR structure members -- Covers + // VUID-VkVideoEncodeH265QualityLevelPropertiesKHR-sType-sType + + // No Validation code for VkVideoEncodeH265SessionParametersAddInfoKHR structure members -- Covers + // VUID-VkVideoEncodeH265SessionParametersAddInfoKHR-sType-sType + + // Validation code for VkVideoEncodeH265SessionParametersCreateInfoKHR structure members + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: { // Covers + // VUID-VkVideoEncodeH265SessionParametersCreateInfoKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH265SessionParametersCreateInfoKHR); + VkVideoEncodeH265SessionParametersCreateInfoKHR* structure = + (VkVideoEncodeH265SessionParametersCreateInfoKHR*)header; + skip |= ValidateStructType( + pNext_loc.dot(Field::pParametersAddInfo), "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR", + structure->pParametersAddInfo, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR, false, + "VUID-VkVideoEncodeH265SessionParametersCreateInfoKHR-pParametersAddInfo-parameter", + "VUID-VkVideoEncodeH265SessionParametersAddInfoKHR-sType-sType"); + + if (structure->pParametersAddInfo != nullptr) { + [[maybe_unused]] const Location pParametersAddInfo_loc = pNext_loc.dot(Field::pParametersAddInfo); + } + } + } break; + + // Validation code for VkVideoEncodeH265SessionParametersGetInfoKHR structure members + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: { // Covers + // VUID-VkVideoEncodeH265SessionParametersGetInfoKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH265SessionParametersGetInfoKHR); + VkVideoEncodeH265SessionParametersGetInfoKHR* structure = (VkVideoEncodeH265SessionParametersGetInfoKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::writeStdVPS), structure->writeStdVPS); + + skip |= ValidateBool32(pNext_loc.dot(Field::writeStdSPS), structure->writeStdSPS); + + skip |= ValidateBool32(pNext_loc.dot(Field::writeStdPPS), structure->writeStdPPS); + } + } break; + + // No Validation code for VkVideoEncodeH265SessionParametersFeedbackInfoKHR structure members -- Covers + // VUID-VkVideoEncodeH265SessionParametersFeedbackInfoKHR-sType-sType + + // Validation code for VkVideoEncodeH265PictureInfoKHR structure members + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: { // Covers VUID-VkVideoEncodeH265PictureInfoKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH265PictureInfoKHR); + VkVideoEncodeH265PictureInfoKHR* structure = (VkVideoEncodeH265PictureInfoKHR*)header; + skip |= ValidateStructTypeArray( + pNext_loc.dot(Field::naluSliceSegmentEntryCount), pNext_loc.dot(Field::pNaluSliceSegmentEntries), + "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR", structure->naluSliceSegmentEntryCount, + structure->pNaluSliceSegmentEntries, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR, true, + true, "VUID-VkVideoEncodeH265NaluSliceSegmentInfoKHR-sType-sType", + "VUID-VkVideoEncodeH265PictureInfoKHR-pNaluSliceSegmentEntries-parameter", + "VUID-VkVideoEncodeH265PictureInfoKHR-naluSliceSegmentEntryCount-arraylength"); + + if (structure->pNaluSliceSegmentEntries != nullptr) { + for (uint32_t naluSliceSegmentEntryIndex = 0; + naluSliceSegmentEntryIndex < structure->naluSliceSegmentEntryCount; ++naluSliceSegmentEntryIndex) { + [[maybe_unused]] const Location pNaluSliceSegmentEntries_loc = + pNext_loc.dot(Field::pNaluSliceSegmentEntries, naluSliceSegmentEntryIndex); + skip |= ValidateRequiredPointer( + pNaluSliceSegmentEntries_loc.dot(Field::pStdSliceSegmentHeader), + structure->pNaluSliceSegmentEntries[naluSliceSegmentEntryIndex].pStdSliceSegmentHeader, + "VUID-VkVideoEncodeH265NaluSliceSegmentInfoKHR-pStdSliceSegmentHeader-parameter"); + } + } + + skip |= ValidateRequiredPointer(pNext_loc.dot(Field::pStdPictureInfo), structure->pStdPictureInfo, + "VUID-VkVideoEncodeH265PictureInfoKHR-pStdPictureInfo-parameter"); + } + } break; + + // Validation code for VkVideoEncodeH265DpbSlotInfoKHR structure members + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: { // Covers VUID-VkVideoEncodeH265DpbSlotInfoKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH265DpbSlotInfoKHR); + VkVideoEncodeH265DpbSlotInfoKHR* structure = (VkVideoEncodeH265DpbSlotInfoKHR*)header; + skip |= ValidateRequiredPointer(pNext_loc.dot(Field::pStdReferenceInfo), structure->pStdReferenceInfo, + "VUID-VkVideoEncodeH265DpbSlotInfoKHR-pStdReferenceInfo-parameter"); + } + } break; + + // No Validation code for VkVideoEncodeH265ProfileInfoKHR structure members -- Covers + // VUID-VkVideoEncodeH265ProfileInfoKHR-sType-sType + + // Validation code for VkVideoEncodeH265RateControlInfoKHR structure members + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: { // Covers + // VUID-VkVideoEncodeH265RateControlInfoKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH265RateControlInfoKHR); + VkVideoEncodeH265RateControlInfoKHR* structure = (VkVideoEncodeH265RateControlInfoKHR*)header; + skip |= ValidateFlags(pNext_loc.dot(Field::flags), "VkVideoEncodeH265RateControlFlagBitsKHR", + AllVkVideoEncodeH265RateControlFlagBitsKHR, structure->flags, kOptionalFlags, + "VUID-VkVideoEncodeH265RateControlInfoKHR-flags-parameter"); + } + } break; + + // Validation code for VkVideoEncodeH265RateControlLayerInfoKHR structure members + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: { // Covers + // VUID-VkVideoEncodeH265RateControlLayerInfoKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH265RateControlLayerInfoKHR); + VkVideoEncodeH265RateControlLayerInfoKHR* structure = (VkVideoEncodeH265RateControlLayerInfoKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::useMinQp), structure->useMinQp); + + skip |= ValidateBool32(pNext_loc.dot(Field::useMaxQp), structure->useMaxQp); + + skip |= ValidateBool32(pNext_loc.dot(Field::useMaxFrameSize), structure->useMaxFrameSize); + } + } break; + + // Validation code for VkVideoEncodeH265GopRemainingFrameInfoKHR structure members + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: { // Covers + // VUID-VkVideoEncodeH265GopRemainingFrameInfoKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH265GopRemainingFrameInfoKHR); + VkVideoEncodeH265GopRemainingFrameInfoKHR* structure = (VkVideoEncodeH265GopRemainingFrameInfoKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::useGopRemainingFrames), structure->useGopRemainingFrames); + } + } break; + // Validation code for VkVideoDecodeH264ProfileInfoKHR structure members case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: { // Covers VUID-VkVideoDecodeH264ProfileInfoKHR-sType-sType if (is_const_param) { @@ -3023,7 +3317,6 @@ bool StatelessValidation::ValidatePnextStructContents(const Location& loc, const skip |= ValidateBool32(pNext_loc.dot(Field::presentId), structure->presentId); } } break; -#ifdef VK_ENABLE_BETA_EXTENSIONS // No Validation code for VkVideoEncodeCapabilitiesKHR structure members -- Covers // VUID-VkVideoEncodeCapabilitiesKHR-sType-sType @@ -3087,7 +3380,6 @@ bool StatelessValidation::ValidatePnextStructContents(const Location& loc, const // No Validation code for VkVideoEncodeQualityLevelInfoKHR structure members -- Covers // VUID-VkVideoEncodeQualityLevelInfoKHR-sType-sType -#endif // VK_ENABLE_BETA_EXTENSIONS // No Validation code for VkQueueFamilyCheckpointProperties2NV structure members -- Covers // VUID-VkQueueFamilyCheckpointProperties2NV-sType-sType @@ -3218,6 +3510,18 @@ bool StatelessValidation::ValidatePnextStructContents(const Location& loc, const // No Validation code for VkPhysicalDeviceCooperativeMatrixPropertiesKHR structure members -- Covers // VUID-VkPhysicalDeviceCooperativeMatrixPropertiesKHR-sType-sType + // Validation code for VkPhysicalDeviceVideoMaintenance1FeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceVideoMaintenance1FeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceVideoMaintenance1FeaturesKHR); + VkPhysicalDeviceVideoMaintenance1FeaturesKHR* structure = (VkPhysicalDeviceVideoMaintenance1FeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::videoMaintenance1), structure->videoMaintenance1); + } + } break; + + // No Validation code for VkVideoInlineQueryInfoKHR structure members -- Covers VUID-VkVideoInlineQueryInfoKHR-sType-sType + // No Validation code for VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR structure members -- Covers // VUID-VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR-sType-sType @@ -3257,6 +3561,29 @@ bool StatelessValidation::ValidatePnextStructContents(const Location& loc, const } } break; + // Validation code for VkPhysicalDeviceMaintenance6FeaturesKHR structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: { // Covers + // VUID-VkPhysicalDeviceMaintenance6FeaturesKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDeviceMaintenance6FeaturesKHR); + VkPhysicalDeviceMaintenance6FeaturesKHR* structure = (VkPhysicalDeviceMaintenance6FeaturesKHR*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::maintenance6), structure->maintenance6); + } + } break; + + // No Validation code for VkPhysicalDeviceMaintenance6PropertiesKHR structure members -- Covers + // VUID-VkPhysicalDeviceMaintenance6PropertiesKHR-sType-sType + + // Validation code for VkBindMemoryStatusKHR structure members + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: { // Covers VUID-VkBindMemoryStatusKHR-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkBindMemoryStatusKHR); + VkBindMemoryStatusKHR* structure = (VkBindMemoryStatusKHR*)header; + skip |= ValidateRequiredPointer(pNext_loc.dot(Field::pResult), structure->pResult, + "VUID-VkBindMemoryStatusKHR-pResult-parameter"); + } + } break; + // Validation code for VkDebugReportCallbackCreateInfoEXT structure members case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: { // Covers // VUID-VkDebugReportCallbackCreateInfoEXT-sType-sType @@ -3334,275 +3661,6 @@ bool StatelessValidation::ValidatePnextStructContents(const Location& loc, const "VUID-VkPipelineRasterizationStateStreamCreateInfoEXT-flags-zerobitmask"); } } break; -#ifdef VK_ENABLE_BETA_EXTENSIONS - - // No Validation code for VkVideoEncodeH264CapabilitiesEXT structure members -- Covers - // VUID-VkVideoEncodeH264CapabilitiesEXT-sType-sType - - // No Validation code for VkVideoEncodeH264QualityLevelPropertiesEXT structure members -- Covers - // VUID-VkVideoEncodeH264QualityLevelPropertiesEXT-sType-sType - - // Validation code for VkVideoEncodeH264SessionCreateInfoEXT structure members - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: { // Covers - // VUID-VkVideoEncodeH264SessionCreateInfoEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH264SessionCreateInfoEXT); - VkVideoEncodeH264SessionCreateInfoEXT* structure = (VkVideoEncodeH264SessionCreateInfoEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::useMaxLevelIdc), structure->useMaxLevelIdc); - } - } break; - - // No Validation code for VkVideoEncodeH264SessionParametersAddInfoEXT structure members -- Covers - // VUID-VkVideoEncodeH264SessionParametersAddInfoEXT-sType-sType - - // Validation code for VkVideoEncodeH264SessionParametersCreateInfoEXT structure members - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: { // Covers - // VUID-VkVideoEncodeH264SessionParametersCreateInfoEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH264SessionParametersCreateInfoEXT); - VkVideoEncodeH264SessionParametersCreateInfoEXT* structure = - (VkVideoEncodeH264SessionParametersCreateInfoEXT*)header; - skip |= ValidateStructType( - pNext_loc.dot(Field::pParametersAddInfo), "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT", - structure->pParametersAddInfo, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT, false, - "VUID-VkVideoEncodeH264SessionParametersCreateInfoEXT-pParametersAddInfo-parameter", - "VUID-VkVideoEncodeH264SessionParametersAddInfoEXT-sType-sType"); - - if (structure->pParametersAddInfo != nullptr) { - [[maybe_unused]] const Location pParametersAddInfo_loc = pNext_loc.dot(Field::pParametersAddInfo); - } - } - } break; - - // Validation code for VkVideoEncodeH264SessionParametersGetInfoEXT structure members - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT: { // Covers - // VUID-VkVideoEncodeH264SessionParametersGetInfoEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH264SessionParametersGetInfoEXT); - VkVideoEncodeH264SessionParametersGetInfoEXT* structure = (VkVideoEncodeH264SessionParametersGetInfoEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::writeStdSPS), structure->writeStdSPS); - - skip |= ValidateBool32(pNext_loc.dot(Field::writeStdPPS), structure->writeStdPPS); - } - } break; - - // No Validation code for VkVideoEncodeH264SessionParametersFeedbackInfoEXT structure members -- Covers - // VUID-VkVideoEncodeH264SessionParametersFeedbackInfoEXT-sType-sType - - // Validation code for VkVideoEncodeH264PictureInfoEXT structure members - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT: { // Covers VUID-VkVideoEncodeH264PictureInfoEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH264PictureInfoEXT); - VkVideoEncodeH264PictureInfoEXT* structure = (VkVideoEncodeH264PictureInfoEXT*)header; - skip |= ValidateStructTypeArray(pNext_loc.dot(Field::naluSliceEntryCount), pNext_loc.dot(Field::pNaluSliceEntries), - "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT", - structure->naluSliceEntryCount, structure->pNaluSliceEntries, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT, true, true, - "VUID-VkVideoEncodeH264NaluSliceInfoEXT-sType-sType", - "VUID-VkVideoEncodeH264PictureInfoEXT-pNaluSliceEntries-parameter", - "VUID-VkVideoEncodeH264PictureInfoEXT-naluSliceEntryCount-arraylength"); - - if (structure->pNaluSliceEntries != nullptr) { - for (uint32_t naluSliceEntryIndex = 0; naluSliceEntryIndex < structure->naluSliceEntryCount; - ++naluSliceEntryIndex) { - [[maybe_unused]] const Location pNaluSliceEntries_loc = - pNext_loc.dot(Field::pNaluSliceEntries, naluSliceEntryIndex); - skip |= ValidateRequiredPointer(pNaluSliceEntries_loc.dot(Field::pStdSliceHeader), - structure->pNaluSliceEntries[naluSliceEntryIndex].pStdSliceHeader, - "VUID-VkVideoEncodeH264NaluSliceInfoEXT-pStdSliceHeader-parameter"); - } - } - - skip |= ValidateRequiredPointer(pNext_loc.dot(Field::pStdPictureInfo), structure->pStdPictureInfo, - "VUID-VkVideoEncodeH264PictureInfoEXT-pStdPictureInfo-parameter"); - - skip |= ValidateBool32(pNext_loc.dot(Field::generatePrefixNalu), structure->generatePrefixNalu); - } - } break; - - // Validation code for VkVideoEncodeH264DpbSlotInfoEXT structure members - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: { // Covers VUID-VkVideoEncodeH264DpbSlotInfoEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH264DpbSlotInfoEXT); - VkVideoEncodeH264DpbSlotInfoEXT* structure = (VkVideoEncodeH264DpbSlotInfoEXT*)header; - skip |= ValidateRequiredPointer(pNext_loc.dot(Field::pStdReferenceInfo), structure->pStdReferenceInfo, - "VUID-VkVideoEncodeH264DpbSlotInfoEXT-pStdReferenceInfo-parameter"); - } - } break; - - // No Validation code for VkVideoEncodeH264ProfileInfoEXT structure members -- Covers - // VUID-VkVideoEncodeH264ProfileInfoEXT-sType-sType - - // Validation code for VkVideoEncodeH264RateControlInfoEXT structure members - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: { // Covers - // VUID-VkVideoEncodeH264RateControlInfoEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH264RateControlInfoEXT); - VkVideoEncodeH264RateControlInfoEXT* structure = (VkVideoEncodeH264RateControlInfoEXT*)header; - skip |= ValidateFlags(pNext_loc.dot(Field::flags), "VkVideoEncodeH264RateControlFlagBitsEXT", - AllVkVideoEncodeH264RateControlFlagBitsEXT, structure->flags, kOptionalFlags, - "VUID-VkVideoEncodeH264RateControlInfoEXT-flags-parameter"); - } - } break; - - // Validation code for VkVideoEncodeH264RateControlLayerInfoEXT structure members - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: { // Covers - // VUID-VkVideoEncodeH264RateControlLayerInfoEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH264RateControlLayerInfoEXT); - VkVideoEncodeH264RateControlLayerInfoEXT* structure = (VkVideoEncodeH264RateControlLayerInfoEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::useMinQp), structure->useMinQp); - - skip |= ValidateBool32(pNext_loc.dot(Field::useMaxQp), structure->useMaxQp); - - skip |= ValidateBool32(pNext_loc.dot(Field::useMaxFrameSize), structure->useMaxFrameSize); - } - } break; - - // Validation code for VkVideoEncodeH264GopRemainingFrameInfoEXT structure members - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT: { // Covers - // VUID-VkVideoEncodeH264GopRemainingFrameInfoEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH264GopRemainingFrameInfoEXT); - VkVideoEncodeH264GopRemainingFrameInfoEXT* structure = (VkVideoEncodeH264GopRemainingFrameInfoEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::useGopRemainingFrames), structure->useGopRemainingFrames); - } - } break; - - // No Validation code for VkVideoEncodeH265CapabilitiesEXT structure members -- Covers - // VUID-VkVideoEncodeH265CapabilitiesEXT-sType-sType - - // Validation code for VkVideoEncodeH265SessionCreateInfoEXT structure members - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: { // Covers - // VUID-VkVideoEncodeH265SessionCreateInfoEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH265SessionCreateInfoEXT); - VkVideoEncodeH265SessionCreateInfoEXT* structure = (VkVideoEncodeH265SessionCreateInfoEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::useMaxLevelIdc), structure->useMaxLevelIdc); - } - } break; - - // No Validation code for VkVideoEncodeH265QualityLevelPropertiesEXT structure members -- Covers - // VUID-VkVideoEncodeH265QualityLevelPropertiesEXT-sType-sType - - // No Validation code for VkVideoEncodeH265SessionParametersAddInfoEXT structure members -- Covers - // VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-sType-sType - - // Validation code for VkVideoEncodeH265SessionParametersCreateInfoEXT structure members - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: { // Covers - // VUID-VkVideoEncodeH265SessionParametersCreateInfoEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH265SessionParametersCreateInfoEXT); - VkVideoEncodeH265SessionParametersCreateInfoEXT* structure = - (VkVideoEncodeH265SessionParametersCreateInfoEXT*)header; - skip |= ValidateStructType( - pNext_loc.dot(Field::pParametersAddInfo), "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT", - structure->pParametersAddInfo, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT, false, - "VUID-VkVideoEncodeH265SessionParametersCreateInfoEXT-pParametersAddInfo-parameter", - "VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-sType-sType"); - - if (structure->pParametersAddInfo != nullptr) { - [[maybe_unused]] const Location pParametersAddInfo_loc = pNext_loc.dot(Field::pParametersAddInfo); - } - } - } break; - - // Validation code for VkVideoEncodeH265SessionParametersGetInfoEXT structure members - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT: { // Covers - // VUID-VkVideoEncodeH265SessionParametersGetInfoEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH265SessionParametersGetInfoEXT); - VkVideoEncodeH265SessionParametersGetInfoEXT* structure = (VkVideoEncodeH265SessionParametersGetInfoEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::writeStdVPS), structure->writeStdVPS); - - skip |= ValidateBool32(pNext_loc.dot(Field::writeStdSPS), structure->writeStdSPS); - - skip |= ValidateBool32(pNext_loc.dot(Field::writeStdPPS), structure->writeStdPPS); - } - } break; - - // No Validation code for VkVideoEncodeH265SessionParametersFeedbackInfoEXT structure members -- Covers - // VUID-VkVideoEncodeH265SessionParametersFeedbackInfoEXT-sType-sType - - // Validation code for VkVideoEncodeH265PictureInfoEXT structure members - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT: { // Covers VUID-VkVideoEncodeH265PictureInfoEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH265PictureInfoEXT); - VkVideoEncodeH265PictureInfoEXT* structure = (VkVideoEncodeH265PictureInfoEXT*)header; - skip |= ValidateStructTypeArray( - pNext_loc.dot(Field::naluSliceSegmentEntryCount), pNext_loc.dot(Field::pNaluSliceSegmentEntries), - "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT", structure->naluSliceSegmentEntryCount, - structure->pNaluSliceSegmentEntries, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT, true, - true, "VUID-VkVideoEncodeH265NaluSliceSegmentInfoEXT-sType-sType", - "VUID-VkVideoEncodeH265PictureInfoEXT-pNaluSliceSegmentEntries-parameter", - "VUID-VkVideoEncodeH265PictureInfoEXT-naluSliceSegmentEntryCount-arraylength"); - - if (structure->pNaluSliceSegmentEntries != nullptr) { - for (uint32_t naluSliceSegmentEntryIndex = 0; - naluSliceSegmentEntryIndex < structure->naluSliceSegmentEntryCount; ++naluSliceSegmentEntryIndex) { - [[maybe_unused]] const Location pNaluSliceSegmentEntries_loc = - pNext_loc.dot(Field::pNaluSliceSegmentEntries, naluSliceSegmentEntryIndex); - skip |= ValidateRequiredPointer( - pNaluSliceSegmentEntries_loc.dot(Field::pStdSliceSegmentHeader), - structure->pNaluSliceSegmentEntries[naluSliceSegmentEntryIndex].pStdSliceSegmentHeader, - "VUID-VkVideoEncodeH265NaluSliceSegmentInfoEXT-pStdSliceSegmentHeader-parameter"); - } - } - - skip |= ValidateRequiredPointer(pNext_loc.dot(Field::pStdPictureInfo), structure->pStdPictureInfo, - "VUID-VkVideoEncodeH265PictureInfoEXT-pStdPictureInfo-parameter"); - } - } break; - - // Validation code for VkVideoEncodeH265DpbSlotInfoEXT structure members - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: { // Covers VUID-VkVideoEncodeH265DpbSlotInfoEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH265DpbSlotInfoEXT); - VkVideoEncodeH265DpbSlotInfoEXT* structure = (VkVideoEncodeH265DpbSlotInfoEXT*)header; - skip |= ValidateRequiredPointer(pNext_loc.dot(Field::pStdReferenceInfo), structure->pStdReferenceInfo, - "VUID-VkVideoEncodeH265DpbSlotInfoEXT-pStdReferenceInfo-parameter"); - } - } break; - - // No Validation code for VkVideoEncodeH265ProfileInfoEXT structure members -- Covers - // VUID-VkVideoEncodeH265ProfileInfoEXT-sType-sType - - // Validation code for VkVideoEncodeH265RateControlInfoEXT structure members - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: { // Covers - // VUID-VkVideoEncodeH265RateControlInfoEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH265RateControlInfoEXT); - VkVideoEncodeH265RateControlInfoEXT* structure = (VkVideoEncodeH265RateControlInfoEXT*)header; - skip |= ValidateFlags(pNext_loc.dot(Field::flags), "VkVideoEncodeH265RateControlFlagBitsEXT", - AllVkVideoEncodeH265RateControlFlagBitsEXT, structure->flags, kOptionalFlags, - "VUID-VkVideoEncodeH265RateControlInfoEXT-flags-parameter"); - } - } break; - - // Validation code for VkVideoEncodeH265RateControlLayerInfoEXT structure members - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: { // Covers - // VUID-VkVideoEncodeH265RateControlLayerInfoEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH265RateControlLayerInfoEXT); - VkVideoEncodeH265RateControlLayerInfoEXT* structure = (VkVideoEncodeH265RateControlLayerInfoEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::useMinQp), structure->useMinQp); - - skip |= ValidateBool32(pNext_loc.dot(Field::useMaxQp), structure->useMaxQp); - - skip |= ValidateBool32(pNext_loc.dot(Field::useMaxFrameSize), structure->useMaxFrameSize); - } - } break; - - // Validation code for VkVideoEncodeH265GopRemainingFrameInfoEXT structure members - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT: { // Covers - // VUID-VkVideoEncodeH265GopRemainingFrameInfoEXT-sType-sType - if (is_const_param) { - [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkVideoEncodeH265GopRemainingFrameInfoEXT); - VkVideoEncodeH265GopRemainingFrameInfoEXT* structure = (VkVideoEncodeH265GopRemainingFrameInfoEXT*)header; - skip |= ValidateBool32(pNext_loc.dot(Field::useGopRemainingFrames), structure->useGopRemainingFrames); - } - } break; -#endif // VK_ENABLE_BETA_EXTENSIONS // No Validation code for VkTextureLODGatherFormatPropertiesAMD structure members -- Covers // VUID-VkTextureLODGatherFormatPropertiesAMD-sType-sType @@ -6347,6 +6405,12 @@ bool StatelessValidation::ValidatePnextStructContents(const Location& loc, const "VUID-VkRenderPassStripeInfoARM-sType-sType", "VUID-VkRenderPassStripeBeginInfoARM-pStripeInfos-parameter", "VUID-VkRenderPassStripeBeginInfoARM-stripeInfoCount-arraylength"); + + if (structure->pStripeInfos != nullptr) { + for (uint32_t stripeInfoIndex = 0; stripeInfoIndex < structure->stripeInfoCount; ++stripeInfoIndex) { + [[maybe_unused]] const Location pStripeInfos_loc = pNext_loc.dot(Field::pStripeInfos, stripeInfoIndex); + } + } } } break; @@ -7019,6 +7083,19 @@ bool StatelessValidation::ValidatePnextStructContents(const Location& loc, const } } break; + // Validation code for VkPhysicalDevicePerStageDescriptorSetFeaturesNV structure members + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: { // Covers + // VUID-VkPhysicalDevicePerStageDescriptorSetFeaturesNV-sType-sType + if (is_const_param) { + [[maybe_unused]] const Location pNext_loc = loc.pNext(Struct::VkPhysicalDevicePerStageDescriptorSetFeaturesNV); + VkPhysicalDevicePerStageDescriptorSetFeaturesNV* structure = + (VkPhysicalDevicePerStageDescriptorSetFeaturesNV*)header; + skip |= ValidateBool32(pNext_loc.dot(Field::perStageDescriptorSet), structure->perStageDescriptorSet); + + skip |= ValidateBool32(pNext_loc.dot(Field::dynamicPipelineLayout), structure->dynamicPipelineLayout); + } + } break; + // Validation code for VkPhysicalDeviceImageProcessing2FeaturesQCOM structure members case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: { // Covers // VUID-VkPhysicalDeviceImageProcessing2FeaturesQCOM-sType-sType @@ -7581,6 +7658,7 @@ bool StatelessValidation::PreCallValidateCreateDevice(VkPhysicalDevice physicalD VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT, @@ -7596,6 +7674,7 @@ bool StatelessValidation::PreCallValidateCreateDevice(VkPhysicalDevice physicalD VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, @@ -7664,6 +7743,7 @@ bool StatelessValidation::PreCallValidateCreateDevice(VkPhysicalDevice physicalD VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, @@ -8716,8 +8796,8 @@ bool StatelessValidation::PreCallValidateCreateQueryPool(VkDevice device, const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR}; @@ -9471,10 +9551,6 @@ bool StatelessValidation::PreCallValidateCreateGraphicsPipelines(VkDevice device allowed_structs_VkGraphicsPipelineCreateInfo.data(), GeneratedVulkanHeaderVersion, "VUID-VkGraphicsPipelineCreateInfo-pNext-pNext", "VUID-VkGraphicsPipelineCreateInfo-sType-unique", false, true); - skip |= ValidateFlags(pCreateInfos_loc.dot(Field::flags), "VkPipelineCreateFlagBits", AllVkPipelineCreateFlagBits, - pCreateInfos[createInfoIndex].flags, kOptionalFlags, - "VUID-VkGraphicsPipelineCreateInfo-flags-parameter"); - skip |= ValidateStructType( pCreateInfos_loc.dot(Field::pDynamicState), "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO", pCreateInfos[createInfoIndex].pDynamicState, VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, false, @@ -9696,8 +9772,8 @@ bool StatelessValidation::PreCallValidateCreatePipelineLayout(VkDevice device, c "VUID-vkCreatePipelineLayout-pCreateInfo-parameter", "VUID-VkPipelineLayoutCreateInfo-sType-sType"); if (pCreateInfo != nullptr) { [[maybe_unused]] const Location pCreateInfo_loc = loc.dot(Field::pCreateInfo); - skip |= ValidateStructPnext(pCreateInfo_loc, pCreateInfo->pNext, 0, nullptr, GeneratedVulkanHeaderVersion, - "VUID-VkPipelineLayoutCreateInfo-pNext-pNext", kVUIDUndefined, false, true); + skip |= ValidateStructPnext(pCreateInfo_loc, pCreateInfo->pNext, 0, nullptr, GeneratedVulkanHeaderVersion, kVUIDUndefined, + kVUIDUndefined, false, true); skip |= ValidateFlags(pCreateInfo_loc.dot(Field::flags), "VkPipelineLayoutCreateFlagBits", AllVkPipelineLayoutCreateFlagBits, @@ -10845,7 +10921,6 @@ bool StatelessValidation::PreCallValidateCmdBindIndexBuffer(VkCommandBuffer comm VkIndexType indexType, const ErrorObject& error_obj) const { bool skip = false; [[maybe_unused]] const Location loc = error_obj.location; - skip |= ValidateRequiredHandle(loc.dot(Field::buffer), buffer); skip |= ValidateRangedEnum(loc.dot(Field::indexType), "VkIndexType", indexType, "VUID-vkCmdBindIndexBuffer-indexType-parameter"); if (!skip) skip |= manual_PreCallValidateCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType, error_obj); @@ -11545,7 +11620,8 @@ bool StatelessValidation::PreCallValidateBindBufferMemory2(VkDevice device, uint if (pBindInfos != nullptr) { for (uint32_t bindInfoIndex = 0; bindInfoIndex < bindInfoCount; ++bindInfoIndex) { [[maybe_unused]] const Location pBindInfos_loc = loc.dot(Field::pBindInfos, bindInfoIndex); - constexpr std::array allowed_structs_VkBindBufferMemoryInfo = {VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO}; + constexpr std::array allowed_structs_VkBindBufferMemoryInfo = {VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, + VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR}; skip |= ValidateStructPnext( pBindInfos_loc, pBindInfos[bindInfoIndex].pNext, allowed_structs_VkBindBufferMemoryInfo.size(), @@ -11572,9 +11648,9 @@ bool StatelessValidation::PreCallValidateBindImageMemory2(VkDevice device, uint3 if (pBindInfos != nullptr) { for (uint32_t bindInfoIndex = 0; bindInfoIndex < bindInfoCount; ++bindInfoIndex) { [[maybe_unused]] const Location pBindInfos_loc = loc.dot(Field::pBindInfos, bindInfoIndex); - constexpr std::array allowed_structs_VkBindImageMemoryInfo = {VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR, - VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO}; + constexpr std::array allowed_structs_VkBindImageMemoryInfo = { + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR, + VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR}; skip |= ValidateStructPnext(pBindInfos_loc, pBindInfos[bindInfoIndex].pNext, allowed_structs_VkBindImageMemoryInfo.size(), allowed_structs_VkBindImageMemoryInfo.data(), @@ -11814,6 +11890,7 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceProperties2(VkPhysical VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV, @@ -15630,8 +15707,8 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceVideoCapabilitiesKHR(V [[maybe_unused]] const Location pVideoProfile_loc = loc.dot(Field::pVideoProfile); constexpr std::array allowed_structs_VkVideoProfileInfoKHR = { VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR, - VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT, VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR}; + VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR}; skip |= ValidateStructPnext(pVideoProfile_loc, pVideoProfile->pNext, allowed_structs_VkVideoProfileInfoKHR.size(), allowed_structs_VkVideoProfileInfoKHR.data(), GeneratedVulkanHeaderVersion, kVUIDUndefined, @@ -15665,7 +15742,7 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceVideoCapabilitiesKHR(V constexpr std::array allowed_structs_VkVideoCapabilitiesKHR = { VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT}; + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR}; skip |= ValidateStructPnext(pCapabilities_loc, pCapabilities->pNext, allowed_structs_VkVideoCapabilitiesKHR.size(), @@ -15731,8 +15808,8 @@ bool StatelessValidation::PreCallValidateCreateVideoSessionKHR(VkDevice device, if (pCreateInfo != nullptr) { [[maybe_unused]] const Location pCreateInfo_loc = loc.dot(Field::pCreateInfo); constexpr std::array allowed_structs_VkVideoSessionCreateInfoKHR = { - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT}; + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR}; skip |= ValidateStructPnext(pCreateInfo_loc, pCreateInfo->pNext, allowed_structs_VkVideoSessionCreateInfoKHR.size(), allowed_structs_VkVideoSessionCreateInfoKHR.data(), GeneratedVulkanHeaderVersion, @@ -15752,8 +15829,8 @@ bool StatelessValidation::PreCallValidateCreateVideoSessionKHR(VkDevice device, [[maybe_unused]] const Location pVideoProfile_loc = pCreateInfo_loc.dot(Field::pVideoProfile); constexpr std::array allowed_structs_VkVideoProfileInfoKHR = { VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR, - VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT, VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR}; + VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR}; skip |= ValidateStructPnext(pVideoProfile_loc, pCreateInfo->pVideoProfile->pNext, allowed_structs_VkVideoProfileInfoKHR.size(), allowed_structs_VkVideoProfileInfoKHR.data(), @@ -15931,8 +16008,8 @@ bool StatelessValidation::PreCallValidateCreateVideoSessionParametersKHR(VkDevic constexpr std::array allowed_structs_VkVideoSessionParametersCreateInfoKHR = { VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR}; skip |= @@ -15993,8 +16070,8 @@ bool StatelessValidation::PreCallValidateUpdateVideoSessionParametersKHR(VkDevic constexpr std::array allowed_structs_VkVideoSessionParametersUpdateInfoKHR = { VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT}; + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR}; skip |= ValidateStructPnext(pUpdateInfo_loc, pUpdateInfo->pNext, allowed_structs_VkVideoSessionParametersUpdateInfoKHR.size(), @@ -16052,10 +16129,10 @@ bool StatelessValidation::PreCallValidateCmdBeginVideoCodingKHR(VkCommandBuffer if (pBeginInfo != nullptr) { [[maybe_unused]] const Location pBeginInfo_loc = loc.dot(Field::pBeginInfo); constexpr std::array allowed_structs_VkVideoBeginCodingInfoKHR = { - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT, VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR}; + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR}; skip |= ValidateStructPnext(pBeginInfo_loc, pBeginInfo->pNext, allowed_structs_VkVideoBeginCodingInfoKHR.size(), allowed_structs_VkVideoBeginCodingInfoKHR.data(), GeneratedVulkanHeaderVersion, @@ -16079,7 +16156,7 @@ bool StatelessValidation::PreCallValidateCmdBeginVideoCodingKHR(VkCommandBuffer pBeginInfo_loc.dot(Field::pReferenceSlots, referenceSlotIndex); constexpr std::array allowed_structs_VkVideoReferenceSlotInfoKHR = { VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT}; + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR}; skip |= ValidateStructPnext(pReferenceSlots_loc, pBeginInfo->pReferenceSlots[referenceSlotIndex].pNext, allowed_structs_VkVideoReferenceSlotInfoKHR.size(), @@ -16148,7 +16225,7 @@ bool StatelessValidation::PreCallValidateCmdControlVideoCodingKHR(VkCommandBuffe if (pCodingControlInfo != nullptr) { [[maybe_unused]] const Location pCodingControlInfo_loc = loc.dot(Field::pCodingControlInfo); constexpr std::array allowed_structs_VkVideoCodingControlInfoKHR = { - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR}; skip |= ValidateStructPnext( @@ -16175,7 +16252,8 @@ bool StatelessValidation::PreCallValidateCmdDecodeVideoKHR(VkCommandBuffer comma if (pDecodeInfo != nullptr) { [[maybe_unused]] const Location pDecodeInfo_loc = loc.dot(Field::pDecodeInfo); constexpr std::array allowed_structs_VkVideoDecodeInfoKHR = {VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR}; + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR, + VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR}; skip |= ValidateStructPnext(pDecodeInfo_loc, pDecodeInfo->pNext, allowed_structs_VkVideoDecodeInfoKHR.size(), allowed_structs_VkVideoDecodeInfoKHR.data(), GeneratedVulkanHeaderVersion, @@ -16211,7 +16289,7 @@ bool StatelessValidation::PreCallValidateCmdDecodeVideoKHR(VkCommandBuffer comma [[maybe_unused]] const Location pSetupReferenceSlot_loc = pDecodeInfo_loc.dot(Field::pSetupReferenceSlot); constexpr std::array allowed_structs_VkVideoReferenceSlotInfoKHR = { VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT}; + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR}; skip |= ValidateStructPnext(pSetupReferenceSlot_loc, pDecodeInfo->pSetupReferenceSlot->pNext, allowed_structs_VkVideoReferenceSlotInfoKHR.size(), @@ -16251,7 +16329,7 @@ bool StatelessValidation::PreCallValidateCmdDecodeVideoKHR(VkCommandBuffer comma pDecodeInfo_loc.dot(Field::pReferenceSlots, referenceSlotIndex); constexpr std::array allowed_structs_VkVideoReferenceSlotInfoKHR = { VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT}; + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR}; skip |= ValidateStructPnext(pReferenceSlots_loc, pDecodeInfo->pReferenceSlots[referenceSlotIndex].pNext, allowed_structs_VkVideoReferenceSlotInfoKHR.size(), @@ -17705,7 +17783,6 @@ bool StatelessValidation::PreCallValidateUnmapMemory2KHR(VkDevice device, const return skip; } -#ifdef VK_ENABLE_BETA_EXTENSIONS bool StatelessValidation::PreCallValidateGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties, const ErrorObject& error_obj) const { @@ -17730,8 +17807,8 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceVideoEncodeQualityLeve [[maybe_unused]] const Location pVideoProfile_loc = pQualityLevelInfo_loc.dot(Field::pVideoProfile); constexpr std::array allowed_structs_VkVideoProfileInfoKHR = { VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR, - VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT, VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR}; + VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR}; skip |= ValidateStructPnext(pVideoProfile_loc, pQualityLevelInfo->pVideoProfile->pNext, allowed_structs_VkVideoProfileInfoKHR.size(), allowed_structs_VkVideoProfileInfoKHR.data(), @@ -17765,8 +17842,8 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceVideoEncodeQualityLeve if (pQualityLevelProperties != nullptr) { [[maybe_unused]] const Location pQualityLevelProperties_loc = loc.dot(Field::pQualityLevelProperties); constexpr std::array allowed_structs_VkVideoEncodeQualityLevelPropertiesKHR = { - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT}; + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR}; skip |= ValidateStructPnext(pQualityLevelProperties_loc, pQualityLevelProperties->pNext, allowed_structs_VkVideoEncodeQualityLevelPropertiesKHR.size(), @@ -17792,8 +17869,8 @@ bool StatelessValidation::PreCallValidateGetEncodedVideoSessionParametersKHR( if (pVideoSessionParametersInfo != nullptr) { [[maybe_unused]] const Location pVideoSessionParametersInfo_loc = loc.dot(Field::pVideoSessionParametersInfo); constexpr std::array allowed_structs_VkVideoEncodeSessionParametersGetInfoKHR = { - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT}; + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR}; skip |= ValidateStructPnext(pVideoSessionParametersInfo_loc, pVideoSessionParametersInfo->pNext, allowed_structs_VkVideoEncodeSessionParametersGetInfoKHR.size(), @@ -17811,8 +17888,8 @@ bool StatelessValidation::PreCallValidateGetEncodedVideoSessionParametersKHR( if (pFeedbackInfo != nullptr) { [[maybe_unused]] const Location pFeedbackInfo_loc = loc.dot(Field::pFeedbackInfo); constexpr std::array allowed_structs_VkVideoEncodeSessionParametersFeedbackInfoKHR = { - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT}; + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR}; skip |= ValidateStructPnext(pFeedbackInfo_loc, pFeedbackInfo->pNext, allowed_structs_VkVideoEncodeSessionParametersFeedbackInfoKHR.size(), @@ -17835,8 +17912,9 @@ bool StatelessValidation::PreCallValidateCmdEncodeVideoKHR(VkCommandBuffer comma "VUID-VkVideoEncodeInfoKHR-sType-sType"); if (pEncodeInfo != nullptr) { [[maybe_unused]] const Location pEncodeInfo_loc = loc.dot(Field::pEncodeInfo); - constexpr std::array allowed_structs_VkVideoEncodeInfoKHR = {VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT}; + constexpr std::array allowed_structs_VkVideoEncodeInfoKHR = {VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR, + VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR}; skip |= ValidateStructPnext(pEncodeInfo_loc, pEncodeInfo->pNext, allowed_structs_VkVideoEncodeInfoKHR.size(), allowed_structs_VkVideoEncodeInfoKHR.data(), GeneratedVulkanHeaderVersion, @@ -17872,7 +17950,7 @@ bool StatelessValidation::PreCallValidateCmdEncodeVideoKHR(VkCommandBuffer comma [[maybe_unused]] const Location pSetupReferenceSlot_loc = pEncodeInfo_loc.dot(Field::pSetupReferenceSlot); constexpr std::array allowed_structs_VkVideoReferenceSlotInfoKHR = { VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT}; + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR}; skip |= ValidateStructPnext(pSetupReferenceSlot_loc, pEncodeInfo->pSetupReferenceSlot->pNext, allowed_structs_VkVideoReferenceSlotInfoKHR.size(), @@ -17912,7 +17990,7 @@ bool StatelessValidation::PreCallValidateCmdEncodeVideoKHR(VkCommandBuffer comma pEncodeInfo_loc.dot(Field::pReferenceSlots, referenceSlotIndex); constexpr std::array allowed_structs_VkVideoReferenceSlotInfoKHR = { VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT}; + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR}; skip |= ValidateStructPnext(pReferenceSlots_loc, pEncodeInfo->pReferenceSlots[referenceSlotIndex].pNext, allowed_structs_VkVideoReferenceSlotInfoKHR.size(), @@ -17947,7 +18025,6 @@ bool StatelessValidation::PreCallValidateCmdEncodeVideoKHR(VkCommandBuffer comma } return skip; } -#endif // VK_ENABLE_BETA_EXTENSIONS bool StatelessValidation::PreCallValidateCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo, @@ -18147,7 +18224,6 @@ bool StatelessValidation::PreCallValidateCmdBindIndexBuffer2KHR(VkCommandBuffer bool skip = false; [[maybe_unused]] const Location loc = error_obj.location; if (!IsExtEnabled(device_extensions.vk_khr_maintenance5)) skip |= OutputExtensionError(loc, "VK_KHR_maintenance5"); - skip |= ValidateRequiredHandle(loc.dot(Field::buffer), buffer); skip |= ValidateRangedEnum(loc.dot(Field::indexType), "VkIndexType", indexType, "VUID-vkCmdBindIndexBuffer2KHR-indexType-parameter"); if (!skip) skip |= manual_PreCallValidateCmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType, error_obj); @@ -18380,6 +18456,233 @@ bool StatelessValidation::PreCallValidateGetCalibratedTimestampsKHR(VkDevice dev return skip; } +bool StatelessValidation::PreCallValidateCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo, + const ErrorObject& error_obj) const { + bool skip = false; + [[maybe_unused]] const Location loc = error_obj.location; + if (!IsExtEnabled(device_extensions.vk_khr_maintenance6)) skip |= OutputExtensionError(loc, "VK_KHR_maintenance6"); + skip |= ValidateStructType(loc.dot(Field::pBindDescriptorSetsInfo), "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR", + pBindDescriptorSetsInfo, VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR, true, + "VUID-vkCmdBindDescriptorSets2KHR-pBindDescriptorSetsInfo-parameter", + "VUID-VkBindDescriptorSetsInfoKHR-sType-sType"); + if (pBindDescriptorSetsInfo != nullptr) { + [[maybe_unused]] const Location pBindDescriptorSetsInfo_loc = loc.dot(Field::pBindDescriptorSetsInfo); + constexpr std::array allowed_structs_VkBindDescriptorSetsInfoKHR = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO}; + + skip |= ValidateStructPnext( + pBindDescriptorSetsInfo_loc, pBindDescriptorSetsInfo->pNext, allowed_structs_VkBindDescriptorSetsInfoKHR.size(), + allowed_structs_VkBindDescriptorSetsInfoKHR.data(), GeneratedVulkanHeaderVersion, + "VUID-VkBindDescriptorSetsInfoKHR-pNext-pNext", "VUID-VkBindDescriptorSetsInfoKHR-sType-unique", false, true); + + skip |= ValidateFlags(pBindDescriptorSetsInfo_loc.dot(Field::stageFlags), "VkShaderStageFlagBits", AllVkShaderStageFlagBits, + pBindDescriptorSetsInfo->stageFlags, kRequiredFlags, + "VUID-VkBindDescriptorSetsInfoKHR-stageFlags-parameter", + "VUID-VkBindDescriptorSetsInfoKHR-stageFlags-requiredbitmask"); + + skip |= ValidateHandleArray( + pBindDescriptorSetsInfo_loc.dot(Field::descriptorSetCount), pBindDescriptorSetsInfo_loc.dot(Field::pDescriptorSets), + pBindDescriptorSetsInfo->descriptorSetCount, pBindDescriptorSetsInfo->pDescriptorSets, true, true, kVUIDUndefined); + } + return skip; +} + +bool StatelessValidation::PreCallValidateCmdPushConstants2KHR(VkCommandBuffer commandBuffer, + const VkPushConstantsInfoKHR* pPushConstantsInfo, + const ErrorObject& error_obj) const { + bool skip = false; + [[maybe_unused]] const Location loc = error_obj.location; + if (!IsExtEnabled(device_extensions.vk_khr_maintenance6)) skip |= OutputExtensionError(loc, "VK_KHR_maintenance6"); + skip |= + ValidateStructType(loc.dot(Field::pPushConstantsInfo), "VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR", pPushConstantsInfo, + VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR, true, + "VUID-vkCmdPushConstants2KHR-pPushConstantsInfo-parameter", "VUID-VkPushConstantsInfoKHR-sType-sType"); + if (pPushConstantsInfo != nullptr) { + [[maybe_unused]] const Location pPushConstantsInfo_loc = loc.dot(Field::pPushConstantsInfo); + constexpr std::array allowed_structs_VkPushConstantsInfoKHR = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO}; + + skip |= + ValidateStructPnext(pPushConstantsInfo_loc, pPushConstantsInfo->pNext, allowed_structs_VkPushConstantsInfoKHR.size(), + allowed_structs_VkPushConstantsInfoKHR.data(), GeneratedVulkanHeaderVersion, + "VUID-VkPushConstantsInfoKHR-pNext-pNext", "VUID-VkPushConstantsInfoKHR-sType-unique", false, true); + + skip |= ValidateFlags(pPushConstantsInfo_loc.dot(Field::stageFlags), "VkShaderStageFlagBits", AllVkShaderStageFlagBits, + pPushConstantsInfo->stageFlags, kRequiredFlags, "VUID-VkPushConstantsInfoKHR-stageFlags-parameter", + "VUID-VkPushConstantsInfoKHR-stageFlags-requiredbitmask"); + + skip |= ValidateArray(pPushConstantsInfo_loc.dot(Field::size), pPushConstantsInfo_loc.dot(Field::pValues), + pPushConstantsInfo->size, &pPushConstantsInfo->pValues, true, true, + "VUID-VkPushConstantsInfoKHR-size-arraylength", "VUID-VkPushConstantsInfoKHR-pValues-parameter"); + } + return skip; +} + +bool StatelessValidation::PreCallValidateCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo, + const ErrorObject& error_obj) const { + bool skip = false; + [[maybe_unused]] const Location loc = error_obj.location; + if (!IsExtEnabled(device_extensions.vk_khr_maintenance6)) skip |= OutputExtensionError(loc, "VK_KHR_maintenance6"); + skip |= ValidateStructType(loc.dot(Field::pPushDescriptorSetInfo), "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR", + pPushDescriptorSetInfo, VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR, true, + "VUID-vkCmdPushDescriptorSet2KHR-pPushDescriptorSetInfo-parameter", + "VUID-VkPushDescriptorSetInfoKHR-sType-sType"); + if (pPushDescriptorSetInfo != nullptr) { + [[maybe_unused]] const Location pPushDescriptorSetInfo_loc = loc.dot(Field::pPushDescriptorSetInfo); + constexpr std::array allowed_structs_VkPushDescriptorSetInfoKHR = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO}; + + skip |= ValidateStructPnext( + pPushDescriptorSetInfo_loc, pPushDescriptorSetInfo->pNext, allowed_structs_VkPushDescriptorSetInfoKHR.size(), + allowed_structs_VkPushDescriptorSetInfoKHR.data(), GeneratedVulkanHeaderVersion, + "VUID-VkPushDescriptorSetInfoKHR-pNext-pNext", "VUID-VkPushDescriptorSetInfoKHR-sType-unique", false, true); + + skip |= ValidateFlags(pPushDescriptorSetInfo_loc.dot(Field::stageFlags), "VkShaderStageFlagBits", AllVkShaderStageFlagBits, + pPushDescriptorSetInfo->stageFlags, kRequiredFlags, + "VUID-VkPushDescriptorSetInfoKHR-stageFlags-parameter", + "VUID-VkPushDescriptorSetInfoKHR-stageFlags-requiredbitmask"); + + skip |= ValidateStructTypeArray( + pPushDescriptorSetInfo_loc.dot(Field::descriptorWriteCount), pPushDescriptorSetInfo_loc.dot(Field::pDescriptorWrites), + "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET", pPushDescriptorSetInfo->descriptorWriteCount, + pPushDescriptorSetInfo->pDescriptorWrites, VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, true, true, + "VUID-VkWriteDescriptorSet-sType-sType", "VUID-VkPushDescriptorSetInfoKHR-pDescriptorWrites-parameter", + "VUID-VkPushDescriptorSetInfoKHR-descriptorWriteCount-arraylength"); + + if (pPushDescriptorSetInfo->pDescriptorWrites != nullptr) { + for (uint32_t descriptorWriteIndex = 0; descriptorWriteIndex < pPushDescriptorSetInfo->descriptorWriteCount; + ++descriptorWriteIndex) { + [[maybe_unused]] const Location pDescriptorWrites_loc = + pPushDescriptorSetInfo_loc.dot(Field::pDescriptorWrites, descriptorWriteIndex); + constexpr std::array allowed_structs_VkWriteDescriptorSet = { + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK}; + + skip |= ValidateStructPnext( + pDescriptorWrites_loc, pPushDescriptorSetInfo->pDescriptorWrites[descriptorWriteIndex].pNext, + allowed_structs_VkWriteDescriptorSet.size(), allowed_structs_VkWriteDescriptorSet.data(), + GeneratedVulkanHeaderVersion, "VUID-VkWriteDescriptorSet-pNext-pNext", "VUID-VkWriteDescriptorSet-sType-unique", + false, true); + + skip |= ValidateRangedEnum(pDescriptorWrites_loc.dot(Field::descriptorType), "VkDescriptorType", + pPushDescriptorSetInfo->pDescriptorWrites[descriptorWriteIndex].descriptorType, + "VUID-VkWriteDescriptorSet-descriptorType-parameter"); + + skip |= ValidateArray(pDescriptorWrites_loc.dot(Field::descriptorCount), loc, + pPushDescriptorSetInfo->pDescriptorWrites[descriptorWriteIndex].descriptorCount, + &pPushDescriptorSetInfo->pDescriptorWrites[descriptorWriteIndex].pImageInfo, true, false, + "VUID-VkWriteDescriptorSet-descriptorCount-arraylength", kVUIDUndefined); + } + } + } + return skip; +} + +bool StatelessValidation::PreCallValidateCmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo, + const ErrorObject& error_obj) const { + bool skip = false; + [[maybe_unused]] const Location loc = error_obj.location; + if (!IsExtEnabled(device_extensions.vk_khr_maintenance6)) skip |= OutputExtensionError(loc, "VK_KHR_maintenance6"); + skip |= ValidateStructType(loc.dot(Field::pPushDescriptorSetWithTemplateInfo), + "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR", pPushDescriptorSetWithTemplateInfo, + VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR, true, + "VUID-vkCmdPushDescriptorSetWithTemplate2KHR-pPushDescriptorSetWithTemplateInfo-parameter", + "VUID-VkPushDescriptorSetWithTemplateInfoKHR-sType-sType"); + if (pPushDescriptorSetWithTemplateInfo != nullptr) { + [[maybe_unused]] const Location pPushDescriptorSetWithTemplateInfo_loc = loc.dot(Field::pPushDescriptorSetWithTemplateInfo); + constexpr std::array allowed_structs_VkPushDescriptorSetWithTemplateInfoKHR = { + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO}; + + skip |= ValidateStructPnext(pPushDescriptorSetWithTemplateInfo_loc, pPushDescriptorSetWithTemplateInfo->pNext, + allowed_structs_VkPushDescriptorSetWithTemplateInfoKHR.size(), + allowed_structs_VkPushDescriptorSetWithTemplateInfoKHR.data(), GeneratedVulkanHeaderVersion, + "VUID-VkPushDescriptorSetWithTemplateInfoKHR-pNext-pNext", + "VUID-VkPushDescriptorSetWithTemplateInfoKHR-sType-unique", false, true); + + skip |= ValidateRequiredHandle(pPushDescriptorSetWithTemplateInfo_loc.dot(Field::descriptorUpdateTemplate), + pPushDescriptorSetWithTemplateInfo->descriptorUpdateTemplate); + + skip |= ValidateRequiredPointer(pPushDescriptorSetWithTemplateInfo_loc.dot(Field::pData), + pPushDescriptorSetWithTemplateInfo->pData, + "VUID-VkPushDescriptorSetWithTemplateInfoKHR-pData-parameter"); + } + return skip; +} + +bool StatelessValidation::PreCallValidateCmdSetDescriptorBufferOffsets2EXT( + VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo, + const ErrorObject& error_obj) const { + bool skip = false; + [[maybe_unused]] const Location loc = error_obj.location; + if (!IsExtEnabled(device_extensions.vk_khr_maintenance6)) skip |= OutputExtensionError(loc, "VK_KHR_maintenance6"); + skip |= ValidateStructType(loc.dot(Field::pSetDescriptorBufferOffsetsInfo), + "VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT", pSetDescriptorBufferOffsetsInfo, + VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT, true, + "VUID-vkCmdSetDescriptorBufferOffsets2EXT-pSetDescriptorBufferOffsetsInfo-parameter", + "VUID-VkSetDescriptorBufferOffsetsInfoEXT-sType-sType"); + if (pSetDescriptorBufferOffsetsInfo != nullptr) { + [[maybe_unused]] const Location pSetDescriptorBufferOffsetsInfo_loc = loc.dot(Field::pSetDescriptorBufferOffsetsInfo); + constexpr std::array allowed_structs_VkSetDescriptorBufferOffsetsInfoEXT = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO}; + + skip |= ValidateStructPnext(pSetDescriptorBufferOffsetsInfo_loc, pSetDescriptorBufferOffsetsInfo->pNext, + allowed_structs_VkSetDescriptorBufferOffsetsInfoEXT.size(), + allowed_structs_VkSetDescriptorBufferOffsetsInfoEXT.data(), GeneratedVulkanHeaderVersion, + "VUID-VkSetDescriptorBufferOffsetsInfoEXT-pNext-pNext", + "VUID-VkSetDescriptorBufferOffsetsInfoEXT-sType-unique", false, true); + + skip |= ValidateFlags(pSetDescriptorBufferOffsetsInfo_loc.dot(Field::stageFlags), "VkShaderStageFlagBits", + AllVkShaderStageFlagBits, pSetDescriptorBufferOffsetsInfo->stageFlags, kRequiredFlags, + "VUID-VkSetDescriptorBufferOffsetsInfoEXT-stageFlags-parameter", + "VUID-VkSetDescriptorBufferOffsetsInfoEXT-stageFlags-requiredbitmask"); + + skip |= ValidateArray(pSetDescriptorBufferOffsetsInfo_loc.dot(Field::setCount), + pSetDescriptorBufferOffsetsInfo_loc.dot(Field::pBufferIndices), + pSetDescriptorBufferOffsetsInfo->setCount, &pSetDescriptorBufferOffsetsInfo->pBufferIndices, true, + true, "VUID-VkSetDescriptorBufferOffsetsInfoEXT-setCount-arraylength", + "VUID-VkSetDescriptorBufferOffsetsInfoEXT-pBufferIndices-parameter"); + + skip |= ValidateArray(pSetDescriptorBufferOffsetsInfo_loc.dot(Field::setCount), + pSetDescriptorBufferOffsetsInfo_loc.dot(Field::pOffsets), pSetDescriptorBufferOffsetsInfo->setCount, + &pSetDescriptorBufferOffsetsInfo->pOffsets, true, true, + "VUID-VkSetDescriptorBufferOffsetsInfoEXT-setCount-arraylength", + "VUID-VkSetDescriptorBufferOffsetsInfoEXT-pOffsets-parameter"); + } + return skip; +} + +bool StatelessValidation::PreCallValidateCmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo, + const ErrorObject& error_obj) const { + bool skip = false; + [[maybe_unused]] const Location loc = error_obj.location; + if (!IsExtEnabled(device_extensions.vk_khr_maintenance6)) skip |= OutputExtensionError(loc, "VK_KHR_maintenance6"); + skip |= ValidateStructType( + loc.dot(Field::pBindDescriptorBufferEmbeddedSamplersInfo), + "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT", pBindDescriptorBufferEmbeddedSamplersInfo, + VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT, true, + "VUID-vkCmdBindDescriptorBufferEmbeddedSamplers2EXT-pBindDescriptorBufferEmbeddedSamplersInfo-parameter", + "VUID-VkBindDescriptorBufferEmbeddedSamplersInfoEXT-sType-sType"); + if (pBindDescriptorBufferEmbeddedSamplersInfo != nullptr) { + [[maybe_unused]] const Location pBindDescriptorBufferEmbeddedSamplersInfo_loc = + loc.dot(Field::pBindDescriptorBufferEmbeddedSamplersInfo); + constexpr std::array allowed_structs_VkBindDescriptorBufferEmbeddedSamplersInfoEXT = { + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO}; + + skip |= ValidateStructPnext(pBindDescriptorBufferEmbeddedSamplersInfo_loc, pBindDescriptorBufferEmbeddedSamplersInfo->pNext, + allowed_structs_VkBindDescriptorBufferEmbeddedSamplersInfoEXT.size(), + allowed_structs_VkBindDescriptorBufferEmbeddedSamplersInfoEXT.data(), + GeneratedVulkanHeaderVersion, "VUID-VkBindDescriptorBufferEmbeddedSamplersInfoEXT-pNext-pNext", + "VUID-VkBindDescriptorBufferEmbeddedSamplersInfoEXT-sType-unique", false, true); + + skip |= ValidateFlags(pBindDescriptorBufferEmbeddedSamplersInfo_loc.dot(Field::stageFlags), "VkShaderStageFlagBits", + AllVkShaderStageFlagBits, pBindDescriptorBufferEmbeddedSamplersInfo->stageFlags, kRequiredFlags, + "VUID-VkBindDescriptorBufferEmbeddedSamplersInfoEXT-stageFlags-parameter", + "VUID-VkBindDescriptorBufferEmbeddedSamplersInfoEXT-stageFlags-requiredbitmask"); + } + return skip; +} + bool StatelessValidation::PreCallValidateCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, @@ -22473,6 +22776,12 @@ bool StatelessValidation::PreCallValidateCmdCudaLaunchKernelNV(VkCommandBuffer c "VUID-VkCudaLaunchInfoNV-pNext-pNext", kVUIDUndefined, false, true); skip |= ValidateRequiredHandle(pLaunchInfo_loc.dot(Field::function), pLaunchInfo->function); + + skip |= ValidateArray(pLaunchInfo_loc.dot(Field::paramCount), pLaunchInfo_loc.dot(Field::pParams), pLaunchInfo->paramCount, + &pLaunchInfo->pParams, false, true, kVUIDUndefined, "VUID-VkCudaLaunchInfoNV-pParams-parameter"); + + skip |= ValidateArray(pLaunchInfo_loc.dot(Field::extraCount), pLaunchInfo_loc.dot(Field::pExtras), pLaunchInfo->extraCount, + &pLaunchInfo->pExtras, false, true, kVUIDUndefined, "VUID-VkCudaLaunchInfoNV-pExtras-parameter"); } return skip; } diff --git a/layers/vulkan/generated/stateless_validation_helper.h b/layers/vulkan/generated/stateless_validation_helper.h index 57dc8534f19..63e6b657ac8 100644 --- a/layers/vulkan/generated/stateless_validation_helper.h +++ b/layers/vulkan/generated/stateless_validation_helper.h @@ -887,7 +887,6 @@ bool PreCallValidateMapMemory2KHR(VkDevice device, const VkMemoryMapInfoKHR* pMe const ErrorObject& error_obj) const override; bool PreCallValidateUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo, const ErrorObject& error_obj) const override; -#ifdef VK_ENABLE_BETA_EXTENSIONS bool PreCallValidateGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties, const ErrorObject& error_obj) const override; @@ -898,7 +897,6 @@ bool PreCallValidateGetEncodedVideoSessionParametersKHR(VkDevice device, const ErrorObject& error_obj) const override; bool PreCallValidateCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo, const ErrorObject& error_obj) const override; -#endif // VK_ENABLE_BETA_EXTENSIONS bool PreCallValidateCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo, const ErrorObject& error_obj) const override; bool PreCallValidateCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask, @@ -957,6 +955,23 @@ bool PreCallValidateGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevic bool PreCallValidateGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, const ErrorObject& error_obj) const override; +bool PreCallValidateCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo, + const ErrorObject& error_obj) const override; +bool PreCallValidateCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR* pPushConstantsInfo, + const ErrorObject& error_obj) const override; +bool PreCallValidateCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo, + const ErrorObject& error_obj) const override; +bool PreCallValidateCmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo, + const ErrorObject& error_obj) const override; +bool PreCallValidateCmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, + const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo, + const ErrorObject& error_obj) const override; +bool PreCallValidateCmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo, + const ErrorObject& error_obj) const override; bool PreCallValidateCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback, const ErrorObject& error_obj) const override; diff --git a/layers/vulkan/generated/thread_safety.cpp b/layers/vulkan/generated/thread_safety.cpp index bcfc65acbf9..fbec2b479e3 100644 --- a/layers/vulkan/generated/thread_safety.cpp +++ b/layers/vulkan/generated/thread_safety.cpp @@ -3754,7 +3754,6 @@ void ThreadSafety::PostCallRecordUnmapMemory2KHR(VkDevice device, const VkMemory FinishReadObjectParentInstance(device, record_obj.location); } -#ifdef VK_ENABLE_BETA_EXTENSIONS void ThreadSafety::PreCallRecordGetEncodedVideoSessionParametersKHR( VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData, const RecordObject& record_obj) { @@ -3779,7 +3778,6 @@ void ThreadSafety::PostCallRecordCmdEncodeVideoKHR(VkCommandBuffer commandBuffer // Host access to commandBuffer must be externally synchronized } -#endif // VK_ENABLE_BETA_EXTENSIONS void ThreadSafety::PreCallRecordCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo, const RecordObject& record_obj) { PreCallRecordCmdSetEvent2(commandBuffer, event, pDependencyInfo, record_obj); @@ -4045,6 +4043,90 @@ void ThreadSafety::PostCallRecordGetCalibratedTimestampsKHR(VkDevice device, uin FinishReadObjectParentInstance(device, record_obj.location); } +void ThreadSafety::PreCallRecordCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo, + const RecordObject& record_obj) { + StartWriteObject(commandBuffer, record_obj.location); + // Host access to commandBuffer must be externally synchronized +} + +void ThreadSafety::PostCallRecordCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo, + const RecordObject& record_obj) { + FinishWriteObject(commandBuffer, record_obj.location); + // Host access to commandBuffer must be externally synchronized +} + +void ThreadSafety::PreCallRecordCmdPushConstants2KHR(VkCommandBuffer commandBuffer, + const VkPushConstantsInfoKHR* pPushConstantsInfo, + const RecordObject& record_obj) { + StartWriteObject(commandBuffer, record_obj.location); + // Host access to commandBuffer must be externally synchronized +} + +void ThreadSafety::PostCallRecordCmdPushConstants2KHR(VkCommandBuffer commandBuffer, + const VkPushConstantsInfoKHR* pPushConstantsInfo, + const RecordObject& record_obj) { + FinishWriteObject(commandBuffer, record_obj.location); + // Host access to commandBuffer must be externally synchronized +} + +void ThreadSafety::PreCallRecordCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo, + const RecordObject& record_obj) { + StartWriteObject(commandBuffer, record_obj.location); + // Host access to commandBuffer must be externally synchronized +} + +void ThreadSafety::PostCallRecordCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo, + const RecordObject& record_obj) { + FinishWriteObject(commandBuffer, record_obj.location); + // Host access to commandBuffer must be externally synchronized +} + +void ThreadSafety::PreCallRecordCmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo, + const RecordObject& record_obj) { + StartWriteObject(commandBuffer, record_obj.location); + // Host access to commandBuffer must be externally synchronized +} + +void ThreadSafety::PostCallRecordCmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo, + const RecordObject& record_obj) { + FinishWriteObject(commandBuffer, record_obj.location); + // Host access to commandBuffer must be externally synchronized +} + +void ThreadSafety::PreCallRecordCmdSetDescriptorBufferOffsets2EXT( + VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo, + const RecordObject& record_obj) { + StartWriteObject(commandBuffer, record_obj.location); + // Host access to commandBuffer must be externally synchronized +} + +void ThreadSafety::PostCallRecordCmdSetDescriptorBufferOffsets2EXT( + VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo, + const RecordObject& record_obj) { + FinishWriteObject(commandBuffer, record_obj.location); + // Host access to commandBuffer must be externally synchronized +} + +void ThreadSafety::PreCallRecordCmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo, + const RecordObject& record_obj) { + StartWriteObject(commandBuffer, record_obj.location); + // Host access to commandBuffer must be externally synchronized +} + +void ThreadSafety::PostCallRecordCmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo, + const RecordObject& record_obj) { + FinishWriteObject(commandBuffer, record_obj.location); + // Host access to commandBuffer must be externally synchronized +} + void ThreadSafety::PreCallRecordCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, diff --git a/layers/vulkan/generated/thread_safety_commands.h b/layers/vulkan/generated/thread_safety_commands.h index 22baaccf015..1746dbb617d 100644 --- a/layers/vulkan/generated/thread_safety_commands.h +++ b/layers/vulkan/generated/thread_safety_commands.h @@ -1939,7 +1939,6 @@ void PreCallRecordUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKHR* p void PostCallRecordUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo, const RecordObject& record_obj) override; -#ifdef VK_ENABLE_BETA_EXTENSIONS void PreCallRecordGetEncodedVideoSessionParametersKHR(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, @@ -1956,7 +1955,6 @@ void PreCallRecordCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideo void PostCallRecordCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo, const RecordObject& record_obj) override; -#endif // VK_ENABLE_BETA_EXTENSIONS void PreCallRecordCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo, const RecordObject& record_obj) override; @@ -2105,6 +2103,50 @@ void PostCallRecordGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestam const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, const RecordObject& record_obj) override; +void PreCallRecordCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo, + const RecordObject& record_obj) override; + +void PostCallRecordCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo, + const RecordObject& record_obj) override; + +void PreCallRecordCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR* pPushConstantsInfo, + const RecordObject& record_obj) override; + +void PostCallRecordCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR* pPushConstantsInfo, + const RecordObject& record_obj) override; + +void PreCallRecordCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo, + const RecordObject& record_obj) override; + +void PostCallRecordCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo, + const RecordObject& record_obj) override; + +void PreCallRecordCmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo, + const RecordObject& record_obj) override; + +void PostCallRecordCmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo, + const RecordObject& record_obj) override; + +void PreCallRecordCmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, + const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo, + const RecordObject& record_obj) override; + +void PostCallRecordCmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, + const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo, + const RecordObject& record_obj) override; + +void PreCallRecordCmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo, + const RecordObject& record_obj) override; + +void PostCallRecordCmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo, + const RecordObject& record_obj) override; + void PreCallRecordCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback, const RecordObject& record_obj) override; diff --git a/layers/vulkan/generated/valid_enum_values.cpp b/layers/vulkan/generated/valid_enum_values.cpp index de60a357c17..f82d026ac58 100644 --- a/layers/vulkan/generated/valid_enum_values.cpp +++ b/layers/vulkan/generated/valid_enum_values.cpp @@ -834,7 +834,6 @@ std::vector ValidationObject::ValidParamValu return values; } -#ifdef VK_ENABLE_BETA_EXTENSIONS template<> std::vector ValidationObject::ValidParamValues() const { constexpr std::array CoreVkVideoEncodeTuningModeKHREnums = {VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR, VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR, VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR, VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR, VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR}; @@ -850,7 +849,6 @@ std::vector ValidationObject::ValidParamValues() con std::copy(unique_exts.cbegin(), unique_exts.cend(), std::back_inserter(values)); return values; } -#endif // VK_ENABLE_BETA_EXTENSIONS template<> std::vector ValidationObject::ValidParamValues() const { diff --git a/layers/vulkan/generated/valid_enum_values.h b/layers/vulkan/generated/valid_enum_values.h index dfa6e1778d2..00268434f1f 100644 --- a/layers/vulkan/generated/valid_enum_values.h +++ b/layers/vulkan/generated/valid_enum_values.h @@ -65,9 +65,7 @@ template<> std::vector ValidationObject::ValidParamValues() co template<> std::vector ValidationObject::ValidParamValues() const; template<> std::vector ValidationObject::ValidParamValues() const; template<> std::vector ValidationObject::ValidParamValues() const; -#ifdef VK_ENABLE_BETA_EXTENSIONS template<> std::vector ValidationObject::ValidParamValues() const; -#endif // VK_ENABLE_BETA_EXTENSIONS template<> std::vector ValidationObject::ValidParamValues() const; template<> std::vector ValidationObject::ValidParamValues() const; template<> std::vector ValidationObject::ValidParamValues() const; diff --git a/layers/vulkan/generated/vk_dispatch_table_helper.h b/layers/vulkan/generated/vk_dispatch_table_helper.h index 4b8728cc383..b306ac0863a 100644 --- a/layers/vulkan/generated/vk_dispatch_table_helper.h +++ b/layers/vulkan/generated/vk_dispatch_table_helper.h @@ -694,7 +694,6 @@ static VKAPI_ATTR VkResult VKAPI_CALL StubMapMemory2KHR(VkDevice device, const V static VKAPI_ATTR VkResult VKAPI_CALL StubUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo) { return VK_SUCCESS; } -#ifdef VK_ENABLE_BETA_EXTENSIONS static VKAPI_ATTR VkResult VKAPI_CALL StubGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties) { @@ -706,7 +705,6 @@ static VKAPI_ATTR VkResult VKAPI_CALL StubGetEncodedVideoSessionParametersKHR( return VK_SUCCESS; } static VKAPI_ATTR void VKAPI_CALL StubCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) {} -#endif // VK_ENABLE_BETA_EXTENSIONS static VKAPI_ATTR void VKAPI_CALL StubCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) {} static VKAPI_ATTR void VKAPI_CALL StubCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, @@ -770,6 +768,19 @@ static VKAPI_ATTR VkResult VKAPI_CALL StubGetCalibratedTimestampsKHR(VkDevice de uint64_t* pTimestamps, uint64_t* pMaxDeviation) { return VK_SUCCESS; } +static VKAPI_ATTR void VKAPI_CALL StubCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo) {} +static VKAPI_ATTR void VKAPI_CALL StubCmdPushConstants2KHR(VkCommandBuffer commandBuffer, + const VkPushConstantsInfoKHR* pPushConstantsInfo) {} +static VKAPI_ATTR void VKAPI_CALL StubCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo) {} +static VKAPI_ATTR void VKAPI_CALL StubCmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo) {} +static VKAPI_ATTR void VKAPI_CALL StubCmdSetDescriptorBufferOffsets2EXT( + VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) {} +static VKAPI_ATTR void VKAPI_CALL StubCmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) { +} static VKAPI_ATTR VkResult VKAPI_CALL StubCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, @@ -1945,6 +1956,12 @@ const vvl::unordered_map> api_ {"vkGetDeviceImageSubresourceLayoutKHR", {"VK_KHR_maintenance5"}}, {"vkGetImageSubresourceLayout2KHR", {"VK_KHR_maintenance5"}}, {"vkGetCalibratedTimestampsKHR", {"VK_KHR_calibrated_timestamps"}}, + {"vkCmdBindDescriptorSets2KHR", {"VK_KHR_maintenance6"}}, + {"vkCmdPushConstants2KHR", {"VK_KHR_maintenance6"}}, + {"vkCmdPushDescriptorSet2KHR", {"VK_KHR_maintenance6"}}, + {"vkCmdPushDescriptorSetWithTemplate2KHR", {"VK_KHR_maintenance6"}}, + {"vkCmdSetDescriptorBufferOffsets2EXT", {"VK_KHR_maintenance6"}}, + {"vkCmdBindDescriptorBufferEmbeddedSamplers2EXT", {"VK_KHR_maintenance6"}}, {"vkDebugMarkerSetObjectTagEXT", {"VK_EXT_debug_marker"}}, {"vkDebugMarkerSetObjectNameEXT", {"VK_EXT_debug_marker"}}, {"vkCmdDebugMarkerBeginEXT", {"VK_EXT_debug_marker"}}, @@ -3004,7 +3021,6 @@ static inline void layer_init_device_dispatch_table(VkDevice device, VkLayerDisp if (table->UnmapMemory2KHR == nullptr) { table->UnmapMemory2KHR = (PFN_vkUnmapMemory2KHR)StubUnmapMemory2KHR; } -#ifdef VK_ENABLE_BETA_EXTENSIONS table->GetEncodedVideoSessionParametersKHR = (PFN_vkGetEncodedVideoSessionParametersKHR)gpa(device, "vkGetEncodedVideoSessionParametersKHR"); if (table->GetEncodedVideoSessionParametersKHR == nullptr) { @@ -3015,7 +3031,6 @@ static inline void layer_init_device_dispatch_table(VkDevice device, VkLayerDisp if (table->CmdEncodeVideoKHR == nullptr) { table->CmdEncodeVideoKHR = (PFN_vkCmdEncodeVideoKHR)StubCmdEncodeVideoKHR; } -#endif // VK_ENABLE_BETA_EXTENSIONS table->CmdSetEvent2KHR = (PFN_vkCmdSetEvent2KHR)gpa(device, "vkCmdSetEvent2KHR"); if (table->CmdSetEvent2KHR == nullptr) { table->CmdSetEvent2KHR = (PFN_vkCmdSetEvent2KHR)StubCmdSetEvent2KHR; @@ -3116,6 +3131,35 @@ static inline void layer_init_device_dispatch_table(VkDevice device, VkLayerDisp if (table->GetCalibratedTimestampsKHR == nullptr) { table->GetCalibratedTimestampsKHR = (PFN_vkGetCalibratedTimestampsKHR)StubGetCalibratedTimestampsKHR; } + table->CmdBindDescriptorSets2KHR = (PFN_vkCmdBindDescriptorSets2KHR)gpa(device, "vkCmdBindDescriptorSets2KHR"); + if (table->CmdBindDescriptorSets2KHR == nullptr) { + table->CmdBindDescriptorSets2KHR = (PFN_vkCmdBindDescriptorSets2KHR)StubCmdBindDescriptorSets2KHR; + } + table->CmdPushConstants2KHR = (PFN_vkCmdPushConstants2KHR)gpa(device, "vkCmdPushConstants2KHR"); + if (table->CmdPushConstants2KHR == nullptr) { + table->CmdPushConstants2KHR = (PFN_vkCmdPushConstants2KHR)StubCmdPushConstants2KHR; + } + table->CmdPushDescriptorSet2KHR = (PFN_vkCmdPushDescriptorSet2KHR)gpa(device, "vkCmdPushDescriptorSet2KHR"); + if (table->CmdPushDescriptorSet2KHR == nullptr) { + table->CmdPushDescriptorSet2KHR = (PFN_vkCmdPushDescriptorSet2KHR)StubCmdPushDescriptorSet2KHR; + } + table->CmdPushDescriptorSetWithTemplate2KHR = + (PFN_vkCmdPushDescriptorSetWithTemplate2KHR)gpa(device, "vkCmdPushDescriptorSetWithTemplate2KHR"); + if (table->CmdPushDescriptorSetWithTemplate2KHR == nullptr) { + table->CmdPushDescriptorSetWithTemplate2KHR = + (PFN_vkCmdPushDescriptorSetWithTemplate2KHR)StubCmdPushDescriptorSetWithTemplate2KHR; + } + table->CmdSetDescriptorBufferOffsets2EXT = + (PFN_vkCmdSetDescriptorBufferOffsets2EXT)gpa(device, "vkCmdSetDescriptorBufferOffsets2EXT"); + if (table->CmdSetDescriptorBufferOffsets2EXT == nullptr) { + table->CmdSetDescriptorBufferOffsets2EXT = (PFN_vkCmdSetDescriptorBufferOffsets2EXT)StubCmdSetDescriptorBufferOffsets2EXT; + } + table->CmdBindDescriptorBufferEmbeddedSamplers2EXT = + (PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT)gpa(device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT"); + if (table->CmdBindDescriptorBufferEmbeddedSamplers2EXT == nullptr) { + table->CmdBindDescriptorBufferEmbeddedSamplers2EXT = + (PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT)StubCmdBindDescriptorBufferEmbeddedSamplers2EXT; + } table->DebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT)gpa(device, "vkDebugMarkerSetObjectTagEXT"); if (table->DebugMarkerSetObjectTagEXT == nullptr) { table->DebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT)StubDebugMarkerSetObjectTagEXT; @@ -4705,14 +4749,12 @@ static inline void layer_init_instance_dispatch_table(VkInstance instance, VkLay table->GetPhysicalDeviceFragmentShadingRatesKHR = (PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)StubGetPhysicalDeviceFragmentShadingRatesKHR; } -#ifdef VK_ENABLE_BETA_EXTENSIONS table->GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = (PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR)gpa( instance, "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR"); if (table->GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR == nullptr) { table->GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = (PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR)StubGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR; } -#endif // VK_ENABLE_BETA_EXTENSIONS table->GetPhysicalDeviceCooperativeMatrixPropertiesKHR = (PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR)gpa(instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR"); if (table->GetPhysicalDeviceCooperativeMatrixPropertiesKHR == nullptr) { diff --git a/layers/vulkan/generated/vk_extension_helper.h b/layers/vulkan/generated/vk_extension_helper.h index 9163a608a61..f1115770811 100644 --- a/layers/vulkan/generated/vk_extension_helper.h +++ b/layers/vulkan/generated/vk_extension_helper.h @@ -404,6 +404,8 @@ struct DeviceExtensions : public InstanceExtensions { ExtEnabled vk_khr_sampler_mirror_clamp_to_edge{kNotEnabled}; ExtEnabled vk_khr_video_queue{kNotEnabled}; ExtEnabled vk_khr_video_decode_queue{kNotEnabled}; + ExtEnabled vk_khr_video_encode_h264{kNotEnabled}; + ExtEnabled vk_khr_video_encode_h265{kNotEnabled}; ExtEnabled vk_khr_video_decode_h264{kNotEnabled}; ExtEnabled vk_khr_dynamic_rendering{kNotEnabled}; ExtEnabled vk_khr_multiview{kNotEnabled}; @@ -480,8 +482,10 @@ struct DeviceExtensions : public InstanceExtensions { ExtEnabled vk_khr_maintenance5{kNotEnabled}; ExtEnabled vk_khr_ray_tracing_position_fetch{kNotEnabled}; ExtEnabled vk_khr_cooperative_matrix{kNotEnabled}; + ExtEnabled vk_khr_video_maintenance1{kNotEnabled}; ExtEnabled vk_khr_vertex_attribute_divisor{kNotEnabled}; ExtEnabled vk_khr_calibrated_timestamps{kNotEnabled}; + ExtEnabled vk_khr_maintenance6{kNotEnabled}; ExtEnabled vk_nv_glsl_shader{kNotEnabled}; ExtEnabled vk_ext_depth_range_unrestricted{kNotEnabled}; ExtEnabled vk_img_filter_cubic{kNotEnabled}; @@ -498,8 +502,6 @@ struct DeviceExtensions : public InstanceExtensions { ExtEnabled vk_amd_negative_viewport_height{kNotEnabled}; ExtEnabled vk_amd_gpu_shader_half_float{kNotEnabled}; ExtEnabled vk_amd_shader_ballot{kNotEnabled}; - ExtEnabled vk_ext_video_encode_h264{kNotEnabled}; - ExtEnabled vk_ext_video_encode_h265{kNotEnabled}; ExtEnabled vk_amd_texture_gather_bias_lod{kNotEnabled}; ExtEnabled vk_amd_shader_info{kNotEnabled}; ExtEnabled vk_amd_shader_image_load_store_lod{kNotEnabled}; @@ -701,6 +703,7 @@ struct DeviceExtensions : public InstanceExtensions { ExtEnabled vk_ext_dynamic_rendering_unused_attachments{kNotEnabled}; ExtEnabled vk_nv_low_latency2{kNotEnabled}; ExtEnabled vk_qcom_multiview_per_view_render_areas{kNotEnabled}; + ExtEnabled vk_nv_per_stage_descriptor_set{kNotEnabled}; ExtEnabled vk_qcom_image_processing2{kNotEnabled}; ExtEnabled vk_qcom_filter_cubic_weights{kNotEnabled}; ExtEnabled vk_qcom_ycbcr_degamma{kNotEnabled}; @@ -832,6 +835,12 @@ struct DeviceExtensions : public InstanceExtensions { DeviceInfo(&DeviceExtensions::vk_khr_video_decode_queue, {{{&DeviceExtensions::vk_khr_video_queue, VK_KHR_VIDEO_QUEUE_EXTENSION_NAME}, {&DeviceExtensions::vk_khr_synchronization2, VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME}}})}, + {VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME, + DeviceInfo(&DeviceExtensions::vk_khr_video_encode_h264, + {{{&DeviceExtensions::vk_khr_video_encode_queue, VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME}}})}, + {VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME, + DeviceInfo(&DeviceExtensions::vk_khr_video_encode_h265, + {{{&DeviceExtensions::vk_khr_video_encode_queue, VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME}}})}, {VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_khr_video_decode_h264, {{{&DeviceExtensions::vk_khr_video_decode_queue, VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME}}})}, @@ -1039,12 +1048,10 @@ struct DeviceExtensions : public InstanceExtensions { {{{&DeviceExtensions::vk_khr_swapchain, VK_KHR_SWAPCHAIN_EXTENSION_NAME}, {&DeviceExtensions::vk_khr_get_physical_device_properties2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME}}})}, -#ifdef VK_ENABLE_BETA_EXTENSIONS {VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_khr_video_encode_queue, {{{&DeviceExtensions::vk_khr_video_queue, VK_KHR_VIDEO_QUEUE_EXTENSION_NAME}, {&DeviceExtensions::vk_khr_synchronization2, VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME}}})}, -#endif // VK_ENABLE_BETA_EXTENSIONS {VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_khr_synchronization2, {{{&DeviceExtensions::vk_khr_get_physical_device_properties2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME}}})}, @@ -1085,6 +1092,9 @@ struct DeviceExtensions : public InstanceExtensions { {VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_khr_cooperative_matrix, {{{&DeviceExtensions::vk_khr_get_physical_device_properties2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME}}})}, + {VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME, + DeviceInfo(&DeviceExtensions::vk_khr_video_maintenance1, + {{{&DeviceExtensions::vk_khr_video_queue, VK_KHR_VIDEO_QUEUE_EXTENSION_NAME}}})}, {VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_khr_vertex_attribute_divisor, {{{&DeviceExtensions::vk_khr_get_physical_device_properties2, @@ -1092,6 +1102,7 @@ struct DeviceExtensions : public InstanceExtensions { {VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_khr_calibrated_timestamps, {{{&DeviceExtensions::vk_khr_get_physical_device_properties2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME}}})}, + {VK_KHR_MAINTENANCE_6_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_khr_maintenance6, {})}, {VK_NV_GLSL_SHADER_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_nv_glsl_shader, {})}, {VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ext_depth_range_unrestricted, {})}, {VK_IMG_FILTER_CUBIC_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_img_filter_cubic, {})}, @@ -1113,14 +1124,6 @@ struct DeviceExtensions : public InstanceExtensions { {VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_amd_negative_viewport_height, {})}, {VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_amd_gpu_shader_half_float, {})}, {VK_AMD_SHADER_BALLOT_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_amd_shader_ballot, {})}, -#ifdef VK_ENABLE_BETA_EXTENSIONS - {VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME, - DeviceInfo(&DeviceExtensions::vk_ext_video_encode_h264, - {{{&DeviceExtensions::vk_khr_video_encode_queue, VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME}}})}, - {VK_EXT_VIDEO_ENCODE_H265_EXTENSION_NAME, - DeviceInfo(&DeviceExtensions::vk_ext_video_encode_h265, - {{{&DeviceExtensions::vk_khr_video_encode_queue, VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME}}})}, -#endif // VK_ENABLE_BETA_EXTENSIONS {VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_amd_texture_gather_bias_lod, {{{&DeviceExtensions::vk_khr_get_physical_device_properties2, @@ -1795,6 +1798,9 @@ struct DeviceExtensions : public InstanceExtensions { {&DeviceExtensions::vk_khr_timeline_semaphore, VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME}}})}, {VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_qcom_multiview_per_view_render_areas, {})}, + {VK_NV_PER_STAGE_DESCRIPTOR_SET_EXTENSION_NAME, + DeviceInfo(&DeviceExtensions::vk_nv_per_stage_descriptor_set, + {{{&DeviceExtensions::vk_khr_maintenance6, VK_KHR_MAINTENANCE_6_EXTENSION_NAME}}})}, {VK_QCOM_IMAGE_PROCESSING_2_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_qcom_image_processing2, {{{&DeviceExtensions::vk_qcom_image_processing, VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME}}})}, @@ -1928,6 +1934,8 @@ static const std::set kDeviceExtensionNames = { VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME, VK_KHR_VIDEO_QUEUE_EXTENSION_NAME, VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME, + VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME, + VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME, VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME, VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME, VK_KHR_MULTIVIEW_EXTENSION_NAME, @@ -2001,9 +2009,7 @@ static const std::set kDeviceExtensionNames = { VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME, VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME, VK_KHR_PRESENT_ID_EXTENSION_NAME, -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME, -#endif // VK_ENABLE_BETA_EXTENSIONS VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME, VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME, VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME, @@ -2016,8 +2022,10 @@ static const std::set kDeviceExtensionNames = { VK_KHR_MAINTENANCE_5_EXTENSION_NAME, VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME, VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME, + VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME, VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME, + VK_KHR_MAINTENANCE_6_EXTENSION_NAME, VK_NV_GLSL_SHADER_EXTENSION_NAME, VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME, VK_IMG_FILTER_CUBIC_EXTENSION_NAME, @@ -2034,10 +2042,6 @@ static const std::set kDeviceExtensionNames = { VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME, VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME, VK_AMD_SHADER_BALLOT_EXTENSION_NAME, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME, - VK_EXT_VIDEO_ENCODE_H265_EXTENSION_NAME, -#endif // VK_ENABLE_BETA_EXTENSIONS VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME, VK_AMD_SHADER_INFO_EXTENSION_NAME, VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME, @@ -2259,6 +2263,7 @@ static const std::set kDeviceExtensionNames = { VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME, VK_NV_LOW_LATENCY_2_EXTENSION_NAME, VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME, + VK_NV_PER_STAGE_DESCRIPTOR_SET_EXTENSION_NAME, VK_QCOM_IMAGE_PROCESSING_2_EXTENSION_NAME, VK_QCOM_FILTER_CUBIC_WEIGHTS_EXTENSION_NAME, VK_QCOM_YCBCR_DEGAMMA_EXTENSION_NAME, diff --git a/layers/vulkan/generated/vk_function_pointers.cpp b/layers/vulkan/generated/vk_function_pointers.cpp index ee8372082a5..db157bdd6c5 100644 --- a/layers/vulkan/generated/vk_function_pointers.cpp +++ b/layers/vulkan/generated/vk_function_pointers.cpp @@ -429,11 +429,9 @@ PFN_vkGetPipelineExecutableStatisticsKHR GetPipelineExecutableStatisticsKHR; PFN_vkGetPipelineExecutableInternalRepresentationsKHR GetPipelineExecutableInternalRepresentationsKHR; PFN_vkMapMemory2KHR MapMemory2KHR; PFN_vkUnmapMemory2KHR UnmapMemory2KHR; -#ifdef VK_ENABLE_BETA_EXTENSIONS PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR; PFN_vkGetEncodedVideoSessionParametersKHR GetEncodedVideoSessionParametersKHR; PFN_vkCmdEncodeVideoKHR CmdEncodeVideoKHR; -#endif // VK_ENABLE_BETA_EXTENSIONS PFN_vkCmdSetEvent2KHR CmdSetEvent2KHR; PFN_vkCmdResetEvent2KHR CmdResetEvent2KHR; PFN_vkCmdWaitEvents2KHR CmdWaitEvents2KHR; @@ -459,6 +457,12 @@ PFN_vkGetImageSubresourceLayout2KHR GetImageSubresourceLayout2KHR; PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR GetPhysicalDeviceCooperativeMatrixPropertiesKHR; PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR GetPhysicalDeviceCalibrateableTimeDomainsKHR; PFN_vkGetCalibratedTimestampsKHR GetCalibratedTimestampsKHR; +PFN_vkCmdBindDescriptorSets2KHR CmdBindDescriptorSets2KHR; +PFN_vkCmdPushConstants2KHR CmdPushConstants2KHR; +PFN_vkCmdPushDescriptorSet2KHR CmdPushDescriptorSet2KHR; +PFN_vkCmdPushDescriptorSetWithTemplate2KHR CmdPushDescriptorSetWithTemplate2KHR; +PFN_vkCmdSetDescriptorBufferOffsets2EXT CmdSetDescriptorBufferOffsets2EXT; +PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT CmdBindDescriptorBufferEmbeddedSamplers2EXT; PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT; PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallbackEXT; PFN_vkDebugReportMessageEXT DebugReportMessageEXT; @@ -1681,7 +1685,6 @@ void InitDeviceExtension(VkInstance instance, VkDevice device, const char* exten UnmapMemory2KHR = reinterpret_cast(GetDeviceProcAddr(device, "vkUnmapMemory2KHR")); } }, -#ifdef VK_ENABLE_BETA_EXTENSIONS { "VK_KHR_video_encode_queue", [](VkInstance instance, VkDevice device) { GetEncodedVideoSessionParametersKHR = reinterpret_cast(GetDeviceProcAddr(device, "vkGetEncodedVideoSessionParametersKHR")); @@ -1689,7 +1692,6 @@ void InitDeviceExtension(VkInstance instance, VkDevice device, const char* exten GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = reinterpret_cast(GetInstanceProcAddr(instance, "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR")); } }, -#endif // VK_ENABLE_BETA_EXTENSIONS { "VK_KHR_synchronization2", [](VkInstance , VkDevice device) { CmdSetEvent2KHR = reinterpret_cast(GetDeviceProcAddr(device, "vkCmdSetEvent2KHR")); @@ -1743,6 +1745,16 @@ void InitDeviceExtension(VkInstance instance, VkDevice device, const char* exten GetPhysicalDeviceCalibrateableTimeDomainsKHR = reinterpret_cast(GetInstanceProcAddr(instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR")); } }, + { + "VK_KHR_maintenance6", [](VkInstance , VkDevice device) { + CmdBindDescriptorSets2KHR = reinterpret_cast(GetDeviceProcAddr(device, "vkCmdBindDescriptorSets2KHR")); + CmdPushConstants2KHR = reinterpret_cast(GetDeviceProcAddr(device, "vkCmdPushConstants2KHR")); + CmdPushDescriptorSet2KHR = reinterpret_cast(GetDeviceProcAddr(device, "vkCmdPushDescriptorSet2KHR")); + CmdPushDescriptorSetWithTemplate2KHR = reinterpret_cast(GetDeviceProcAddr(device, "vkCmdPushDescriptorSetWithTemplate2KHR")); + CmdSetDescriptorBufferOffsets2EXT = reinterpret_cast(GetDeviceProcAddr(device, "vkCmdSetDescriptorBufferOffsets2EXT")); + CmdBindDescriptorBufferEmbeddedSamplers2EXT = reinterpret_cast(GetDeviceProcAddr(device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT")); + } + }, { "VK_EXT_debug_marker", [](VkInstance , VkDevice device) { DebugMarkerSetObjectTagEXT = reinterpret_cast(GetDeviceProcAddr(device, "vkDebugMarkerSetObjectTagEXT")); @@ -2536,11 +2548,9 @@ void ResetAllExtensions() { GetPipelineExecutableInternalRepresentationsKHR = nullptr; MapMemory2KHR = nullptr; UnmapMemory2KHR = nullptr; -#ifdef VK_ENABLE_BETA_EXTENSIONS GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = nullptr; GetEncodedVideoSessionParametersKHR = nullptr; CmdEncodeVideoKHR = nullptr; -#endif // VK_ENABLE_BETA_EXTENSIONS CmdSetEvent2KHR = nullptr; CmdResetEvent2KHR = nullptr; CmdWaitEvents2KHR = nullptr; @@ -2566,6 +2576,12 @@ void ResetAllExtensions() { GetPhysicalDeviceCooperativeMatrixPropertiesKHR = nullptr; GetPhysicalDeviceCalibrateableTimeDomainsKHR = nullptr; GetCalibratedTimestampsKHR = nullptr; + CmdBindDescriptorSets2KHR = nullptr; + CmdPushConstants2KHR = nullptr; + CmdPushDescriptorSet2KHR = nullptr; + CmdPushDescriptorSetWithTemplate2KHR = nullptr; + CmdSetDescriptorBufferOffsets2EXT = nullptr; + CmdBindDescriptorBufferEmbeddedSamplers2EXT = nullptr; CreateDebugReportCallbackEXT = nullptr; DestroyDebugReportCallbackEXT = nullptr; DebugReportMessageEXT = nullptr; diff --git a/layers/vulkan/generated/vk_function_pointers.h b/layers/vulkan/generated/vk_function_pointers.h index 4f84c97596b..96a29930929 100644 --- a/layers/vulkan/generated/vk_function_pointers.h +++ b/layers/vulkan/generated/vk_function_pointers.h @@ -392,11 +392,9 @@ extern PFN_vkGetPipelineExecutableStatisticsKHR GetPipelineExecutableStatisticsK extern PFN_vkGetPipelineExecutableInternalRepresentationsKHR GetPipelineExecutableInternalRepresentationsKHR; extern PFN_vkMapMemory2KHR MapMemory2KHR; extern PFN_vkUnmapMemory2KHR UnmapMemory2KHR; -#ifdef VK_ENABLE_BETA_EXTENSIONS extern PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR; extern PFN_vkGetEncodedVideoSessionParametersKHR GetEncodedVideoSessionParametersKHR; extern PFN_vkCmdEncodeVideoKHR CmdEncodeVideoKHR; -#endif // VK_ENABLE_BETA_EXTENSIONS extern PFN_vkCmdSetEvent2KHR CmdSetEvent2KHR; extern PFN_vkCmdResetEvent2KHR CmdResetEvent2KHR; extern PFN_vkCmdWaitEvents2KHR CmdWaitEvents2KHR; @@ -422,6 +420,12 @@ extern PFN_vkGetImageSubresourceLayout2KHR GetImageSubresourceLayout2KHR; extern PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR GetPhysicalDeviceCooperativeMatrixPropertiesKHR; extern PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR GetPhysicalDeviceCalibrateableTimeDomainsKHR; extern PFN_vkGetCalibratedTimestampsKHR GetCalibratedTimestampsKHR; +extern PFN_vkCmdBindDescriptorSets2KHR CmdBindDescriptorSets2KHR; +extern PFN_vkCmdPushConstants2KHR CmdPushConstants2KHR; +extern PFN_vkCmdPushDescriptorSet2KHR CmdPushDescriptorSet2KHR; +extern PFN_vkCmdPushDescriptorSetWithTemplate2KHR CmdPushDescriptorSetWithTemplate2KHR; +extern PFN_vkCmdSetDescriptorBufferOffsets2EXT CmdSetDescriptorBufferOffsets2EXT; +extern PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT CmdBindDescriptorBufferEmbeddedSamplers2EXT; extern PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT; extern PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallbackEXT; extern PFN_vkDebugReportMessageEXT DebugReportMessageEXT; diff --git a/layers/vulkan/generated/vk_layer_dispatch_table.h b/layers/vulkan/generated/vk_layer_dispatch_table.h index 4f1f4b9af08..ca1cbba104d 100644 --- a/layers/vulkan/generated/vk_layer_dispatch_table.h +++ b/layers/vulkan/generated/vk_layer_dispatch_table.h @@ -113,9 +113,7 @@ typedef struct VkLayerInstanceDispatchTable_ { PFN_vkGetDisplayModeProperties2KHR GetDisplayModeProperties2KHR; PFN_vkGetDisplayPlaneCapabilities2KHR GetDisplayPlaneCapabilities2KHR; PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR GetPhysicalDeviceFragmentShadingRatesKHR; -#ifdef VK_ENABLE_BETA_EXTENSIONS PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR; -#endif // VK_ENABLE_BETA_EXTENSIONS PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR GetPhysicalDeviceCooperativeMatrixPropertiesKHR; PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR GetPhysicalDeviceCalibrateableTimeDomainsKHR; PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT; @@ -448,10 +446,8 @@ typedef struct VkLayerDispatchTable_ { PFN_vkGetPipelineExecutableInternalRepresentationsKHR GetPipelineExecutableInternalRepresentationsKHR; PFN_vkMapMemory2KHR MapMemory2KHR; PFN_vkUnmapMemory2KHR UnmapMemory2KHR; -#ifdef VK_ENABLE_BETA_EXTENSIONS PFN_vkGetEncodedVideoSessionParametersKHR GetEncodedVideoSessionParametersKHR; PFN_vkCmdEncodeVideoKHR CmdEncodeVideoKHR; -#endif // VK_ENABLE_BETA_EXTENSIONS PFN_vkCmdSetEvent2KHR CmdSetEvent2KHR; PFN_vkCmdResetEvent2KHR CmdResetEvent2KHR; PFN_vkCmdWaitEvents2KHR CmdWaitEvents2KHR; @@ -475,6 +471,12 @@ typedef struct VkLayerDispatchTable_ { PFN_vkGetDeviceImageSubresourceLayoutKHR GetDeviceImageSubresourceLayoutKHR; PFN_vkGetImageSubresourceLayout2KHR GetImageSubresourceLayout2KHR; PFN_vkGetCalibratedTimestampsKHR GetCalibratedTimestampsKHR; + PFN_vkCmdBindDescriptorSets2KHR CmdBindDescriptorSets2KHR; + PFN_vkCmdPushConstants2KHR CmdPushConstants2KHR; + PFN_vkCmdPushDescriptorSet2KHR CmdPushDescriptorSet2KHR; + PFN_vkCmdPushDescriptorSetWithTemplate2KHR CmdPushDescriptorSetWithTemplate2KHR; + PFN_vkCmdSetDescriptorBufferOffsets2EXT CmdSetDescriptorBufferOffsets2EXT; + PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT CmdBindDescriptorBufferEmbeddedSamplers2EXT; PFN_vkDebugMarkerSetObjectTagEXT DebugMarkerSetObjectTagEXT; PFN_vkDebugMarkerSetObjectNameEXT DebugMarkerSetObjectNameEXT; PFN_vkCmdDebugMarkerBeginEXT CmdDebugMarkerBeginEXT; diff --git a/layers/vulkan/generated/vk_safe_struct.h b/layers/vulkan/generated/vk_safe_struct.h index a973d2bf526..f04c0db2f90 100644 --- a/layers/vulkan/generated/vk_safe_struct.h +++ b/layers/vulkan/generated/vk_safe_struct.h @@ -5269,41 +5269,82 @@ struct safe_VkVideoDecodeInfoKHR { VkVideoDecodeInfoKHR* ptr() { return reinterpret_cast(this); } VkVideoDecodeInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkVideoDecodeH264ProfileInfoKHR { +struct safe_VkVideoEncodeH264CapabilitiesKHR { VkStructureType sType; - const void* pNext{}; - StdVideoH264ProfileIdc stdProfileIdc; - VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout; + void* pNext{}; + VkVideoEncodeH264CapabilityFlagsKHR flags; + StdVideoH264LevelIdc maxLevelIdc; + uint32_t maxSliceCount; + uint32_t maxPPictureL0ReferenceCount; + uint32_t maxBPictureL0ReferenceCount; + uint32_t maxL1ReferenceCount; + uint32_t maxTemporalLayerCount; + VkBool32 expectDyadicTemporalLayerPattern; + int32_t minQp; + int32_t maxQp; + VkBool32 prefersGopRemainingFrames; + VkBool32 requiresGopRemainingFrames; + VkVideoEncodeH264StdFlagsKHR stdSyntaxFlags; - safe_VkVideoDecodeH264ProfileInfoKHR(const VkVideoDecodeH264ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoDecodeH264ProfileInfoKHR(const safe_VkVideoDecodeH264ProfileInfoKHR& copy_src); - safe_VkVideoDecodeH264ProfileInfoKHR& operator=(const safe_VkVideoDecodeH264ProfileInfoKHR& copy_src); - safe_VkVideoDecodeH264ProfileInfoKHR(); - ~safe_VkVideoDecodeH264ProfileInfoKHR(); - void initialize(const VkVideoDecodeH264ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoDecodeH264ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoDecodeH264ProfileInfoKHR* ptr() { return reinterpret_cast(this); } - VkVideoDecodeH264ProfileInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoEncodeH264CapabilitiesKHR(const VkVideoEncodeH264CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoEncodeH264CapabilitiesKHR(const safe_VkVideoEncodeH264CapabilitiesKHR& copy_src); + safe_VkVideoEncodeH264CapabilitiesKHR& operator=(const safe_VkVideoEncodeH264CapabilitiesKHR& copy_src); + safe_VkVideoEncodeH264CapabilitiesKHR(); + ~safe_VkVideoEncodeH264CapabilitiesKHR(); + void initialize(const VkVideoEncodeH264CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH264CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH264CapabilitiesKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeH264CapabilitiesKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkVideoDecodeH264CapabilitiesKHR { +struct safe_VkVideoEncodeH264QualityLevelPropertiesKHR { VkStructureType sType; void* pNext{}; + VkVideoEncodeH264RateControlFlagsKHR preferredRateControlFlags; + uint32_t preferredGopFrameCount; + uint32_t preferredIdrPeriod; + uint32_t preferredConsecutiveBFrameCount; + uint32_t preferredTemporalLayerCount; + VkVideoEncodeH264QpKHR preferredConstantQp; + uint32_t preferredMaxL0ReferenceCount; + uint32_t preferredMaxL1ReferenceCount; + VkBool32 preferredStdEntropyCodingModeFlag; + + safe_VkVideoEncodeH264QualityLevelPropertiesKHR(const VkVideoEncodeH264QualityLevelPropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeH264QualityLevelPropertiesKHR(const safe_VkVideoEncodeH264QualityLevelPropertiesKHR& copy_src); + safe_VkVideoEncodeH264QualityLevelPropertiesKHR& operator=(const safe_VkVideoEncodeH264QualityLevelPropertiesKHR& copy_src); + safe_VkVideoEncodeH264QualityLevelPropertiesKHR(); + ~safe_VkVideoEncodeH264QualityLevelPropertiesKHR(); + void initialize(const VkVideoEncodeH264QualityLevelPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH264QualityLevelPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH264QualityLevelPropertiesKHR* ptr() { + return reinterpret_cast(this); + } + VkVideoEncodeH264QualityLevelPropertiesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkVideoEncodeH264SessionCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkBool32 useMaxLevelIdc; StdVideoH264LevelIdc maxLevelIdc; - VkOffset2D fieldOffsetGranularity; - safe_VkVideoDecodeH264CapabilitiesKHR(const VkVideoDecodeH264CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoDecodeH264CapabilitiesKHR(const safe_VkVideoDecodeH264CapabilitiesKHR& copy_src); - safe_VkVideoDecodeH264CapabilitiesKHR& operator=(const safe_VkVideoDecodeH264CapabilitiesKHR& copy_src); - safe_VkVideoDecodeH264CapabilitiesKHR(); - ~safe_VkVideoDecodeH264CapabilitiesKHR(); - void initialize(const VkVideoDecodeH264CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoDecodeH264CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoDecodeH264CapabilitiesKHR* ptr() { return reinterpret_cast(this); } - VkVideoDecodeH264CapabilitiesKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoEncodeH264SessionCreateInfoKHR(const VkVideoEncodeH264SessionCreateInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeH264SessionCreateInfoKHR(const safe_VkVideoEncodeH264SessionCreateInfoKHR& copy_src); + safe_VkVideoEncodeH264SessionCreateInfoKHR& operator=(const safe_VkVideoEncodeH264SessionCreateInfoKHR& copy_src); + safe_VkVideoEncodeH264SessionCreateInfoKHR(); + ~safe_VkVideoEncodeH264SessionCreateInfoKHR(); + void initialize(const VkVideoEncodeH264SessionCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH264SessionCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH264SessionCreateInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeH264SessionCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkVideoDecodeH264SessionParametersAddInfoKHR { +struct safe_VkVideoEncodeH264SessionParametersAddInfoKHR { VkStructureType sType; const void* pNext{}; uint32_t stdSPSCount; @@ -5311,3063 +5352,3237 @@ struct safe_VkVideoDecodeH264SessionParametersAddInfoKHR { uint32_t stdPPSCount; const StdVideoH264PictureParameterSet* pStdPPSs{}; - safe_VkVideoDecodeH264SessionParametersAddInfoKHR(const VkVideoDecodeH264SessionParametersAddInfoKHR* in_struct, + safe_VkVideoEncodeH264SessionParametersAddInfoKHR(const VkVideoEncodeH264SessionParametersAddInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoDecodeH264SessionParametersAddInfoKHR(const safe_VkVideoDecodeH264SessionParametersAddInfoKHR& copy_src); - safe_VkVideoDecodeH264SessionParametersAddInfoKHR& operator=(const safe_VkVideoDecodeH264SessionParametersAddInfoKHR& copy_src); - safe_VkVideoDecodeH264SessionParametersAddInfoKHR(); - ~safe_VkVideoDecodeH264SessionParametersAddInfoKHR(); - void initialize(const VkVideoDecodeH264SessionParametersAddInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoDecodeH264SessionParametersAddInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoDecodeH264SessionParametersAddInfoKHR* ptr() { - return reinterpret_cast(this); + safe_VkVideoEncodeH264SessionParametersAddInfoKHR(const safe_VkVideoEncodeH264SessionParametersAddInfoKHR& copy_src); + safe_VkVideoEncodeH264SessionParametersAddInfoKHR& operator=(const safe_VkVideoEncodeH264SessionParametersAddInfoKHR& copy_src); + safe_VkVideoEncodeH264SessionParametersAddInfoKHR(); + ~safe_VkVideoEncodeH264SessionParametersAddInfoKHR(); + void initialize(const VkVideoEncodeH264SessionParametersAddInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH264SessionParametersAddInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH264SessionParametersAddInfoKHR* ptr() { + return reinterpret_cast(this); } - VkVideoDecodeH264SessionParametersAddInfoKHR const* ptr() const { - return reinterpret_cast(this); + VkVideoEncodeH264SessionParametersAddInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkVideoDecodeH264SessionParametersCreateInfoKHR { +struct safe_VkVideoEncodeH264SessionParametersCreateInfoKHR { VkStructureType sType; const void* pNext{}; uint32_t maxStdSPSCount; uint32_t maxStdPPSCount; - safe_VkVideoDecodeH264SessionParametersAddInfoKHR* pParametersAddInfo{}; + safe_VkVideoEncodeH264SessionParametersAddInfoKHR* pParametersAddInfo{}; - safe_VkVideoDecodeH264SessionParametersCreateInfoKHR(const VkVideoDecodeH264SessionParametersCreateInfoKHR* in_struct, + safe_VkVideoEncodeH264SessionParametersCreateInfoKHR(const VkVideoEncodeH264SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoDecodeH264SessionParametersCreateInfoKHR(const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& copy_src); - safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& operator=( - const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& copy_src); - safe_VkVideoDecodeH264SessionParametersCreateInfoKHR(); - ~safe_VkVideoDecodeH264SessionParametersCreateInfoKHR(); - void initialize(const VkVideoDecodeH264SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoDecodeH264SessionParametersCreateInfoKHR* ptr() { - return reinterpret_cast(this); + safe_VkVideoEncodeH264SessionParametersCreateInfoKHR(const safe_VkVideoEncodeH264SessionParametersCreateInfoKHR& copy_src); + safe_VkVideoEncodeH264SessionParametersCreateInfoKHR& operator=( + const safe_VkVideoEncodeH264SessionParametersCreateInfoKHR& copy_src); + safe_VkVideoEncodeH264SessionParametersCreateInfoKHR(); + ~safe_VkVideoEncodeH264SessionParametersCreateInfoKHR(); + void initialize(const VkVideoEncodeH264SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH264SessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH264SessionParametersCreateInfoKHR* ptr() { + return reinterpret_cast(this); } - VkVideoDecodeH264SessionParametersCreateInfoKHR const* ptr() const { - return reinterpret_cast(this); + VkVideoEncodeH264SessionParametersCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkVideoDecodeH264PictureInfoKHR { +struct safe_VkVideoEncodeH264SessionParametersGetInfoKHR { VkStructureType sType; const void* pNext{}; - const StdVideoDecodeH264PictureInfo* pStdPictureInfo{}; - uint32_t sliceCount; - const uint32_t* pSliceOffsets{}; + VkBool32 writeStdSPS; + VkBool32 writeStdPPS; + uint32_t stdSPSId; + uint32_t stdPPSId; - safe_VkVideoDecodeH264PictureInfoKHR(const VkVideoDecodeH264PictureInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoDecodeH264PictureInfoKHR(const safe_VkVideoDecodeH264PictureInfoKHR& copy_src); - safe_VkVideoDecodeH264PictureInfoKHR& operator=(const safe_VkVideoDecodeH264PictureInfoKHR& copy_src); - safe_VkVideoDecodeH264PictureInfoKHR(); - ~safe_VkVideoDecodeH264PictureInfoKHR(); - void initialize(const VkVideoDecodeH264PictureInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoDecodeH264PictureInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoDecodeH264PictureInfoKHR* ptr() { return reinterpret_cast(this); } - VkVideoDecodeH264PictureInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoEncodeH264SessionParametersGetInfoKHR(const VkVideoEncodeH264SessionParametersGetInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeH264SessionParametersGetInfoKHR(const safe_VkVideoEncodeH264SessionParametersGetInfoKHR& copy_src); + safe_VkVideoEncodeH264SessionParametersGetInfoKHR& operator=(const safe_VkVideoEncodeH264SessionParametersGetInfoKHR& copy_src); + safe_VkVideoEncodeH264SessionParametersGetInfoKHR(); + ~safe_VkVideoEncodeH264SessionParametersGetInfoKHR(); + void initialize(const VkVideoEncodeH264SessionParametersGetInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH264SessionParametersGetInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH264SessionParametersGetInfoKHR* ptr() { + return reinterpret_cast(this); + } + VkVideoEncodeH264SessionParametersGetInfoKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkVideoDecodeH264DpbSlotInfoKHR { +struct safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR { VkStructureType sType; - const void* pNext{}; - const StdVideoDecodeH264ReferenceInfo* pStdReferenceInfo{}; + void* pNext{}; + VkBool32 hasStdSPSOverrides; + VkBool32 hasStdPPSOverrides; - safe_VkVideoDecodeH264DpbSlotInfoKHR(const VkVideoDecodeH264DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoDecodeH264DpbSlotInfoKHR(const safe_VkVideoDecodeH264DpbSlotInfoKHR& copy_src); - safe_VkVideoDecodeH264DpbSlotInfoKHR& operator=(const safe_VkVideoDecodeH264DpbSlotInfoKHR& copy_src); - safe_VkVideoDecodeH264DpbSlotInfoKHR(); - ~safe_VkVideoDecodeH264DpbSlotInfoKHR(); - void initialize(const VkVideoDecodeH264DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoDecodeH264DpbSlotInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoDecodeH264DpbSlotInfoKHR* ptr() { return reinterpret_cast(this); } - VkVideoDecodeH264DpbSlotInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR(const VkVideoEncodeH264SessionParametersFeedbackInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR(const safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR& copy_src); + safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR& operator=( + const safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR& copy_src); + safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR(); + ~safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR(); + void initialize(const VkVideoEncodeH264SessionParametersFeedbackInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH264SessionParametersFeedbackInfoKHR* ptr() { + return reinterpret_cast(this); + } + VkVideoEncodeH264SessionParametersFeedbackInfoKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkRenderingFragmentShadingRateAttachmentInfoKHR { +struct safe_VkVideoEncodeH264NaluSliceInfoKHR { VkStructureType sType; const void* pNext{}; - VkImageView imageView; - VkImageLayout imageLayout; - VkExtent2D shadingRateAttachmentTexelSize; + int32_t constantQp; + const StdVideoEncodeH264SliceHeader* pStdSliceHeader{}; - safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src); - safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& operator=( - const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src); - safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(); - ~safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(); - void initialize(const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkRenderingFragmentShadingRateAttachmentInfoKHR* ptr() { - return reinterpret_cast(this); - } - VkRenderingFragmentShadingRateAttachmentInfoKHR const* ptr() const { - return reinterpret_cast(this); + safe_VkVideoEncodeH264NaluSliceInfoKHR(const VkVideoEncodeH264NaluSliceInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoEncodeH264NaluSliceInfoKHR(const safe_VkVideoEncodeH264NaluSliceInfoKHR& copy_src); + safe_VkVideoEncodeH264NaluSliceInfoKHR& operator=(const safe_VkVideoEncodeH264NaluSliceInfoKHR& copy_src); + safe_VkVideoEncodeH264NaluSliceInfoKHR(); + ~safe_VkVideoEncodeH264NaluSliceInfoKHR(); + void initialize(const VkVideoEncodeH264NaluSliceInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH264NaluSliceInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH264NaluSliceInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeH264NaluSliceInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkRenderingFragmentDensityMapAttachmentInfoEXT { +struct safe_VkVideoEncodeH264PictureInfoKHR { VkStructureType sType; const void* pNext{}; - VkImageView imageView; - VkImageLayout imageLayout; + uint32_t naluSliceEntryCount; + safe_VkVideoEncodeH264NaluSliceInfoKHR* pNaluSliceEntries{}; + const StdVideoEncodeH264PictureInfo* pStdPictureInfo{}; + VkBool32 generatePrefixNalu; - safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& copy_src); - safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& operator=( - const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& copy_src); - safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(); - ~safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(); - void initialize(const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkRenderingFragmentDensityMapAttachmentInfoEXT* ptr() { - return reinterpret_cast(this); - } - VkRenderingFragmentDensityMapAttachmentInfoEXT const* ptr() const { - return reinterpret_cast(this); - } + safe_VkVideoEncodeH264PictureInfoKHR(const VkVideoEncodeH264PictureInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoEncodeH264PictureInfoKHR(const safe_VkVideoEncodeH264PictureInfoKHR& copy_src); + safe_VkVideoEncodeH264PictureInfoKHR& operator=(const safe_VkVideoEncodeH264PictureInfoKHR& copy_src); + safe_VkVideoEncodeH264PictureInfoKHR(); + ~safe_VkVideoEncodeH264PictureInfoKHR(); + void initialize(const VkVideoEncodeH264PictureInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH264PictureInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH264PictureInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeH264PictureInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkAttachmentSampleCountInfoAMD { +struct safe_VkVideoEncodeH264DpbSlotInfoKHR { VkStructureType sType; const void* pNext{}; - uint32_t colorAttachmentCount; - const VkSampleCountFlagBits* pColorAttachmentSamples{}; - VkSampleCountFlagBits depthStencilAttachmentSamples; + const StdVideoEncodeH264ReferenceInfo* pStdReferenceInfo{}; - safe_VkAttachmentSampleCountInfoAMD(const VkAttachmentSampleCountInfoAMD* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkAttachmentSampleCountInfoAMD(const safe_VkAttachmentSampleCountInfoAMD& copy_src); - safe_VkAttachmentSampleCountInfoAMD& operator=(const safe_VkAttachmentSampleCountInfoAMD& copy_src); - safe_VkAttachmentSampleCountInfoAMD(); - ~safe_VkAttachmentSampleCountInfoAMD(); - void initialize(const VkAttachmentSampleCountInfoAMD* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkAttachmentSampleCountInfoAMD* copy_src, PNextCopyState* copy_state = {}); - VkAttachmentSampleCountInfoAMD* ptr() { return reinterpret_cast(this); } - VkAttachmentSampleCountInfoAMD const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoEncodeH264DpbSlotInfoKHR(const VkVideoEncodeH264DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoEncodeH264DpbSlotInfoKHR(const safe_VkVideoEncodeH264DpbSlotInfoKHR& copy_src); + safe_VkVideoEncodeH264DpbSlotInfoKHR& operator=(const safe_VkVideoEncodeH264DpbSlotInfoKHR& copy_src); + safe_VkVideoEncodeH264DpbSlotInfoKHR(); + ~safe_VkVideoEncodeH264DpbSlotInfoKHR(); + void initialize(const VkVideoEncodeH264DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH264DpbSlotInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH264DpbSlotInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeH264DpbSlotInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkMultiviewPerViewAttributesInfoNVX { +struct safe_VkVideoEncodeH264ProfileInfoKHR { VkStructureType sType; const void* pNext{}; - VkBool32 perViewAttributes; - VkBool32 perViewAttributesPositionXOnly; + StdVideoH264ProfileIdc stdProfileIdc; - safe_VkMultiviewPerViewAttributesInfoNVX(const VkMultiviewPerViewAttributesInfoNVX* in_struct, PNextCopyState* copy_state = {}, + safe_VkVideoEncodeH264ProfileInfoKHR(const VkVideoEncodeH264ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoEncodeH264ProfileInfoKHR(const safe_VkVideoEncodeH264ProfileInfoKHR& copy_src); + safe_VkVideoEncodeH264ProfileInfoKHR& operator=(const safe_VkVideoEncodeH264ProfileInfoKHR& copy_src); + safe_VkVideoEncodeH264ProfileInfoKHR(); + ~safe_VkVideoEncodeH264ProfileInfoKHR(); + void initialize(const VkVideoEncodeH264ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH264ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH264ProfileInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeH264ProfileInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoEncodeH264RateControlInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkVideoEncodeH264RateControlFlagsKHR flags; + uint32_t gopFrameCount; + uint32_t idrPeriod; + uint32_t consecutiveBFrameCount; + uint32_t temporalLayerCount; + + safe_VkVideoEncodeH264RateControlInfoKHR(const VkVideoEncodeH264RateControlInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkMultiviewPerViewAttributesInfoNVX(const safe_VkMultiviewPerViewAttributesInfoNVX& copy_src); - safe_VkMultiviewPerViewAttributesInfoNVX& operator=(const safe_VkMultiviewPerViewAttributesInfoNVX& copy_src); - safe_VkMultiviewPerViewAttributesInfoNVX(); - ~safe_VkMultiviewPerViewAttributesInfoNVX(); - void initialize(const VkMultiviewPerViewAttributesInfoNVX* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkMultiviewPerViewAttributesInfoNVX* copy_src, PNextCopyState* copy_state = {}); - VkMultiviewPerViewAttributesInfoNVX* ptr() { return reinterpret_cast(this); } - VkMultiviewPerViewAttributesInfoNVX const* ptr() const { - return reinterpret_cast(this); + safe_VkVideoEncodeH264RateControlInfoKHR(const safe_VkVideoEncodeH264RateControlInfoKHR& copy_src); + safe_VkVideoEncodeH264RateControlInfoKHR& operator=(const safe_VkVideoEncodeH264RateControlInfoKHR& copy_src); + safe_VkVideoEncodeH264RateControlInfoKHR(); + ~safe_VkVideoEncodeH264RateControlInfoKHR(); + void initialize(const VkVideoEncodeH264RateControlInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH264RateControlInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH264RateControlInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeH264RateControlInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -#ifdef VK_USE_PLATFORM_WIN32_KHR -struct safe_VkImportMemoryWin32HandleInfoKHR { +struct safe_VkVideoEncodeH264RateControlLayerInfoKHR { VkStructureType sType; const void* pNext{}; - VkExternalMemoryHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; + VkBool32 useMinQp; + VkVideoEncodeH264QpKHR minQp; + VkBool32 useMaxQp; + VkVideoEncodeH264QpKHR maxQp; + VkBool32 useMaxFrameSize; + VkVideoEncodeH264FrameSizeKHR maxFrameSize; - safe_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkImportMemoryWin32HandleInfoKHR(const safe_VkImportMemoryWin32HandleInfoKHR& copy_src); - safe_VkImportMemoryWin32HandleInfoKHR& operator=(const safe_VkImportMemoryWin32HandleInfoKHR& copy_src); - safe_VkImportMemoryWin32HandleInfoKHR(); - ~safe_VkImportMemoryWin32HandleInfoKHR(); - void initialize(const VkImportMemoryWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkImportMemoryWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkImportMemoryWin32HandleInfoKHR* ptr() { return reinterpret_cast(this); } - VkImportMemoryWin32HandleInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoEncodeH264RateControlLayerInfoKHR(const VkVideoEncodeH264RateControlLayerInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeH264RateControlLayerInfoKHR(const safe_VkVideoEncodeH264RateControlLayerInfoKHR& copy_src); + safe_VkVideoEncodeH264RateControlLayerInfoKHR& operator=(const safe_VkVideoEncodeH264RateControlLayerInfoKHR& copy_src); + safe_VkVideoEncodeH264RateControlLayerInfoKHR(); + ~safe_VkVideoEncodeH264RateControlLayerInfoKHR(); + void initialize(const VkVideoEncodeH264RateControlLayerInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH264RateControlLayerInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH264RateControlLayerInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeH264RateControlLayerInfoKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkExportMemoryWin32HandleInfoKHR { +struct safe_VkVideoEncodeH264GopRemainingFrameInfoKHR { VkStructureType sType; const void* pNext{}; - const SECURITY_ATTRIBUTES* pAttributes{}; - DWORD dwAccess; - LPCWSTR name; + VkBool32 useGopRemainingFrames; + uint32_t gopRemainingI; + uint32_t gopRemainingP; + uint32_t gopRemainingB; - safe_VkExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkExportMemoryWin32HandleInfoKHR(const safe_VkExportMemoryWin32HandleInfoKHR& copy_src); - safe_VkExportMemoryWin32HandleInfoKHR& operator=(const safe_VkExportMemoryWin32HandleInfoKHR& copy_src); - safe_VkExportMemoryWin32HandleInfoKHR(); - ~safe_VkExportMemoryWin32HandleInfoKHR(); - void initialize(const VkExportMemoryWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkExportMemoryWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkExportMemoryWin32HandleInfoKHR* ptr() { return reinterpret_cast(this); } - VkExportMemoryWin32HandleInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoEncodeH264GopRemainingFrameInfoKHR(const VkVideoEncodeH264GopRemainingFrameInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeH264GopRemainingFrameInfoKHR(const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR& copy_src); + safe_VkVideoEncodeH264GopRemainingFrameInfoKHR& operator=(const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR& copy_src); + safe_VkVideoEncodeH264GopRemainingFrameInfoKHR(); + ~safe_VkVideoEncodeH264GopRemainingFrameInfoKHR(); + void initialize(const VkVideoEncodeH264GopRemainingFrameInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH264GopRemainingFrameInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeH264GopRemainingFrameInfoKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkMemoryWin32HandlePropertiesKHR { +struct safe_VkVideoEncodeH265CapabilitiesKHR { VkStructureType sType; void* pNext{}; - uint32_t memoryTypeBits; - - safe_VkMemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkMemoryWin32HandlePropertiesKHR(const safe_VkMemoryWin32HandlePropertiesKHR& copy_src); - safe_VkMemoryWin32HandlePropertiesKHR& operator=(const safe_VkMemoryWin32HandlePropertiesKHR& copy_src); - safe_VkMemoryWin32HandlePropertiesKHR(); - ~safe_VkMemoryWin32HandlePropertiesKHR(); - void initialize(const VkMemoryWin32HandlePropertiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkMemoryWin32HandlePropertiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkMemoryWin32HandlePropertiesKHR* ptr() { return reinterpret_cast(this); } - VkMemoryWin32HandlePropertiesKHR const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkMemoryGetWin32HandleInfoKHR { - VkStructureType sType; - const void* pNext{}; - VkDeviceMemory memory; - VkExternalMemoryHandleTypeFlagBits handleType; + VkVideoEncodeH265CapabilityFlagsKHR flags; + StdVideoH265LevelIdc maxLevelIdc; + uint32_t maxSliceSegmentCount; + VkExtent2D maxTiles; + VkVideoEncodeH265CtbSizeFlagsKHR ctbSizes; + VkVideoEncodeH265TransformBlockSizeFlagsKHR transformBlockSizes; + uint32_t maxPPictureL0ReferenceCount; + uint32_t maxBPictureL0ReferenceCount; + uint32_t maxL1ReferenceCount; + uint32_t maxSubLayerCount; + VkBool32 expectDyadicTemporalSubLayerPattern; + int32_t minQp; + int32_t maxQp; + VkBool32 prefersGopRemainingFrames; + VkBool32 requiresGopRemainingFrames; + VkVideoEncodeH265StdFlagsKHR stdSyntaxFlags; - safe_VkMemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkMemoryGetWin32HandleInfoKHR(const safe_VkMemoryGetWin32HandleInfoKHR& copy_src); - safe_VkMemoryGetWin32HandleInfoKHR& operator=(const safe_VkMemoryGetWin32HandleInfoKHR& copy_src); - safe_VkMemoryGetWin32HandleInfoKHR(); - ~safe_VkMemoryGetWin32HandleInfoKHR(); - void initialize(const VkMemoryGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkMemoryGetWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkMemoryGetWin32HandleInfoKHR* ptr() { return reinterpret_cast(this); } - VkMemoryGetWin32HandleInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoEncodeH265CapabilitiesKHR(const VkVideoEncodeH265CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoEncodeH265CapabilitiesKHR(const safe_VkVideoEncodeH265CapabilitiesKHR& copy_src); + safe_VkVideoEncodeH265CapabilitiesKHR& operator=(const safe_VkVideoEncodeH265CapabilitiesKHR& copy_src); + safe_VkVideoEncodeH265CapabilitiesKHR(); + ~safe_VkVideoEncodeH265CapabilitiesKHR(); + void initialize(const VkVideoEncodeH265CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH265CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH265CapabilitiesKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeH265CapabilitiesKHR const* ptr() const { return reinterpret_cast(this); } }; -#endif // VK_USE_PLATFORM_WIN32_KHR -struct safe_VkImportMemoryFdInfoKHR { +struct safe_VkVideoEncodeH265SessionCreateInfoKHR { VkStructureType sType; const void* pNext{}; - VkExternalMemoryHandleTypeFlagBits handleType; - int fd; + VkBool32 useMaxLevelIdc; + StdVideoH265LevelIdc maxLevelIdc; - safe_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkImportMemoryFdInfoKHR(const safe_VkImportMemoryFdInfoKHR& copy_src); - safe_VkImportMemoryFdInfoKHR& operator=(const safe_VkImportMemoryFdInfoKHR& copy_src); - safe_VkImportMemoryFdInfoKHR(); - ~safe_VkImportMemoryFdInfoKHR(); - void initialize(const VkImportMemoryFdInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkImportMemoryFdInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkImportMemoryFdInfoKHR* ptr() { return reinterpret_cast(this); } - VkImportMemoryFdInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoEncodeH265SessionCreateInfoKHR(const VkVideoEncodeH265SessionCreateInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeH265SessionCreateInfoKHR(const safe_VkVideoEncodeH265SessionCreateInfoKHR& copy_src); + safe_VkVideoEncodeH265SessionCreateInfoKHR& operator=(const safe_VkVideoEncodeH265SessionCreateInfoKHR& copy_src); + safe_VkVideoEncodeH265SessionCreateInfoKHR(); + ~safe_VkVideoEncodeH265SessionCreateInfoKHR(); + void initialize(const VkVideoEncodeH265SessionCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH265SessionCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH265SessionCreateInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeH265SessionCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkMemoryFdPropertiesKHR { +struct safe_VkVideoEncodeH265QualityLevelPropertiesKHR { VkStructureType sType; void* pNext{}; - uint32_t memoryTypeBits; + VkVideoEncodeH265RateControlFlagsKHR preferredRateControlFlags; + uint32_t preferredGopFrameCount; + uint32_t preferredIdrPeriod; + uint32_t preferredConsecutiveBFrameCount; + uint32_t preferredSubLayerCount; + VkVideoEncodeH265QpKHR preferredConstantQp; + uint32_t preferredMaxL0ReferenceCount; + uint32_t preferredMaxL1ReferenceCount; - safe_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkMemoryFdPropertiesKHR(const safe_VkMemoryFdPropertiesKHR& copy_src); - safe_VkMemoryFdPropertiesKHR& operator=(const safe_VkMemoryFdPropertiesKHR& copy_src); - safe_VkMemoryFdPropertiesKHR(); - ~safe_VkMemoryFdPropertiesKHR(); - void initialize(const VkMemoryFdPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkMemoryFdPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkMemoryFdPropertiesKHR* ptr() { return reinterpret_cast(this); } - VkMemoryFdPropertiesKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoEncodeH265QualityLevelPropertiesKHR(const VkVideoEncodeH265QualityLevelPropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeH265QualityLevelPropertiesKHR(const safe_VkVideoEncodeH265QualityLevelPropertiesKHR& copy_src); + safe_VkVideoEncodeH265QualityLevelPropertiesKHR& operator=(const safe_VkVideoEncodeH265QualityLevelPropertiesKHR& copy_src); + safe_VkVideoEncodeH265QualityLevelPropertiesKHR(); + ~safe_VkVideoEncodeH265QualityLevelPropertiesKHR(); + void initialize(const VkVideoEncodeH265QualityLevelPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH265QualityLevelPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH265QualityLevelPropertiesKHR* ptr() { + return reinterpret_cast(this); + } + VkVideoEncodeH265QualityLevelPropertiesKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkMemoryGetFdInfoKHR { +struct safe_VkVideoEncodeH265SessionParametersAddInfoKHR { VkStructureType sType; const void* pNext{}; - VkDeviceMemory memory; - VkExternalMemoryHandleTypeFlagBits handleType; + uint32_t stdVPSCount; + const StdVideoH265VideoParameterSet* pStdVPSs{}; + uint32_t stdSPSCount; + const StdVideoH265SequenceParameterSet* pStdSPSs{}; + uint32_t stdPPSCount; + const StdVideoH265PictureParameterSet* pStdPPSs{}; - safe_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkMemoryGetFdInfoKHR(const safe_VkMemoryGetFdInfoKHR& copy_src); - safe_VkMemoryGetFdInfoKHR& operator=(const safe_VkMemoryGetFdInfoKHR& copy_src); - safe_VkMemoryGetFdInfoKHR(); - ~safe_VkMemoryGetFdInfoKHR(); - void initialize(const VkMemoryGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkMemoryGetFdInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkMemoryGetFdInfoKHR* ptr() { return reinterpret_cast(this); } - VkMemoryGetFdInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoEncodeH265SessionParametersAddInfoKHR(const VkVideoEncodeH265SessionParametersAddInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeH265SessionParametersAddInfoKHR(const safe_VkVideoEncodeH265SessionParametersAddInfoKHR& copy_src); + safe_VkVideoEncodeH265SessionParametersAddInfoKHR& operator=(const safe_VkVideoEncodeH265SessionParametersAddInfoKHR& copy_src); + safe_VkVideoEncodeH265SessionParametersAddInfoKHR(); + ~safe_VkVideoEncodeH265SessionParametersAddInfoKHR(); + void initialize(const VkVideoEncodeH265SessionParametersAddInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH265SessionParametersAddInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH265SessionParametersAddInfoKHR* ptr() { + return reinterpret_cast(this); + } + VkVideoEncodeH265SessionParametersAddInfoKHR const* ptr() const { + return reinterpret_cast(this); + } }; -#ifdef VK_USE_PLATFORM_WIN32_KHR -struct safe_VkWin32KeyedMutexAcquireReleaseInfoKHR { +struct safe_VkVideoEncodeH265SessionParametersCreateInfoKHR { VkStructureType sType; const void* pNext{}; - uint32_t acquireCount; - VkDeviceMemory* pAcquireSyncs{}; - const uint64_t* pAcquireKeys{}; - const uint32_t* pAcquireTimeouts{}; - uint32_t releaseCount; - VkDeviceMemory* pReleaseSyncs{}; - const uint64_t* pReleaseKeys{}; + uint32_t maxStdVPSCount; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + safe_VkVideoEncodeH265SessionParametersAddInfoKHR* pParametersAddInfo{}; - safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src); - safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& operator=(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src); - safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(); - ~safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(); - void initialize(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkWin32KeyedMutexAcquireReleaseInfoKHR* ptr() { return reinterpret_cast(this); } - VkWin32KeyedMutexAcquireReleaseInfoKHR const* ptr() const { - return reinterpret_cast(this); + safe_VkVideoEncodeH265SessionParametersCreateInfoKHR(const VkVideoEncodeH265SessionParametersCreateInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeH265SessionParametersCreateInfoKHR(const safe_VkVideoEncodeH265SessionParametersCreateInfoKHR& copy_src); + safe_VkVideoEncodeH265SessionParametersCreateInfoKHR& operator=( + const safe_VkVideoEncodeH265SessionParametersCreateInfoKHR& copy_src); + safe_VkVideoEncodeH265SessionParametersCreateInfoKHR(); + ~safe_VkVideoEncodeH265SessionParametersCreateInfoKHR(); + void initialize(const VkVideoEncodeH265SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH265SessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH265SessionParametersCreateInfoKHR* ptr() { + return reinterpret_cast(this); + } + VkVideoEncodeH265SessionParametersCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkImportSemaphoreWin32HandleInfoKHR { +struct safe_VkVideoEncodeH265SessionParametersGetInfoKHR { VkStructureType sType; const void* pNext{}; - VkSemaphore semaphore; - VkSemaphoreImportFlags flags; - VkExternalSemaphoreHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; + VkBool32 writeStdVPS; + VkBool32 writeStdSPS; + VkBool32 writeStdPPS; + uint32_t stdVPSId; + uint32_t stdSPSId; + uint32_t stdPPSId; - safe_VkImportSemaphoreWin32HandleInfoKHR(const VkImportSemaphoreWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkImportSemaphoreWin32HandleInfoKHR(const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src); - safe_VkImportSemaphoreWin32HandleInfoKHR& operator=(const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src); - safe_VkImportSemaphoreWin32HandleInfoKHR(); - ~safe_VkImportSemaphoreWin32HandleInfoKHR(); - void initialize(const VkImportSemaphoreWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkImportSemaphoreWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkImportSemaphoreWin32HandleInfoKHR* ptr() { return reinterpret_cast(this); } - VkImportSemaphoreWin32HandleInfoKHR const* ptr() const { - return reinterpret_cast(this); + safe_VkVideoEncodeH265SessionParametersGetInfoKHR(const VkVideoEncodeH265SessionParametersGetInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeH265SessionParametersGetInfoKHR(const safe_VkVideoEncodeH265SessionParametersGetInfoKHR& copy_src); + safe_VkVideoEncodeH265SessionParametersGetInfoKHR& operator=(const safe_VkVideoEncodeH265SessionParametersGetInfoKHR& copy_src); + safe_VkVideoEncodeH265SessionParametersGetInfoKHR(); + ~safe_VkVideoEncodeH265SessionParametersGetInfoKHR(); + void initialize(const VkVideoEncodeH265SessionParametersGetInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH265SessionParametersGetInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH265SessionParametersGetInfoKHR* ptr() { + return reinterpret_cast(this); + } + VkVideoEncodeH265SessionParametersGetInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkExportSemaphoreWin32HandleInfoKHR { +struct safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR { VkStructureType sType; - const void* pNext{}; - const SECURITY_ATTRIBUTES* pAttributes{}; - DWORD dwAccess; - LPCWSTR name; + void* pNext{}; + VkBool32 hasStdVPSOverrides; + VkBool32 hasStdSPSOverrides; + VkBool32 hasStdPPSOverrides; - safe_VkExportSemaphoreWin32HandleInfoKHR(const VkExportSemaphoreWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkExportSemaphoreWin32HandleInfoKHR(const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src); - safe_VkExportSemaphoreWin32HandleInfoKHR& operator=(const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src); - safe_VkExportSemaphoreWin32HandleInfoKHR(); - ~safe_VkExportSemaphoreWin32HandleInfoKHR(); - void initialize(const VkExportSemaphoreWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkExportSemaphoreWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkExportSemaphoreWin32HandleInfoKHR* ptr() { return reinterpret_cast(this); } - VkExportSemaphoreWin32HandleInfoKHR const* ptr() const { - return reinterpret_cast(this); + safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR(const VkVideoEncodeH265SessionParametersFeedbackInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR(const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR& copy_src); + safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR& operator=( + const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR& copy_src); + safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR(); + ~safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR(); + void initialize(const VkVideoEncodeH265SessionParametersFeedbackInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH265SessionParametersFeedbackInfoKHR* ptr() { + return reinterpret_cast(this); + } + VkVideoEncodeH265SessionParametersFeedbackInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkD3D12FenceSubmitInfoKHR { +struct safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR { VkStructureType sType; const void* pNext{}; - uint32_t waitSemaphoreValuesCount; - const uint64_t* pWaitSemaphoreValues{}; - uint32_t signalSemaphoreValuesCount; - const uint64_t* pSignalSemaphoreValues{}; + int32_t constantQp; + const StdVideoEncodeH265SliceSegmentHeader* pStdSliceSegmentHeader{}; - safe_VkD3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkD3D12FenceSubmitInfoKHR(const safe_VkD3D12FenceSubmitInfoKHR& copy_src); - safe_VkD3D12FenceSubmitInfoKHR& operator=(const safe_VkD3D12FenceSubmitInfoKHR& copy_src); - safe_VkD3D12FenceSubmitInfoKHR(); - ~safe_VkD3D12FenceSubmitInfoKHR(); - void initialize(const VkD3D12FenceSubmitInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkD3D12FenceSubmitInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkD3D12FenceSubmitInfoKHR* ptr() { return reinterpret_cast(this); } - VkD3D12FenceSubmitInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR(const VkVideoEncodeH265NaluSliceSegmentInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR(const safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR& copy_src); + safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR& operator=(const safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR& copy_src); + safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR(); + ~safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR(); + void initialize(const VkVideoEncodeH265NaluSliceSegmentInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH265NaluSliceSegmentInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeH265NaluSliceSegmentInfoKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkSemaphoreGetWin32HandleInfoKHR { +struct safe_VkVideoEncodeH265PictureInfoKHR { VkStructureType sType; const void* pNext{}; - VkSemaphore semaphore; - VkExternalSemaphoreHandleTypeFlagBits handleType; + uint32_t naluSliceSegmentEntryCount; + safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR* pNaluSliceSegmentEntries{}; + const StdVideoEncodeH265PictureInfo* pStdPictureInfo{}; - safe_VkSemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkSemaphoreGetWin32HandleInfoKHR(const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src); - safe_VkSemaphoreGetWin32HandleInfoKHR& operator=(const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src); - safe_VkSemaphoreGetWin32HandleInfoKHR(); - ~safe_VkSemaphoreGetWin32HandleInfoKHR(); - void initialize(const VkSemaphoreGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkSemaphoreGetWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkSemaphoreGetWin32HandleInfoKHR* ptr() { return reinterpret_cast(this); } - VkSemaphoreGetWin32HandleInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoEncodeH265PictureInfoKHR(const VkVideoEncodeH265PictureInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoEncodeH265PictureInfoKHR(const safe_VkVideoEncodeH265PictureInfoKHR& copy_src); + safe_VkVideoEncodeH265PictureInfoKHR& operator=(const safe_VkVideoEncodeH265PictureInfoKHR& copy_src); + safe_VkVideoEncodeH265PictureInfoKHR(); + ~safe_VkVideoEncodeH265PictureInfoKHR(); + void initialize(const VkVideoEncodeH265PictureInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH265PictureInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH265PictureInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeH265PictureInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -#endif // VK_USE_PLATFORM_WIN32_KHR -struct safe_VkImportSemaphoreFdInfoKHR { +struct safe_VkVideoEncodeH265DpbSlotInfoKHR { VkStructureType sType; const void* pNext{}; - VkSemaphore semaphore; - VkSemaphoreImportFlags flags; - VkExternalSemaphoreHandleTypeFlagBits handleType; - int fd; + const StdVideoEncodeH265ReferenceInfo* pStdReferenceInfo{}; - safe_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkImportSemaphoreFdInfoKHR(const safe_VkImportSemaphoreFdInfoKHR& copy_src); - safe_VkImportSemaphoreFdInfoKHR& operator=(const safe_VkImportSemaphoreFdInfoKHR& copy_src); - safe_VkImportSemaphoreFdInfoKHR(); - ~safe_VkImportSemaphoreFdInfoKHR(); - void initialize(const VkImportSemaphoreFdInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkImportSemaphoreFdInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkImportSemaphoreFdInfoKHR* ptr() { return reinterpret_cast(this); } - VkImportSemaphoreFdInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoEncodeH265DpbSlotInfoKHR(const VkVideoEncodeH265DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoEncodeH265DpbSlotInfoKHR(const safe_VkVideoEncodeH265DpbSlotInfoKHR& copy_src); + safe_VkVideoEncodeH265DpbSlotInfoKHR& operator=(const safe_VkVideoEncodeH265DpbSlotInfoKHR& copy_src); + safe_VkVideoEncodeH265DpbSlotInfoKHR(); + ~safe_VkVideoEncodeH265DpbSlotInfoKHR(); + void initialize(const VkVideoEncodeH265DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH265DpbSlotInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH265DpbSlotInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeH265DpbSlotInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkSemaphoreGetFdInfoKHR { +struct safe_VkVideoEncodeH265ProfileInfoKHR { VkStructureType sType; const void* pNext{}; - VkSemaphore semaphore; - VkExternalSemaphoreHandleTypeFlagBits handleType; + StdVideoH265ProfileIdc stdProfileIdc; - safe_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkSemaphoreGetFdInfoKHR(const safe_VkSemaphoreGetFdInfoKHR& copy_src); - safe_VkSemaphoreGetFdInfoKHR& operator=(const safe_VkSemaphoreGetFdInfoKHR& copy_src); - safe_VkSemaphoreGetFdInfoKHR(); - ~safe_VkSemaphoreGetFdInfoKHR(); - void initialize(const VkSemaphoreGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkSemaphoreGetFdInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkSemaphoreGetFdInfoKHR* ptr() { return reinterpret_cast(this); } - VkSemaphoreGetFdInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoEncodeH265ProfileInfoKHR(const VkVideoEncodeH265ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoEncodeH265ProfileInfoKHR(const safe_VkVideoEncodeH265ProfileInfoKHR& copy_src); + safe_VkVideoEncodeH265ProfileInfoKHR& operator=(const safe_VkVideoEncodeH265ProfileInfoKHR& copy_src); + safe_VkVideoEncodeH265ProfileInfoKHR(); + ~safe_VkVideoEncodeH265ProfileInfoKHR(); + void initialize(const VkVideoEncodeH265ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH265ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH265ProfileInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeH265ProfileInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPhysicalDevicePushDescriptorPropertiesKHR { +struct safe_VkVideoEncodeH265RateControlInfoKHR { VkStructureType sType; - void* pNext{}; - uint32_t maxPushDescriptors; + const void* pNext{}; + VkVideoEncodeH265RateControlFlagsKHR flags; + uint32_t gopFrameCount; + uint32_t idrPeriod; + uint32_t consecutiveBFrameCount; + uint32_t subLayerCount; - 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); + safe_VkVideoEncodeH265RateControlInfoKHR(const VkVideoEncodeH265RateControlInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoEncodeH265RateControlInfoKHR(const safe_VkVideoEncodeH265RateControlInfoKHR& copy_src); + safe_VkVideoEncodeH265RateControlInfoKHR& operator=(const safe_VkVideoEncodeH265RateControlInfoKHR& copy_src); + safe_VkVideoEncodeH265RateControlInfoKHR(); + ~safe_VkVideoEncodeH265RateControlInfoKHR(); + void initialize(const VkVideoEncodeH265RateControlInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH265RateControlInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH265RateControlInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeH265RateControlInfoKHR const* ptr() const { + return reinterpret_cast(this); } - VkPhysicalDevicePushDescriptorPropertiesKHR const* ptr() const { - return reinterpret_cast(this); +}; +struct safe_VkVideoEncodeH265RateControlLayerInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkBool32 useMinQp; + VkVideoEncodeH265QpKHR minQp; + VkBool32 useMaxQp; + VkVideoEncodeH265QpKHR maxQp; + VkBool32 useMaxFrameSize; + VkVideoEncodeH265FrameSizeKHR maxFrameSize; + + safe_VkVideoEncodeH265RateControlLayerInfoKHR(const VkVideoEncodeH265RateControlLayerInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeH265RateControlLayerInfoKHR(const safe_VkVideoEncodeH265RateControlLayerInfoKHR& copy_src); + safe_VkVideoEncodeH265RateControlLayerInfoKHR& operator=(const safe_VkVideoEncodeH265RateControlLayerInfoKHR& copy_src); + safe_VkVideoEncodeH265RateControlLayerInfoKHR(); + ~safe_VkVideoEncodeH265RateControlLayerInfoKHR(); + void initialize(const VkVideoEncodeH265RateControlLayerInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH265RateControlLayerInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH265RateControlLayerInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeH265RateControlLayerInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkPresentRegionKHR { - uint32_t rectangleCount; - const VkRectLayerKHR* pRectangles{}; +struct safe_VkVideoEncodeH265GopRemainingFrameInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkBool32 useGopRemainingFrames; + uint32_t gopRemainingI; + uint32_t gopRemainingP; + uint32_t gopRemainingB; - safe_VkPresentRegionKHR(const VkPresentRegionKHR* in_struct, PNextCopyState* copy_state = {}); - safe_VkPresentRegionKHR(const safe_VkPresentRegionKHR& copy_src); - safe_VkPresentRegionKHR& operator=(const safe_VkPresentRegionKHR& copy_src); - safe_VkPresentRegionKHR(); - ~safe_VkPresentRegionKHR(); - void initialize(const VkPresentRegionKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPresentRegionKHR* copy_src, PNextCopyState* copy_state = {}); - VkPresentRegionKHR* ptr() { return reinterpret_cast(this); } - VkPresentRegionKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoEncodeH265GopRemainingFrameInfoKHR(const VkVideoEncodeH265GopRemainingFrameInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeH265GopRemainingFrameInfoKHR(const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR& copy_src); + safe_VkVideoEncodeH265GopRemainingFrameInfoKHR& operator=(const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR& copy_src); + safe_VkVideoEncodeH265GopRemainingFrameInfoKHR(); + ~safe_VkVideoEncodeH265GopRemainingFrameInfoKHR(); + void initialize(const VkVideoEncodeH265GopRemainingFrameInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeH265GopRemainingFrameInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeH265GopRemainingFrameInfoKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkPresentRegionsKHR { +struct safe_VkVideoDecodeH264ProfileInfoKHR { VkStructureType sType; const void* pNext{}; - uint32_t swapchainCount; - safe_VkPresentRegionKHR* pRegions{}; + StdVideoH264ProfileIdc stdProfileIdc; + VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout; - safe_VkPresentRegionsKHR(const VkPresentRegionsKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPresentRegionsKHR(const safe_VkPresentRegionsKHR& copy_src); - safe_VkPresentRegionsKHR& operator=(const safe_VkPresentRegionsKHR& copy_src); - safe_VkPresentRegionsKHR(); - ~safe_VkPresentRegionsKHR(); - void initialize(const VkPresentRegionsKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPresentRegionsKHR* copy_src, PNextCopyState* copy_state = {}); - VkPresentRegionsKHR* ptr() { return reinterpret_cast(this); } - VkPresentRegionsKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoDecodeH264ProfileInfoKHR(const VkVideoDecodeH264ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoDecodeH264ProfileInfoKHR(const safe_VkVideoDecodeH264ProfileInfoKHR& copy_src); + safe_VkVideoDecodeH264ProfileInfoKHR& operator=(const safe_VkVideoDecodeH264ProfileInfoKHR& copy_src); + safe_VkVideoDecodeH264ProfileInfoKHR(); + ~safe_VkVideoDecodeH264ProfileInfoKHR(); + void initialize(const VkVideoDecodeH264ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeH264ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeH264ProfileInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoDecodeH264ProfileInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkSharedPresentSurfaceCapabilitiesKHR { +struct safe_VkVideoDecodeH264CapabilitiesKHR { VkStructureType sType; void* pNext{}; - VkImageUsageFlags sharedPresentSupportedUsageFlags; + StdVideoH264LevelIdc maxLevelIdc; + VkOffset2D fieldOffsetGranularity; - safe_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkSharedPresentSurfaceCapabilitiesKHR(const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src); - safe_VkSharedPresentSurfaceCapabilitiesKHR& operator=(const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src); - safe_VkSharedPresentSurfaceCapabilitiesKHR(); - ~safe_VkSharedPresentSurfaceCapabilitiesKHR(); - void initialize(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkSharedPresentSurfaceCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkSharedPresentSurfaceCapabilitiesKHR* ptr() { return reinterpret_cast(this); } - VkSharedPresentSurfaceCapabilitiesKHR const* ptr() const { - return reinterpret_cast(this); - } + safe_VkVideoDecodeH264CapabilitiesKHR(const VkVideoDecodeH264CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoDecodeH264CapabilitiesKHR(const safe_VkVideoDecodeH264CapabilitiesKHR& copy_src); + safe_VkVideoDecodeH264CapabilitiesKHR& operator=(const safe_VkVideoDecodeH264CapabilitiesKHR& copy_src); + safe_VkVideoDecodeH264CapabilitiesKHR(); + ~safe_VkVideoDecodeH264CapabilitiesKHR(); + void initialize(const VkVideoDecodeH264CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeH264CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeH264CapabilitiesKHR* ptr() { return reinterpret_cast(this); } + VkVideoDecodeH264CapabilitiesKHR const* ptr() const { return reinterpret_cast(this); } }; -#ifdef VK_USE_PLATFORM_WIN32_KHR -struct safe_VkImportFenceWin32HandleInfoKHR { +struct safe_VkVideoDecodeH264SessionParametersAddInfoKHR { VkStructureType sType; const void* pNext{}; - VkFence fence; - VkFenceImportFlags flags; - VkExternalFenceHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; + uint32_t stdSPSCount; + const StdVideoH264SequenceParameterSet* pStdSPSs{}; + uint32_t stdPPSCount; + const StdVideoH264PictureParameterSet* pStdPPSs{}; - safe_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkImportFenceWin32HandleInfoKHR(const safe_VkImportFenceWin32HandleInfoKHR& copy_src); - safe_VkImportFenceWin32HandleInfoKHR& operator=(const safe_VkImportFenceWin32HandleInfoKHR& copy_src); - safe_VkImportFenceWin32HandleInfoKHR(); - ~safe_VkImportFenceWin32HandleInfoKHR(); - void initialize(const VkImportFenceWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkImportFenceWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkImportFenceWin32HandleInfoKHR* ptr() { return reinterpret_cast(this); } - VkImportFenceWin32HandleInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoDecodeH264SessionParametersAddInfoKHR(const VkVideoDecodeH264SessionParametersAddInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoDecodeH264SessionParametersAddInfoKHR(const safe_VkVideoDecodeH264SessionParametersAddInfoKHR& copy_src); + safe_VkVideoDecodeH264SessionParametersAddInfoKHR& operator=(const safe_VkVideoDecodeH264SessionParametersAddInfoKHR& copy_src); + safe_VkVideoDecodeH264SessionParametersAddInfoKHR(); + ~safe_VkVideoDecodeH264SessionParametersAddInfoKHR(); + void initialize(const VkVideoDecodeH264SessionParametersAddInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeH264SessionParametersAddInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeH264SessionParametersAddInfoKHR* ptr() { + return reinterpret_cast(this); + } + VkVideoDecodeH264SessionParametersAddInfoKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkExportFenceWin32HandleInfoKHR { +struct safe_VkVideoDecodeH264SessionParametersCreateInfoKHR { VkStructureType sType; const void* pNext{}; - const SECURITY_ATTRIBUTES* pAttributes{}; - DWORD dwAccess; - LPCWSTR name; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + safe_VkVideoDecodeH264SessionParametersAddInfoKHR* pParametersAddInfo{}; - safe_VkExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkExportFenceWin32HandleInfoKHR(const safe_VkExportFenceWin32HandleInfoKHR& copy_src); - safe_VkExportFenceWin32HandleInfoKHR& operator=(const safe_VkExportFenceWin32HandleInfoKHR& copy_src); - safe_VkExportFenceWin32HandleInfoKHR(); - ~safe_VkExportFenceWin32HandleInfoKHR(); - void initialize(const VkExportFenceWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkExportFenceWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkExportFenceWin32HandleInfoKHR* ptr() { return reinterpret_cast(this); } - VkExportFenceWin32HandleInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoDecodeH264SessionParametersCreateInfoKHR(const VkVideoDecodeH264SessionParametersCreateInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoDecodeH264SessionParametersCreateInfoKHR(const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& copy_src); + safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& operator=( + const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& copy_src); + safe_VkVideoDecodeH264SessionParametersCreateInfoKHR(); + ~safe_VkVideoDecodeH264SessionParametersCreateInfoKHR(); + void initialize(const VkVideoDecodeH264SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeH264SessionParametersCreateInfoKHR* ptr() { + return reinterpret_cast(this); + } + VkVideoDecodeH264SessionParametersCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkFenceGetWin32HandleInfoKHR { +struct safe_VkVideoDecodeH264PictureInfoKHR { VkStructureType sType; const void* pNext{}; - VkFence fence; - VkExternalFenceHandleTypeFlagBits handleType; + const StdVideoDecodeH264PictureInfo* pStdPictureInfo{}; + uint32_t sliceCount; + const uint32_t* pSliceOffsets{}; - safe_VkFenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkFenceGetWin32HandleInfoKHR(const safe_VkFenceGetWin32HandleInfoKHR& copy_src); - safe_VkFenceGetWin32HandleInfoKHR& operator=(const safe_VkFenceGetWin32HandleInfoKHR& copy_src); - safe_VkFenceGetWin32HandleInfoKHR(); - ~safe_VkFenceGetWin32HandleInfoKHR(); - void initialize(const VkFenceGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkFenceGetWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkFenceGetWin32HandleInfoKHR* ptr() { return reinterpret_cast(this); } - VkFenceGetWin32HandleInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoDecodeH264PictureInfoKHR(const VkVideoDecodeH264PictureInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoDecodeH264PictureInfoKHR(const safe_VkVideoDecodeH264PictureInfoKHR& copy_src); + safe_VkVideoDecodeH264PictureInfoKHR& operator=(const safe_VkVideoDecodeH264PictureInfoKHR& copy_src); + safe_VkVideoDecodeH264PictureInfoKHR(); + ~safe_VkVideoDecodeH264PictureInfoKHR(); + void initialize(const VkVideoDecodeH264PictureInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeH264PictureInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeH264PictureInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoDecodeH264PictureInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -#endif // VK_USE_PLATFORM_WIN32_KHR -struct safe_VkImportFenceFdInfoKHR { +struct safe_VkVideoDecodeH264DpbSlotInfoKHR { VkStructureType sType; const void* pNext{}; - VkFence fence; - VkFenceImportFlags flags; - VkExternalFenceHandleTypeFlagBits handleType; - int fd; + const StdVideoDecodeH264ReferenceInfo* pStdReferenceInfo{}; - safe_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkImportFenceFdInfoKHR(const safe_VkImportFenceFdInfoKHR& copy_src); - safe_VkImportFenceFdInfoKHR& operator=(const safe_VkImportFenceFdInfoKHR& copy_src); - safe_VkImportFenceFdInfoKHR(); - ~safe_VkImportFenceFdInfoKHR(); - void initialize(const VkImportFenceFdInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkImportFenceFdInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkImportFenceFdInfoKHR* ptr() { return reinterpret_cast(this); } - VkImportFenceFdInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoDecodeH264DpbSlotInfoKHR(const VkVideoDecodeH264DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoDecodeH264DpbSlotInfoKHR(const safe_VkVideoDecodeH264DpbSlotInfoKHR& copy_src); + safe_VkVideoDecodeH264DpbSlotInfoKHR& operator=(const safe_VkVideoDecodeH264DpbSlotInfoKHR& copy_src); + safe_VkVideoDecodeH264DpbSlotInfoKHR(); + ~safe_VkVideoDecodeH264DpbSlotInfoKHR(); + void initialize(const VkVideoDecodeH264DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeH264DpbSlotInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeH264DpbSlotInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoDecodeH264DpbSlotInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkFenceGetFdInfoKHR { +struct safe_VkRenderingFragmentShadingRateAttachmentInfoKHR { VkStructureType sType; const void* pNext{}; - VkFence fence; - VkExternalFenceHandleTypeFlagBits handleType; - - safe_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkFenceGetFdInfoKHR(const safe_VkFenceGetFdInfoKHR& copy_src); - safe_VkFenceGetFdInfoKHR& operator=(const safe_VkFenceGetFdInfoKHR& copy_src); - safe_VkFenceGetFdInfoKHR(); - ~safe_VkFenceGetFdInfoKHR(); - void initialize(const VkFenceGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkFenceGetFdInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkFenceGetFdInfoKHR* ptr() { return reinterpret_cast(this); } - VkFenceGetFdInfoKHR const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkPhysicalDevicePerformanceQueryFeaturesKHR { - VkStructureType sType; - void* pNext{}; - VkBool32 performanceCounterQueryPools; - VkBool32 performanceCounterMultipleQueryPools; + VkImageView imageView; + VkImageLayout imageLayout; + VkExtent2D shadingRateAttachmentTexelSize; - safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src); - safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& operator=(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src); - safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(); - ~safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(); - void initialize(const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDevicePerformanceQueryFeaturesKHR* ptr() { - return reinterpret_cast(this); + safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src); + safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& operator=( + const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src); + safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(); + ~safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(); + void initialize(const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkRenderingFragmentShadingRateAttachmentInfoKHR* ptr() { + return reinterpret_cast(this); } - VkPhysicalDevicePerformanceQueryFeaturesKHR const* ptr() const { - return reinterpret_cast(this); + VkRenderingFragmentShadingRateAttachmentInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkPhysicalDevicePerformanceQueryPropertiesKHR { +struct safe_VkRenderingFragmentDensityMapAttachmentInfoEXT { VkStructureType sType; - void* pNext{}; - VkBool32 allowCommandBufferQueryCopies; + const void* pNext{}; + VkImageView imageView; + VkImageLayout imageLayout; - safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src); - safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& operator=( - const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src); - safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(); - ~safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(); - void initialize(const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDevicePerformanceQueryPropertiesKHR* ptr() { - return reinterpret_cast(this); + safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& copy_src); + safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& operator=( + const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& copy_src); + safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(); + ~safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(); + void initialize(const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkRenderingFragmentDensityMapAttachmentInfoEXT* ptr() { + return reinterpret_cast(this); } - VkPhysicalDevicePerformanceQueryPropertiesKHR const* ptr() const { - return reinterpret_cast(this); + VkRenderingFragmentDensityMapAttachmentInfoEXT const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkPerformanceCounterKHR { - VkStructureType sType; - void* pNext{}; - VkPerformanceCounterUnitKHR unit; - VkPerformanceCounterScopeKHR scope; - VkPerformanceCounterStorageKHR storage; - uint8_t uuid[VK_UUID_SIZE]; - - safe_VkPerformanceCounterKHR(const VkPerformanceCounterKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPerformanceCounterKHR(const safe_VkPerformanceCounterKHR& copy_src); - safe_VkPerformanceCounterKHR& operator=(const safe_VkPerformanceCounterKHR& copy_src); - safe_VkPerformanceCounterKHR(); - ~safe_VkPerformanceCounterKHR(); - void initialize(const VkPerformanceCounterKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPerformanceCounterKHR* copy_src, PNextCopyState* copy_state = {}); - VkPerformanceCounterKHR* ptr() { return reinterpret_cast(this); } - VkPerformanceCounterKHR const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkPerformanceCounterDescriptionKHR { +struct safe_VkAttachmentSampleCountInfoAMD { VkStructureType sType; - void* pNext{}; - VkPerformanceCounterDescriptionFlagsKHR flags; - char name[VK_MAX_DESCRIPTION_SIZE]; - char category[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; + const void* pNext{}; + uint32_t colorAttachmentCount; + const VkSampleCountFlagBits* pColorAttachmentSamples{}; + VkSampleCountFlagBits depthStencilAttachmentSamples; - safe_VkPerformanceCounterDescriptionKHR(const VkPerformanceCounterDescriptionKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkPerformanceCounterDescriptionKHR(const safe_VkPerformanceCounterDescriptionKHR& copy_src); - safe_VkPerformanceCounterDescriptionKHR& operator=(const safe_VkPerformanceCounterDescriptionKHR& copy_src); - safe_VkPerformanceCounterDescriptionKHR(); - ~safe_VkPerformanceCounterDescriptionKHR(); - void initialize(const VkPerformanceCounterDescriptionKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPerformanceCounterDescriptionKHR* copy_src, PNextCopyState* copy_state = {}); - VkPerformanceCounterDescriptionKHR* ptr() { return reinterpret_cast(this); } - VkPerformanceCounterDescriptionKHR const* ptr() const { - return reinterpret_cast(this); - } + safe_VkAttachmentSampleCountInfoAMD(const VkAttachmentSampleCountInfoAMD* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkAttachmentSampleCountInfoAMD(const safe_VkAttachmentSampleCountInfoAMD& copy_src); + safe_VkAttachmentSampleCountInfoAMD& operator=(const safe_VkAttachmentSampleCountInfoAMD& copy_src); + safe_VkAttachmentSampleCountInfoAMD(); + ~safe_VkAttachmentSampleCountInfoAMD(); + void initialize(const VkAttachmentSampleCountInfoAMD* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAttachmentSampleCountInfoAMD* copy_src, PNextCopyState* copy_state = {}); + VkAttachmentSampleCountInfoAMD* ptr() { return reinterpret_cast(this); } + VkAttachmentSampleCountInfoAMD const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkQueryPoolPerformanceCreateInfoKHR { +struct safe_VkMultiviewPerViewAttributesInfoNVX { VkStructureType sType; const void* pNext{}; - uint32_t queueFamilyIndex; - uint32_t counterIndexCount; - const uint32_t* pCounterIndices{}; + VkBool32 perViewAttributes; + VkBool32 perViewAttributesPositionXOnly; - safe_VkQueryPoolPerformanceCreateInfoKHR(const VkQueryPoolPerformanceCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, + safe_VkMultiviewPerViewAttributesInfoNVX(const VkMultiviewPerViewAttributesInfoNVX* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkQueryPoolPerformanceCreateInfoKHR(const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src); - safe_VkQueryPoolPerformanceCreateInfoKHR& operator=(const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src); - safe_VkQueryPoolPerformanceCreateInfoKHR(); - ~safe_VkQueryPoolPerformanceCreateInfoKHR(); - void initialize(const VkQueryPoolPerformanceCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkQueryPoolPerformanceCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkQueryPoolPerformanceCreateInfoKHR* ptr() { return reinterpret_cast(this); } - VkQueryPoolPerformanceCreateInfoKHR const* ptr() const { - return reinterpret_cast(this); + safe_VkMultiviewPerViewAttributesInfoNVX(const safe_VkMultiviewPerViewAttributesInfoNVX& copy_src); + safe_VkMultiviewPerViewAttributesInfoNVX& operator=(const safe_VkMultiviewPerViewAttributesInfoNVX& copy_src); + safe_VkMultiviewPerViewAttributesInfoNVX(); + ~safe_VkMultiviewPerViewAttributesInfoNVX(); + void initialize(const VkMultiviewPerViewAttributesInfoNVX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMultiviewPerViewAttributesInfoNVX* copy_src, PNextCopyState* copy_state = {}); + VkMultiviewPerViewAttributesInfoNVX* ptr() { return reinterpret_cast(this); } + VkMultiviewPerViewAttributesInfoNVX const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkAcquireProfilingLockInfoKHR { +#ifdef VK_USE_PLATFORM_WIN32_KHR +struct safe_VkImportMemoryWin32HandleInfoKHR { VkStructureType sType; const void* pNext{}; - VkAcquireProfilingLockFlagsKHR flags; - uint64_t timeout; + VkExternalMemoryHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; - safe_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkAcquireProfilingLockInfoKHR(const safe_VkAcquireProfilingLockInfoKHR& copy_src); - safe_VkAcquireProfilingLockInfoKHR& operator=(const safe_VkAcquireProfilingLockInfoKHR& copy_src); - safe_VkAcquireProfilingLockInfoKHR(); - ~safe_VkAcquireProfilingLockInfoKHR(); - void initialize(const VkAcquireProfilingLockInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkAcquireProfilingLockInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkAcquireProfilingLockInfoKHR* ptr() { return reinterpret_cast(this); } - VkAcquireProfilingLockInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImportMemoryWin32HandleInfoKHR(const safe_VkImportMemoryWin32HandleInfoKHR& copy_src); + safe_VkImportMemoryWin32HandleInfoKHR& operator=(const safe_VkImportMemoryWin32HandleInfoKHR& copy_src); + safe_VkImportMemoryWin32HandleInfoKHR(); + ~safe_VkImportMemoryWin32HandleInfoKHR(); + void initialize(const VkImportMemoryWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImportMemoryWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkImportMemoryWin32HandleInfoKHR* ptr() { return reinterpret_cast(this); } + VkImportMemoryWin32HandleInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPerformanceQuerySubmitInfoKHR { +struct safe_VkExportMemoryWin32HandleInfoKHR { VkStructureType sType; const void* pNext{}; - uint32_t counterPassIndex; + const SECURITY_ATTRIBUTES* pAttributes{}; + DWORD dwAccess; + LPCWSTR name; - safe_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkPerformanceQuerySubmitInfoKHR(const safe_VkPerformanceQuerySubmitInfoKHR& copy_src); - safe_VkPerformanceQuerySubmitInfoKHR& operator=(const safe_VkPerformanceQuerySubmitInfoKHR& copy_src); - safe_VkPerformanceQuerySubmitInfoKHR(); - ~safe_VkPerformanceQuerySubmitInfoKHR(); - void initialize(const VkPerformanceQuerySubmitInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPerformanceQuerySubmitInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkPerformanceQuerySubmitInfoKHR* ptr() { return reinterpret_cast(this); } - VkPerformanceQuerySubmitInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExportMemoryWin32HandleInfoKHR(const safe_VkExportMemoryWin32HandleInfoKHR& copy_src); + safe_VkExportMemoryWin32HandleInfoKHR& operator=(const safe_VkExportMemoryWin32HandleInfoKHR& copy_src); + safe_VkExportMemoryWin32HandleInfoKHR(); + ~safe_VkExportMemoryWin32HandleInfoKHR(); + void initialize(const VkExportMemoryWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExportMemoryWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkExportMemoryWin32HandleInfoKHR* ptr() { return reinterpret_cast(this); } + VkExportMemoryWin32HandleInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceSurfaceInfo2KHR { +struct safe_VkMemoryWin32HandlePropertiesKHR { VkStructureType sType; - const void* pNext{}; - VkSurfaceKHR surface; + void* pNext{}; + uint32_t memoryTypeBits; - safe_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkPhysicalDeviceSurfaceInfo2KHR(const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src); - safe_VkPhysicalDeviceSurfaceInfo2KHR& operator=(const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src); - safe_VkPhysicalDeviceSurfaceInfo2KHR(); - ~safe_VkPhysicalDeviceSurfaceInfo2KHR(); - void initialize(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceSurfaceInfo2KHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceSurfaceInfo2KHR* ptr() { return reinterpret_cast(this); } - VkPhysicalDeviceSurfaceInfo2KHR const* ptr() const { return reinterpret_cast(this); } + safe_VkMemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkMemoryWin32HandlePropertiesKHR(const safe_VkMemoryWin32HandlePropertiesKHR& copy_src); + safe_VkMemoryWin32HandlePropertiesKHR& operator=(const safe_VkMemoryWin32HandlePropertiesKHR& copy_src); + safe_VkMemoryWin32HandlePropertiesKHR(); + ~safe_VkMemoryWin32HandlePropertiesKHR(); + void initialize(const VkMemoryWin32HandlePropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryWin32HandlePropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkMemoryWin32HandlePropertiesKHR* ptr() { return reinterpret_cast(this); } + VkMemoryWin32HandlePropertiesKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkSurfaceCapabilities2KHR { +struct safe_VkMemoryGetWin32HandleInfoKHR { VkStructureType sType; - void* pNext{}; - VkSurfaceCapabilitiesKHR surfaceCapabilities; + const void* pNext{}; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; - safe_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkSurfaceCapabilities2KHR(const safe_VkSurfaceCapabilities2KHR& copy_src); - safe_VkSurfaceCapabilities2KHR& operator=(const safe_VkSurfaceCapabilities2KHR& copy_src); - safe_VkSurfaceCapabilities2KHR(); - ~safe_VkSurfaceCapabilities2KHR(); - void initialize(const VkSurfaceCapabilities2KHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkSurfaceCapabilities2KHR* copy_src, PNextCopyState* copy_state = {}); - VkSurfaceCapabilities2KHR* ptr() { return reinterpret_cast(this); } - VkSurfaceCapabilities2KHR const* ptr() const { return reinterpret_cast(this); } + safe_VkMemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkMemoryGetWin32HandleInfoKHR(const safe_VkMemoryGetWin32HandleInfoKHR& copy_src); + safe_VkMemoryGetWin32HandleInfoKHR& operator=(const safe_VkMemoryGetWin32HandleInfoKHR& copy_src); + safe_VkMemoryGetWin32HandleInfoKHR(); + ~safe_VkMemoryGetWin32HandleInfoKHR(); + void initialize(const VkMemoryGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryGetWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkMemoryGetWin32HandleInfoKHR* ptr() { return reinterpret_cast(this); } + VkMemoryGetWin32HandleInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkSurfaceFormat2KHR { +#endif // VK_USE_PLATFORM_WIN32_KHR +struct safe_VkImportMemoryFdInfoKHR { VkStructureType sType; - void* pNext{}; - VkSurfaceFormatKHR surfaceFormat; + const void* pNext{}; + VkExternalMemoryHandleTypeFlagBits handleType; + int fd; - safe_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkSurfaceFormat2KHR(const safe_VkSurfaceFormat2KHR& copy_src); - safe_VkSurfaceFormat2KHR& operator=(const safe_VkSurfaceFormat2KHR& copy_src); - safe_VkSurfaceFormat2KHR(); - ~safe_VkSurfaceFormat2KHR(); - void initialize(const VkSurfaceFormat2KHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkSurfaceFormat2KHR* copy_src, PNextCopyState* copy_state = {}); - VkSurfaceFormat2KHR* ptr() { return reinterpret_cast(this); } - VkSurfaceFormat2KHR const* ptr() const { return reinterpret_cast(this); } + safe_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImportMemoryFdInfoKHR(const safe_VkImportMemoryFdInfoKHR& copy_src); + safe_VkImportMemoryFdInfoKHR& operator=(const safe_VkImportMemoryFdInfoKHR& copy_src); + safe_VkImportMemoryFdInfoKHR(); + ~safe_VkImportMemoryFdInfoKHR(); + void initialize(const VkImportMemoryFdInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImportMemoryFdInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkImportMemoryFdInfoKHR* ptr() { return reinterpret_cast(this); } + VkImportMemoryFdInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkDisplayProperties2KHR { +struct safe_VkMemoryFdPropertiesKHR { VkStructureType sType; void* pNext{}; - safe_VkDisplayPropertiesKHR displayProperties; + uint32_t memoryTypeBits; - safe_VkDisplayProperties2KHR(const VkDisplayProperties2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkDisplayProperties2KHR(const safe_VkDisplayProperties2KHR& copy_src); - safe_VkDisplayProperties2KHR& operator=(const safe_VkDisplayProperties2KHR& copy_src); - safe_VkDisplayProperties2KHR(); - ~safe_VkDisplayProperties2KHR(); - void initialize(const VkDisplayProperties2KHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkDisplayProperties2KHR* copy_src, PNextCopyState* copy_state = {}); - VkDisplayProperties2KHR* ptr() { return reinterpret_cast(this); } - VkDisplayProperties2KHR const* ptr() const { return reinterpret_cast(this); } + safe_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMemoryFdPropertiesKHR(const safe_VkMemoryFdPropertiesKHR& copy_src); + safe_VkMemoryFdPropertiesKHR& operator=(const safe_VkMemoryFdPropertiesKHR& copy_src); + safe_VkMemoryFdPropertiesKHR(); + ~safe_VkMemoryFdPropertiesKHR(); + void initialize(const VkMemoryFdPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryFdPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkMemoryFdPropertiesKHR* ptr() { return reinterpret_cast(this); } + VkMemoryFdPropertiesKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkDisplayPlaneProperties2KHR { +struct safe_VkMemoryGetFdInfoKHR { VkStructureType sType; - void* pNext{}; - VkDisplayPlanePropertiesKHR displayPlaneProperties; + const void* pNext{}; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; - safe_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkDisplayPlaneProperties2KHR(const safe_VkDisplayPlaneProperties2KHR& copy_src); - safe_VkDisplayPlaneProperties2KHR& operator=(const safe_VkDisplayPlaneProperties2KHR& copy_src); - safe_VkDisplayPlaneProperties2KHR(); - ~safe_VkDisplayPlaneProperties2KHR(); - void initialize(const VkDisplayPlaneProperties2KHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkDisplayPlaneProperties2KHR* copy_src, PNextCopyState* copy_state = {}); - VkDisplayPlaneProperties2KHR* ptr() { return reinterpret_cast(this); } - VkDisplayPlaneProperties2KHR const* ptr() const { return reinterpret_cast(this); } + safe_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMemoryGetFdInfoKHR(const safe_VkMemoryGetFdInfoKHR& copy_src); + safe_VkMemoryGetFdInfoKHR& operator=(const safe_VkMemoryGetFdInfoKHR& copy_src); + safe_VkMemoryGetFdInfoKHR(); + ~safe_VkMemoryGetFdInfoKHR(); + void initialize(const VkMemoryGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryGetFdInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkMemoryGetFdInfoKHR* ptr() { return reinterpret_cast(this); } + VkMemoryGetFdInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkDisplayModeProperties2KHR { +#ifdef VK_USE_PLATFORM_WIN32_KHR +struct safe_VkWin32KeyedMutexAcquireReleaseInfoKHR { VkStructureType sType; - void* pNext{}; - VkDisplayModePropertiesKHR displayModeProperties; + const void* pNext{}; + uint32_t acquireCount; + VkDeviceMemory* pAcquireSyncs{}; + const uint64_t* pAcquireKeys{}; + const uint32_t* pAcquireTimeouts{}; + uint32_t releaseCount; + VkDeviceMemory* pReleaseSyncs{}; + const uint64_t* pReleaseKeys{}; - safe_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkDisplayModeProperties2KHR(const safe_VkDisplayModeProperties2KHR& copy_src); - safe_VkDisplayModeProperties2KHR& operator=(const safe_VkDisplayModeProperties2KHR& copy_src); - safe_VkDisplayModeProperties2KHR(); - ~safe_VkDisplayModeProperties2KHR(); - void initialize(const VkDisplayModeProperties2KHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkDisplayModeProperties2KHR* copy_src, PNextCopyState* copy_state = {}); - VkDisplayModeProperties2KHR* ptr() { return reinterpret_cast(this); } - VkDisplayModeProperties2KHR const* ptr() const { return reinterpret_cast(this); } + safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src); + safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& operator=(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src); + safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(); + ~safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(); + void initialize(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkWin32KeyedMutexAcquireReleaseInfoKHR* ptr() { return reinterpret_cast(this); } + VkWin32KeyedMutexAcquireReleaseInfoKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkDisplayPlaneInfo2KHR { +struct safe_VkImportSemaphoreWin32HandleInfoKHR { VkStructureType sType; const void* pNext{}; - VkDisplayModeKHR mode; - uint32_t planeIndex; + VkSemaphore semaphore; + VkSemaphoreImportFlags flags; + VkExternalSemaphoreHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; - safe_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkDisplayPlaneInfo2KHR(const safe_VkDisplayPlaneInfo2KHR& copy_src); - safe_VkDisplayPlaneInfo2KHR& operator=(const safe_VkDisplayPlaneInfo2KHR& copy_src); - safe_VkDisplayPlaneInfo2KHR(); - ~safe_VkDisplayPlaneInfo2KHR(); - void initialize(const VkDisplayPlaneInfo2KHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkDisplayPlaneInfo2KHR* copy_src, PNextCopyState* copy_state = {}); - VkDisplayPlaneInfo2KHR* ptr() { return reinterpret_cast(this); } - VkDisplayPlaneInfo2KHR const* ptr() const { return reinterpret_cast(this); } + safe_VkImportSemaphoreWin32HandleInfoKHR(const VkImportSemaphoreWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImportSemaphoreWin32HandleInfoKHR(const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src); + safe_VkImportSemaphoreWin32HandleInfoKHR& operator=(const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src); + safe_VkImportSemaphoreWin32HandleInfoKHR(); + ~safe_VkImportSemaphoreWin32HandleInfoKHR(); + void initialize(const VkImportSemaphoreWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImportSemaphoreWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkImportSemaphoreWin32HandleInfoKHR* ptr() { return reinterpret_cast(this); } + VkImportSemaphoreWin32HandleInfoKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkDisplayPlaneCapabilities2KHR { +struct safe_VkExportSemaphoreWin32HandleInfoKHR { VkStructureType sType; - void* pNext{}; - VkDisplayPlaneCapabilitiesKHR capabilities; + const void* pNext{}; + const SECURITY_ATTRIBUTES* pAttributes{}; + DWORD dwAccess; + LPCWSTR name; - safe_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkDisplayPlaneCapabilities2KHR(const safe_VkDisplayPlaneCapabilities2KHR& copy_src); - safe_VkDisplayPlaneCapabilities2KHR& operator=(const safe_VkDisplayPlaneCapabilities2KHR& copy_src); - safe_VkDisplayPlaneCapabilities2KHR(); - ~safe_VkDisplayPlaneCapabilities2KHR(); - void initialize(const VkDisplayPlaneCapabilities2KHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkDisplayPlaneCapabilities2KHR* copy_src, PNextCopyState* copy_state = {}); - VkDisplayPlaneCapabilities2KHR* ptr() { return reinterpret_cast(this); } - VkDisplayPlaneCapabilities2KHR const* ptr() const { return reinterpret_cast(this); } + safe_VkExportSemaphoreWin32HandleInfoKHR(const VkExportSemaphoreWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExportSemaphoreWin32HandleInfoKHR(const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src); + safe_VkExportSemaphoreWin32HandleInfoKHR& operator=(const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src); + safe_VkExportSemaphoreWin32HandleInfoKHR(); + ~safe_VkExportSemaphoreWin32HandleInfoKHR(); + void initialize(const VkExportSemaphoreWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExportSemaphoreWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkExportSemaphoreWin32HandleInfoKHR* ptr() { return reinterpret_cast(this); } + VkExportSemaphoreWin32HandleInfoKHR const* ptr() const { + return reinterpret_cast(this); + } }; -#ifdef VK_ENABLE_BETA_EXTENSIONS -struct safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR { +struct safe_VkD3D12FenceSubmitInfoKHR { VkStructureType sType; - void* pNext{}; - VkBool32 constantAlphaColorBlendFactors; - VkBool32 events; - VkBool32 imageViewFormatReinterpretation; - VkBool32 imageViewFormatSwizzle; - VkBool32 imageView2DOn3DImage; - VkBool32 multisampleArrayImage; - VkBool32 mutableComparisonSamplers; - VkBool32 pointPolygons; - VkBool32 samplerMipLodBias; - VkBool32 separateStencilMaskRef; - VkBool32 shaderSampleRateInterpolationFunctions; - VkBool32 tessellationIsolines; - VkBool32 tessellationPointMode; - VkBool32 triangleFans; - VkBool32 vertexAttributeAccessBeyondStride; + const void* pNext{}; + uint32_t waitSemaphoreValuesCount; + const uint64_t* pWaitSemaphoreValues{}; + uint32_t signalSemaphoreValuesCount; + const uint64_t* pSignalSemaphoreValues{}; - safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src); - safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& operator=(const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src); - safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(); - ~safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(); - void initialize(const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDevicePortabilitySubsetFeaturesKHR* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDevicePortabilitySubsetFeaturesKHR const* ptr() const { - return reinterpret_cast(this); - } + safe_VkD3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkD3D12FenceSubmitInfoKHR(const safe_VkD3D12FenceSubmitInfoKHR& copy_src); + safe_VkD3D12FenceSubmitInfoKHR& operator=(const safe_VkD3D12FenceSubmitInfoKHR& copy_src); + safe_VkD3D12FenceSubmitInfoKHR(); + ~safe_VkD3D12FenceSubmitInfoKHR(); + void initialize(const VkD3D12FenceSubmitInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkD3D12FenceSubmitInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkD3D12FenceSubmitInfoKHR* ptr() { return reinterpret_cast(this); } + VkD3D12FenceSubmitInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR { +struct safe_VkSemaphoreGetWin32HandleInfoKHR { VkStructureType sType; - void* pNext{}; - uint32_t minVertexInputBindingStrideAlignment; + const void* pNext{}; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBits handleType; - safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src); - safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& operator=( - const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src); - safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(); - ~safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(); - void initialize(const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDevicePortabilitySubsetPropertiesKHR* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDevicePortabilitySubsetPropertiesKHR const* ptr() const { - return reinterpret_cast(this); - } + safe_VkSemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSemaphoreGetWin32HandleInfoKHR(const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src); + safe_VkSemaphoreGetWin32HandleInfoKHR& operator=(const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src); + safe_VkSemaphoreGetWin32HandleInfoKHR(); + ~safe_VkSemaphoreGetWin32HandleInfoKHR(); + void initialize(const VkSemaphoreGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSemaphoreGetWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkSemaphoreGetWin32HandleInfoKHR* ptr() { return reinterpret_cast(this); } + VkSemaphoreGetWin32HandleInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -#endif // VK_ENABLE_BETA_EXTENSIONS -struct safe_VkPhysicalDeviceShaderClockFeaturesKHR { +#endif // VK_USE_PLATFORM_WIN32_KHR +struct safe_VkImportSemaphoreFdInfoKHR { VkStructureType sType; - void* pNext{}; - VkBool32 shaderSubgroupClock; - VkBool32 shaderDeviceClock; + const void* pNext{}; + VkSemaphore semaphore; + VkSemaphoreImportFlags flags; + VkExternalSemaphoreHandleTypeFlagBits handleType; + int fd; - safe_VkPhysicalDeviceShaderClockFeaturesKHR(const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceShaderClockFeaturesKHR(const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src); - safe_VkPhysicalDeviceShaderClockFeaturesKHR& operator=(const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src); - safe_VkPhysicalDeviceShaderClockFeaturesKHR(); - ~safe_VkPhysicalDeviceShaderClockFeaturesKHR(); - void initialize(const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceShaderClockFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceShaderClockFeaturesKHR* ptr() { return reinterpret_cast(this); } - VkPhysicalDeviceShaderClockFeaturesKHR const* ptr() const { - return reinterpret_cast(this); - } + safe_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImportSemaphoreFdInfoKHR(const safe_VkImportSemaphoreFdInfoKHR& copy_src); + safe_VkImportSemaphoreFdInfoKHR& operator=(const safe_VkImportSemaphoreFdInfoKHR& copy_src); + safe_VkImportSemaphoreFdInfoKHR(); + ~safe_VkImportSemaphoreFdInfoKHR(); + void initialize(const VkImportSemaphoreFdInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImportSemaphoreFdInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkImportSemaphoreFdInfoKHR* ptr() { return reinterpret_cast(this); } + VkImportSemaphoreFdInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkVideoDecodeH265ProfileInfoKHR { +struct safe_VkSemaphoreGetFdInfoKHR { VkStructureType sType; const void* pNext{}; - StdVideoH265ProfileIdc stdProfileIdc; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBits handleType; - safe_VkVideoDecodeH265ProfileInfoKHR(const VkVideoDecodeH265ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoDecodeH265ProfileInfoKHR(const safe_VkVideoDecodeH265ProfileInfoKHR& copy_src); - safe_VkVideoDecodeH265ProfileInfoKHR& operator=(const safe_VkVideoDecodeH265ProfileInfoKHR& copy_src); - safe_VkVideoDecodeH265ProfileInfoKHR(); - ~safe_VkVideoDecodeH265ProfileInfoKHR(); - void initialize(const VkVideoDecodeH265ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoDecodeH265ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoDecodeH265ProfileInfoKHR* ptr() { return reinterpret_cast(this); } - VkVideoDecodeH265ProfileInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSemaphoreGetFdInfoKHR(const safe_VkSemaphoreGetFdInfoKHR& copy_src); + safe_VkSemaphoreGetFdInfoKHR& operator=(const safe_VkSemaphoreGetFdInfoKHR& copy_src); + safe_VkSemaphoreGetFdInfoKHR(); + ~safe_VkSemaphoreGetFdInfoKHR(); + void initialize(const VkSemaphoreGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSemaphoreGetFdInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkSemaphoreGetFdInfoKHR* ptr() { return reinterpret_cast(this); } + VkSemaphoreGetFdInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkVideoDecodeH265CapabilitiesKHR { +struct safe_VkPhysicalDevicePushDescriptorPropertiesKHR { VkStructureType sType; void* pNext{}; - StdVideoH265LevelIdc maxLevelIdc; + uint32_t maxPushDescriptors; - safe_VkVideoDecodeH265CapabilitiesKHR(const VkVideoDecodeH265CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoDecodeH265CapabilitiesKHR(const safe_VkVideoDecodeH265CapabilitiesKHR& copy_src); - safe_VkVideoDecodeH265CapabilitiesKHR& operator=(const safe_VkVideoDecodeH265CapabilitiesKHR& copy_src); - safe_VkVideoDecodeH265CapabilitiesKHR(); - ~safe_VkVideoDecodeH265CapabilitiesKHR(); - void initialize(const VkVideoDecodeH265CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoDecodeH265CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoDecodeH265CapabilitiesKHR* ptr() { return reinterpret_cast(this); } - VkVideoDecodeH265CapabilitiesKHR const* ptr() const { return reinterpret_cast(this); } + 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_VkVideoDecodeH265SessionParametersAddInfoKHR { +struct safe_VkPresentRegionKHR { + uint32_t rectangleCount; + const VkRectLayerKHR* pRectangles{}; + + safe_VkPresentRegionKHR(const VkPresentRegionKHR* in_struct, PNextCopyState* copy_state = {}); + safe_VkPresentRegionKHR(const safe_VkPresentRegionKHR& copy_src); + safe_VkPresentRegionKHR& operator=(const safe_VkPresentRegionKHR& copy_src); + safe_VkPresentRegionKHR(); + ~safe_VkPresentRegionKHR(); + void initialize(const VkPresentRegionKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPresentRegionKHR* copy_src, PNextCopyState* copy_state = {}); + VkPresentRegionKHR* ptr() { return reinterpret_cast(this); } + VkPresentRegionKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPresentRegionsKHR { VkStructureType sType; const void* pNext{}; - uint32_t stdVPSCount; - const StdVideoH265VideoParameterSet* pStdVPSs{}; - uint32_t stdSPSCount; - const StdVideoH265SequenceParameterSet* pStdSPSs{}; - uint32_t stdPPSCount; - const StdVideoH265PictureParameterSet* pStdPPSs{}; + uint32_t swapchainCount; + safe_VkPresentRegionKHR* pRegions{}; - safe_VkVideoDecodeH265SessionParametersAddInfoKHR(const VkVideoDecodeH265SessionParametersAddInfoKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoDecodeH265SessionParametersAddInfoKHR(const safe_VkVideoDecodeH265SessionParametersAddInfoKHR& copy_src); - safe_VkVideoDecodeH265SessionParametersAddInfoKHR& operator=(const safe_VkVideoDecodeH265SessionParametersAddInfoKHR& copy_src); - safe_VkVideoDecodeH265SessionParametersAddInfoKHR(); - ~safe_VkVideoDecodeH265SessionParametersAddInfoKHR(); - void initialize(const VkVideoDecodeH265SessionParametersAddInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoDecodeH265SessionParametersAddInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoDecodeH265SessionParametersAddInfoKHR* ptr() { - return reinterpret_cast(this); - } - VkVideoDecodeH265SessionParametersAddInfoKHR const* ptr() const { - return reinterpret_cast(this); - } + safe_VkPresentRegionsKHR(const VkPresentRegionsKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPresentRegionsKHR(const safe_VkPresentRegionsKHR& copy_src); + safe_VkPresentRegionsKHR& operator=(const safe_VkPresentRegionsKHR& copy_src); + safe_VkPresentRegionsKHR(); + ~safe_VkPresentRegionsKHR(); + void initialize(const VkPresentRegionsKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPresentRegionsKHR* copy_src, PNextCopyState* copy_state = {}); + VkPresentRegionsKHR* ptr() { return reinterpret_cast(this); } + VkPresentRegionsKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkVideoDecodeH265SessionParametersCreateInfoKHR { +struct safe_VkSharedPresentSurfaceCapabilitiesKHR { VkStructureType sType; - const void* pNext{}; - uint32_t maxStdVPSCount; - uint32_t maxStdSPSCount; - uint32_t maxStdPPSCount; - safe_VkVideoDecodeH265SessionParametersAddInfoKHR* pParametersAddInfo{}; + void* pNext{}; + VkImageUsageFlags sharedPresentSupportedUsageFlags; - safe_VkVideoDecodeH265SessionParametersCreateInfoKHR(const VkVideoDecodeH265SessionParametersCreateInfoKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoDecodeH265SessionParametersCreateInfoKHR(const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& copy_src); - safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& operator=( - const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& copy_src); - safe_VkVideoDecodeH265SessionParametersCreateInfoKHR(); - ~safe_VkVideoDecodeH265SessionParametersCreateInfoKHR(); - void initialize(const VkVideoDecodeH265SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoDecodeH265SessionParametersCreateInfoKHR* ptr() { - return reinterpret_cast(this); - } - VkVideoDecodeH265SessionParametersCreateInfoKHR const* ptr() const { - return reinterpret_cast(this); + safe_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSharedPresentSurfaceCapabilitiesKHR(const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src); + safe_VkSharedPresentSurfaceCapabilitiesKHR& operator=(const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src); + safe_VkSharedPresentSurfaceCapabilitiesKHR(); + ~safe_VkSharedPresentSurfaceCapabilitiesKHR(); + void initialize(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSharedPresentSurfaceCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkSharedPresentSurfaceCapabilitiesKHR* ptr() { return reinterpret_cast(this); } + VkSharedPresentSurfaceCapabilitiesKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkVideoDecodeH265PictureInfoKHR { +#ifdef VK_USE_PLATFORM_WIN32_KHR +struct safe_VkImportFenceWin32HandleInfoKHR { VkStructureType sType; const void* pNext{}; - const StdVideoDecodeH265PictureInfo* pStdPictureInfo{}; - uint32_t sliceSegmentCount; - const uint32_t* pSliceSegmentOffsets{}; + VkFence fence; + VkFenceImportFlags flags; + VkExternalFenceHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; - safe_VkVideoDecodeH265PictureInfoKHR(const VkVideoDecodeH265PictureInfoKHR* in_struct, PNextCopyState* copy_state = {}, + safe_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoDecodeH265PictureInfoKHR(const safe_VkVideoDecodeH265PictureInfoKHR& copy_src); - safe_VkVideoDecodeH265PictureInfoKHR& operator=(const safe_VkVideoDecodeH265PictureInfoKHR& copy_src); - safe_VkVideoDecodeH265PictureInfoKHR(); - ~safe_VkVideoDecodeH265PictureInfoKHR(); - void initialize(const VkVideoDecodeH265PictureInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoDecodeH265PictureInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoDecodeH265PictureInfoKHR* ptr() { return reinterpret_cast(this); } - VkVideoDecodeH265PictureInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkImportFenceWin32HandleInfoKHR(const safe_VkImportFenceWin32HandleInfoKHR& copy_src); + safe_VkImportFenceWin32HandleInfoKHR& operator=(const safe_VkImportFenceWin32HandleInfoKHR& copy_src); + safe_VkImportFenceWin32HandleInfoKHR(); + ~safe_VkImportFenceWin32HandleInfoKHR(); + void initialize(const VkImportFenceWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImportFenceWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkImportFenceWin32HandleInfoKHR* ptr() { return reinterpret_cast(this); } + VkImportFenceWin32HandleInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkVideoDecodeH265DpbSlotInfoKHR { +struct safe_VkExportFenceWin32HandleInfoKHR { VkStructureType sType; const void* pNext{}; - const StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo{}; + const SECURITY_ATTRIBUTES* pAttributes{}; + DWORD dwAccess; + LPCWSTR name; - safe_VkVideoDecodeH265DpbSlotInfoKHR(const VkVideoDecodeH265DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {}, + safe_VkExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoDecodeH265DpbSlotInfoKHR(const safe_VkVideoDecodeH265DpbSlotInfoKHR& copy_src); - safe_VkVideoDecodeH265DpbSlotInfoKHR& operator=(const safe_VkVideoDecodeH265DpbSlotInfoKHR& copy_src); - safe_VkVideoDecodeH265DpbSlotInfoKHR(); - ~safe_VkVideoDecodeH265DpbSlotInfoKHR(); - void initialize(const VkVideoDecodeH265DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoDecodeH265DpbSlotInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoDecodeH265DpbSlotInfoKHR* ptr() { return reinterpret_cast(this); } - VkVideoDecodeH265DpbSlotInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkExportFenceWin32HandleInfoKHR(const safe_VkExportFenceWin32HandleInfoKHR& copy_src); + safe_VkExportFenceWin32HandleInfoKHR& operator=(const safe_VkExportFenceWin32HandleInfoKHR& copy_src); + safe_VkExportFenceWin32HandleInfoKHR(); + ~safe_VkExportFenceWin32HandleInfoKHR(); + void initialize(const VkExportFenceWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExportFenceWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkExportFenceWin32HandleInfoKHR* ptr() { return reinterpret_cast(this); } + VkExportFenceWin32HandleInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkDeviceQueueGlobalPriorityCreateInfoKHR { +struct safe_VkFenceGetWin32HandleInfoKHR { 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]; + VkFence fence; + VkExternalFenceHandleTypeFlagBits handleType; - 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); - } + safe_VkFenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkFenceGetWin32HandleInfoKHR(const safe_VkFenceGetWin32HandleInfoKHR& copy_src); + safe_VkFenceGetWin32HandleInfoKHR& operator=(const safe_VkFenceGetWin32HandleInfoKHR& copy_src); + safe_VkFenceGetWin32HandleInfoKHR(); + ~safe_VkFenceGetWin32HandleInfoKHR(); + void initialize(const VkFenceGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkFenceGetWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkFenceGetWin32HandleInfoKHR* ptr() { return reinterpret_cast(this); } + VkFenceGetWin32HandleInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkFragmentShadingRateAttachmentInfoKHR { +#endif // VK_USE_PLATFORM_WIN32_KHR +struct safe_VkImportFenceFdInfoKHR { VkStructureType sType; const void* pNext{}; - safe_VkAttachmentReference2* pFragmentShadingRateAttachment{}; - VkExtent2D shadingRateAttachmentTexelSize; + VkFence fence; + VkFenceImportFlags flags; + VkExternalFenceHandleTypeFlagBits handleType; + int fd; - safe_VkFragmentShadingRateAttachmentInfoKHR(const VkFragmentShadingRateAttachmentInfoKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkFragmentShadingRateAttachmentInfoKHR(const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src); - safe_VkFragmentShadingRateAttachmentInfoKHR& operator=(const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src); - safe_VkFragmentShadingRateAttachmentInfoKHR(); - ~safe_VkFragmentShadingRateAttachmentInfoKHR(); - void initialize(const VkFragmentShadingRateAttachmentInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkFragmentShadingRateAttachmentInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkFragmentShadingRateAttachmentInfoKHR* ptr() { return reinterpret_cast(this); } - VkFragmentShadingRateAttachmentInfoKHR const* ptr() const { - return reinterpret_cast(this); - } + safe_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImportFenceFdInfoKHR(const safe_VkImportFenceFdInfoKHR& copy_src); + safe_VkImportFenceFdInfoKHR& operator=(const safe_VkImportFenceFdInfoKHR& copy_src); + safe_VkImportFenceFdInfoKHR(); + ~safe_VkImportFenceFdInfoKHR(); + void initialize(const VkImportFenceFdInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImportFenceFdInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkImportFenceFdInfoKHR* ptr() { return reinterpret_cast(this); } + VkImportFenceFdInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPipelineFragmentShadingRateStateCreateInfoKHR { +struct safe_VkFenceGetFdInfoKHR { VkStructureType sType; const void* pNext{}; - VkExtent2D fragmentSize; - VkFragmentShadingRateCombinerOpKHR combinerOps[2]; + VkFence fence; + VkExternalFenceHandleTypeFlagBits handleType; - safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src); - safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& operator=( - const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src); - safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(); - ~safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(); - void initialize(const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkPipelineFragmentShadingRateStateCreateInfoKHR* ptr() { - return reinterpret_cast(this); - } - VkPipelineFragmentShadingRateStateCreateInfoKHR const* ptr() const { - return reinterpret_cast(this); - } + safe_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkFenceGetFdInfoKHR(const safe_VkFenceGetFdInfoKHR& copy_src); + safe_VkFenceGetFdInfoKHR& operator=(const safe_VkFenceGetFdInfoKHR& copy_src); + safe_VkFenceGetFdInfoKHR(); + ~safe_VkFenceGetFdInfoKHR(); + void initialize(const VkFenceGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkFenceGetFdInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkFenceGetFdInfoKHR* ptr() { return reinterpret_cast(this); } + VkFenceGetFdInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR { +struct safe_VkPhysicalDevicePerformanceQueryFeaturesKHR { VkStructureType sType; void* pNext{}; - VkBool32 pipelineFragmentShadingRate; - VkBool32 primitiveFragmentShadingRate; - VkBool32 attachmentFragmentShadingRate; + VkBool32 performanceCounterQueryPools; + VkBool32 performanceCounterMultipleQueryPools; - safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src); - safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& operator=( - const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src); - safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(); - ~safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(); - void initialize(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceFragmentShadingRateFeaturesKHR* ptr() { - return reinterpret_cast(this); + safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src); + safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& operator=(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src); + safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(); + ~safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(); + void initialize(const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePerformanceQueryFeaturesKHR* ptr() { + return reinterpret_cast(this); } - VkPhysicalDeviceFragmentShadingRateFeaturesKHR const* ptr() const { - return reinterpret_cast(this); + VkPhysicalDevicePerformanceQueryFeaturesKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR { +struct safe_VkPhysicalDevicePerformanceQueryPropertiesKHR { VkStructureType sType; void* pNext{}; - VkExtent2D minFragmentShadingRateAttachmentTexelSize; - VkExtent2D maxFragmentShadingRateAttachmentTexelSize; - uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio; - VkBool32 primitiveFragmentShadingRateWithMultipleViewports; - VkBool32 layeredShadingRateAttachments; - VkBool32 fragmentShadingRateNonTrivialCombinerOps; - VkExtent2D maxFragmentSize; - uint32_t maxFragmentSizeAspectRatio; - uint32_t maxFragmentShadingRateCoverageSamples; - VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples; - VkBool32 fragmentShadingRateWithShaderDepthStencilWrites; - VkBool32 fragmentShadingRateWithSampleMask; - VkBool32 fragmentShadingRateWithShaderSampleMask; - VkBool32 fragmentShadingRateWithConservativeRasterization; - VkBool32 fragmentShadingRateWithFragmentShaderInterlock; - VkBool32 fragmentShadingRateWithCustomSampleLocations; - VkBool32 fragmentShadingRateStrictMultiplyCombiner; + VkBool32 allowCommandBufferQueryCopies; - safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src); - safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& operator=( - const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src); - safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(); - ~safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(); - void initialize(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceFragmentShadingRatePropertiesKHR* ptr() { - return reinterpret_cast(this); + safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src); + safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& operator=( + const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src); + safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(); + ~safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(); + void initialize(const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePerformanceQueryPropertiesKHR* ptr() { + return reinterpret_cast(this); } - VkPhysicalDeviceFragmentShadingRatePropertiesKHR const* ptr() const { - return reinterpret_cast(this); + VkPhysicalDevicePerformanceQueryPropertiesKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceFragmentShadingRateKHR { +struct safe_VkPerformanceCounterKHR { VkStructureType sType; void* pNext{}; - VkSampleCountFlags sampleCounts; - VkExtent2D fragmentSize; + VkPerformanceCounterUnitKHR unit; + VkPerformanceCounterScopeKHR scope; + VkPerformanceCounterStorageKHR storage; + uint8_t uuid[VK_UUID_SIZE]; - safe_VkPhysicalDeviceFragmentShadingRateKHR(const VkPhysicalDeviceFragmentShadingRateKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceFragmentShadingRateKHR(const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src); - safe_VkPhysicalDeviceFragmentShadingRateKHR& operator=(const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src); - safe_VkPhysicalDeviceFragmentShadingRateKHR(); - ~safe_VkPhysicalDeviceFragmentShadingRateKHR(); - void initialize(const VkPhysicalDeviceFragmentShadingRateKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceFragmentShadingRateKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceFragmentShadingRateKHR* ptr() { return reinterpret_cast(this); } - VkPhysicalDeviceFragmentShadingRateKHR const* ptr() const { - return reinterpret_cast(this); - } + safe_VkPerformanceCounterKHR(const VkPerformanceCounterKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPerformanceCounterKHR(const safe_VkPerformanceCounterKHR& copy_src); + safe_VkPerformanceCounterKHR& operator=(const safe_VkPerformanceCounterKHR& copy_src); + safe_VkPerformanceCounterKHR(); + ~safe_VkPerformanceCounterKHR(); + void initialize(const VkPerformanceCounterKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPerformanceCounterKHR* copy_src, PNextCopyState* copy_state = {}); + VkPerformanceCounterKHR* ptr() { return reinterpret_cast(this); } + VkPerformanceCounterKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkSurfaceProtectedCapabilitiesKHR { +struct safe_VkPerformanceCounterDescriptionKHR { VkStructureType sType; - const void* pNext{}; - VkBool32 supportsProtected; + void* pNext{}; + VkPerformanceCounterDescriptionFlagsKHR flags; + char name[VK_MAX_DESCRIPTION_SIZE]; + char category[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; - safe_VkSurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkSurfaceProtectedCapabilitiesKHR(const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src); - safe_VkSurfaceProtectedCapabilitiesKHR& operator=(const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src); - safe_VkSurfaceProtectedCapabilitiesKHR(); - ~safe_VkSurfaceProtectedCapabilitiesKHR(); - void initialize(const VkSurfaceProtectedCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkSurfaceProtectedCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkSurfaceProtectedCapabilitiesKHR* ptr() { return reinterpret_cast(this); } - VkSurfaceProtectedCapabilitiesKHR const* ptr() const { - return reinterpret_cast(this); + safe_VkPerformanceCounterDescriptionKHR(const VkPerformanceCounterDescriptionKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPerformanceCounterDescriptionKHR(const safe_VkPerformanceCounterDescriptionKHR& copy_src); + safe_VkPerformanceCounterDescriptionKHR& operator=(const safe_VkPerformanceCounterDescriptionKHR& copy_src); + safe_VkPerformanceCounterDescriptionKHR(); + ~safe_VkPerformanceCounterDescriptionKHR(); + void initialize(const VkPerformanceCounterDescriptionKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPerformanceCounterDescriptionKHR* copy_src, PNextCopyState* copy_state = {}); + VkPerformanceCounterDescriptionKHR* ptr() { return reinterpret_cast(this); } + VkPerformanceCounterDescriptionKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkPhysicalDevicePresentWaitFeaturesKHR { +struct safe_VkQueryPoolPerformanceCreateInfoKHR { VkStructureType sType; - void* pNext{}; - VkBool32 presentWait; + const void* pNext{}; + uint32_t queueFamilyIndex; + uint32_t counterIndexCount; + const uint32_t* pCounterIndices{}; - safe_VkPhysicalDevicePresentWaitFeaturesKHR(const VkPhysicalDevicePresentWaitFeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDevicePresentWaitFeaturesKHR(const safe_VkPhysicalDevicePresentWaitFeaturesKHR& copy_src); - safe_VkPhysicalDevicePresentWaitFeaturesKHR& operator=(const safe_VkPhysicalDevicePresentWaitFeaturesKHR& copy_src); - safe_VkPhysicalDevicePresentWaitFeaturesKHR(); - ~safe_VkPhysicalDevicePresentWaitFeaturesKHR(); - void initialize(const VkPhysicalDevicePresentWaitFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDevicePresentWaitFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDevicePresentWaitFeaturesKHR* ptr() { return reinterpret_cast(this); } - VkPhysicalDevicePresentWaitFeaturesKHR const* ptr() const { - return reinterpret_cast(this); + safe_VkQueryPoolPerformanceCreateInfoKHR(const VkQueryPoolPerformanceCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkQueryPoolPerformanceCreateInfoKHR(const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src); + safe_VkQueryPoolPerformanceCreateInfoKHR& operator=(const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src); + safe_VkQueryPoolPerformanceCreateInfoKHR(); + ~safe_VkQueryPoolPerformanceCreateInfoKHR(); + void initialize(const VkQueryPoolPerformanceCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkQueryPoolPerformanceCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkQueryPoolPerformanceCreateInfoKHR* ptr() { return reinterpret_cast(this); } + VkQueryPoolPerformanceCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR { +struct safe_VkAcquireProfilingLockInfoKHR { VkStructureType sType; - void* pNext{}; - VkBool32 pipelineExecutableInfo; + const void* pNext{}; + VkAcquireProfilingLockFlagsKHR flags; + uint64_t timeout; - safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR( - const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR( - const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src); - safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=( - const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src); - safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(); - ~safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(); - void initialize(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const* ptr() const { - return reinterpret_cast(this); - } + safe_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkAcquireProfilingLockInfoKHR(const safe_VkAcquireProfilingLockInfoKHR& copy_src); + safe_VkAcquireProfilingLockInfoKHR& operator=(const safe_VkAcquireProfilingLockInfoKHR& copy_src); + safe_VkAcquireProfilingLockInfoKHR(); + ~safe_VkAcquireProfilingLockInfoKHR(); + void initialize(const VkAcquireProfilingLockInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAcquireProfilingLockInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkAcquireProfilingLockInfoKHR* ptr() { return reinterpret_cast(this); } + VkAcquireProfilingLockInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPipelineInfoKHR { +struct safe_VkPerformanceQuerySubmitInfoKHR { VkStructureType sType; const void* pNext{}; - VkPipeline pipeline; + uint32_t counterPassIndex; - safe_VkPipelineInfoKHR(const VkPipelineInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPipelineInfoKHR(const safe_VkPipelineInfoKHR& copy_src); - safe_VkPipelineInfoKHR& operator=(const safe_VkPipelineInfoKHR& copy_src); - safe_VkPipelineInfoKHR(); - ~safe_VkPipelineInfoKHR(); - void initialize(const VkPipelineInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPipelineInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkPipelineInfoKHR* ptr() { return reinterpret_cast(this); } - VkPipelineInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPerformanceQuerySubmitInfoKHR(const safe_VkPerformanceQuerySubmitInfoKHR& copy_src); + safe_VkPerformanceQuerySubmitInfoKHR& operator=(const safe_VkPerformanceQuerySubmitInfoKHR& copy_src); + safe_VkPerformanceQuerySubmitInfoKHR(); + ~safe_VkPerformanceQuerySubmitInfoKHR(); + void initialize(const VkPerformanceQuerySubmitInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPerformanceQuerySubmitInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPerformanceQuerySubmitInfoKHR* ptr() { return reinterpret_cast(this); } + VkPerformanceQuerySubmitInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPipelineExecutablePropertiesKHR { +struct safe_VkPhysicalDeviceSurfaceInfo2KHR { + VkStructureType sType; + const void* pNext{}; + VkSurfaceKHR surface; + + safe_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceSurfaceInfo2KHR(const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src); + safe_VkPhysicalDeviceSurfaceInfo2KHR& operator=(const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src); + safe_VkPhysicalDeviceSurfaceInfo2KHR(); + ~safe_VkPhysicalDeviceSurfaceInfo2KHR(); + void initialize(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceSurfaceInfo2KHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceSurfaceInfo2KHR* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceSurfaceInfo2KHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSurfaceCapabilities2KHR { VkStructureType sType; void* pNext{}; - VkShaderStageFlags stages; - char name[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; - uint32_t subgroupSize; + VkSurfaceCapabilitiesKHR surfaceCapabilities; - safe_VkPipelineExecutablePropertiesKHR(const VkPipelineExecutablePropertiesKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkPipelineExecutablePropertiesKHR(const safe_VkPipelineExecutablePropertiesKHR& copy_src); - safe_VkPipelineExecutablePropertiesKHR& operator=(const safe_VkPipelineExecutablePropertiesKHR& copy_src); - safe_VkPipelineExecutablePropertiesKHR(); - ~safe_VkPipelineExecutablePropertiesKHR(); - void initialize(const VkPipelineExecutablePropertiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPipelineExecutablePropertiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPipelineExecutablePropertiesKHR* ptr() { return reinterpret_cast(this); } - VkPipelineExecutablePropertiesKHR const* ptr() const { - return reinterpret_cast(this); - } + safe_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSurfaceCapabilities2KHR(const safe_VkSurfaceCapabilities2KHR& copy_src); + safe_VkSurfaceCapabilities2KHR& operator=(const safe_VkSurfaceCapabilities2KHR& copy_src); + safe_VkSurfaceCapabilities2KHR(); + ~safe_VkSurfaceCapabilities2KHR(); + void initialize(const VkSurfaceCapabilities2KHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSurfaceCapabilities2KHR* copy_src, PNextCopyState* copy_state = {}); + VkSurfaceCapabilities2KHR* ptr() { return reinterpret_cast(this); } + VkSurfaceCapabilities2KHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPipelineExecutableInfoKHR { +struct safe_VkSurfaceFormat2KHR { VkStructureType sType; - const void* pNext{}; - VkPipeline pipeline; - uint32_t executableIndex; + void* pNext{}; + VkSurfaceFormatKHR surfaceFormat; - safe_VkPipelineExecutableInfoKHR(const VkPipelineExecutableInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkPipelineExecutableInfoKHR(const safe_VkPipelineExecutableInfoKHR& copy_src); - safe_VkPipelineExecutableInfoKHR& operator=(const safe_VkPipelineExecutableInfoKHR& copy_src); - safe_VkPipelineExecutableInfoKHR(); - ~safe_VkPipelineExecutableInfoKHR(); - void initialize(const VkPipelineExecutableInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPipelineExecutableInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkPipelineExecutableInfoKHR* ptr() { return reinterpret_cast(this); } - VkPipelineExecutableInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSurfaceFormat2KHR(const safe_VkSurfaceFormat2KHR& copy_src); + safe_VkSurfaceFormat2KHR& operator=(const safe_VkSurfaceFormat2KHR& copy_src); + safe_VkSurfaceFormat2KHR(); + ~safe_VkSurfaceFormat2KHR(); + void initialize(const VkSurfaceFormat2KHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSurfaceFormat2KHR* copy_src, PNextCopyState* copy_state = {}); + VkSurfaceFormat2KHR* ptr() { return reinterpret_cast(this); } + VkSurfaceFormat2KHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPipelineExecutableStatisticKHR { +struct safe_VkDisplayProperties2KHR { VkStructureType sType; void* pNext{}; - char name[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; - VkPipelineExecutableStatisticFormatKHR format; - VkPipelineExecutableStatisticValueKHR value; + safe_VkDisplayPropertiesKHR displayProperties; - safe_VkPipelineExecutableStatisticKHR(const VkPipelineExecutableStatisticKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkPipelineExecutableStatisticKHR(const safe_VkPipelineExecutableStatisticKHR& copy_src); - safe_VkPipelineExecutableStatisticKHR& operator=(const safe_VkPipelineExecutableStatisticKHR& copy_src); - safe_VkPipelineExecutableStatisticKHR(); - ~safe_VkPipelineExecutableStatisticKHR(); - void initialize(const VkPipelineExecutableStatisticKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPipelineExecutableStatisticKHR* copy_src, PNextCopyState* copy_state = {}); - VkPipelineExecutableStatisticKHR* ptr() { return reinterpret_cast(this); } - VkPipelineExecutableStatisticKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkDisplayProperties2KHR(const VkDisplayProperties2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDisplayProperties2KHR(const safe_VkDisplayProperties2KHR& copy_src); + safe_VkDisplayProperties2KHR& operator=(const safe_VkDisplayProperties2KHR& copy_src); + safe_VkDisplayProperties2KHR(); + ~safe_VkDisplayProperties2KHR(); + void initialize(const VkDisplayProperties2KHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDisplayProperties2KHR* copy_src, PNextCopyState* copy_state = {}); + VkDisplayProperties2KHR* ptr() { return reinterpret_cast(this); } + VkDisplayProperties2KHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPipelineExecutableInternalRepresentationKHR { +struct safe_VkDisplayPlaneProperties2KHR { VkStructureType sType; void* pNext{}; - char name[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; - VkBool32 isText; - size_t dataSize; - void* pData{}; + VkDisplayPlanePropertiesKHR displayPlaneProperties; - safe_VkPipelineExecutableInternalRepresentationKHR(const VkPipelineExecutableInternalRepresentationKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPipelineExecutableInternalRepresentationKHR(const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src); - safe_VkPipelineExecutableInternalRepresentationKHR& operator=( - const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src); - safe_VkPipelineExecutableInternalRepresentationKHR(); - ~safe_VkPipelineExecutableInternalRepresentationKHR(); - void initialize(const VkPipelineExecutableInternalRepresentationKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPipelineExecutableInternalRepresentationKHR* copy_src, PNextCopyState* copy_state = {}); - VkPipelineExecutableInternalRepresentationKHR* ptr() { - return reinterpret_cast(this); - } - VkPipelineExecutableInternalRepresentationKHR const* ptr() const { - return reinterpret_cast(this); - } + safe_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDisplayPlaneProperties2KHR(const safe_VkDisplayPlaneProperties2KHR& copy_src); + safe_VkDisplayPlaneProperties2KHR& operator=(const safe_VkDisplayPlaneProperties2KHR& copy_src); + safe_VkDisplayPlaneProperties2KHR(); + ~safe_VkDisplayPlaneProperties2KHR(); + void initialize(const VkDisplayPlaneProperties2KHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDisplayPlaneProperties2KHR* copy_src, PNextCopyState* copy_state = {}); + VkDisplayPlaneProperties2KHR* ptr() { return reinterpret_cast(this); } + VkDisplayPlaneProperties2KHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkMemoryMapInfoKHR { +struct safe_VkDisplayModeProperties2KHR { VkStructureType sType; - const void* pNext{}; - VkMemoryMapFlags flags; - VkDeviceMemory memory; - VkDeviceSize offset; - VkDeviceSize size; + void* pNext{}; + VkDisplayModePropertiesKHR displayModeProperties; - 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); } + safe_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDisplayModeProperties2KHR(const safe_VkDisplayModeProperties2KHR& copy_src); + safe_VkDisplayModeProperties2KHR& operator=(const safe_VkDisplayModeProperties2KHR& copy_src); + safe_VkDisplayModeProperties2KHR(); + ~safe_VkDisplayModeProperties2KHR(); + void initialize(const VkDisplayModeProperties2KHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDisplayModeProperties2KHR* copy_src, PNextCopyState* copy_state = {}); + VkDisplayModeProperties2KHR* ptr() { return reinterpret_cast(this); } + VkDisplayModeProperties2KHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkMemoryUnmapInfoKHR { +struct safe_VkDisplayPlaneInfo2KHR { VkStructureType sType; const void* pNext{}; - VkMemoryUnmapFlagsKHR flags; - VkDeviceMemory memory; + VkDisplayModeKHR mode; + uint32_t planeIndex; - 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); } + safe_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDisplayPlaneInfo2KHR(const safe_VkDisplayPlaneInfo2KHR& copy_src); + safe_VkDisplayPlaneInfo2KHR& operator=(const safe_VkDisplayPlaneInfo2KHR& copy_src); + safe_VkDisplayPlaneInfo2KHR(); + ~safe_VkDisplayPlaneInfo2KHR(); + void initialize(const VkDisplayPlaneInfo2KHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDisplayPlaneInfo2KHR* copy_src, PNextCopyState* copy_state = {}); + VkDisplayPlaneInfo2KHR* ptr() { return reinterpret_cast(this); } + VkDisplayPlaneInfo2KHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPipelineLibraryCreateInfoKHR { +struct safe_VkDisplayPlaneCapabilities2KHR { VkStructureType sType; - const void* pNext{}; - uint32_t libraryCount; - VkPipeline* pLibraries{}; + void* pNext{}; + VkDisplayPlaneCapabilitiesKHR capabilities; - safe_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, + safe_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPipelineLibraryCreateInfoKHR(const safe_VkPipelineLibraryCreateInfoKHR& copy_src); - safe_VkPipelineLibraryCreateInfoKHR& operator=(const safe_VkPipelineLibraryCreateInfoKHR& copy_src); - safe_VkPipelineLibraryCreateInfoKHR(); - ~safe_VkPipelineLibraryCreateInfoKHR(); - void initialize(const VkPipelineLibraryCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPipelineLibraryCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkPipelineLibraryCreateInfoKHR* ptr() { return reinterpret_cast(this); } - VkPipelineLibraryCreateInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkDisplayPlaneCapabilities2KHR(const safe_VkDisplayPlaneCapabilities2KHR& copy_src); + safe_VkDisplayPlaneCapabilities2KHR& operator=(const safe_VkDisplayPlaneCapabilities2KHR& copy_src); + safe_VkDisplayPlaneCapabilities2KHR(); + ~safe_VkDisplayPlaneCapabilities2KHR(); + void initialize(const VkDisplayPlaneCapabilities2KHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDisplayPlaneCapabilities2KHR* copy_src, PNextCopyState* copy_state = {}); + VkDisplayPlaneCapabilities2KHR* ptr() { return reinterpret_cast(this); } + VkDisplayPlaneCapabilities2KHR const* ptr() const { return reinterpret_cast(this); } +}; +#ifdef VK_ENABLE_BETA_EXTENSIONS +struct safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 constantAlphaColorBlendFactors; + VkBool32 events; + VkBool32 imageViewFormatReinterpretation; + VkBool32 imageViewFormatSwizzle; + VkBool32 imageView2DOn3DImage; + VkBool32 multisampleArrayImage; + VkBool32 mutableComparisonSamplers; + VkBool32 pointPolygons; + VkBool32 samplerMipLodBias; + VkBool32 separateStencilMaskRef; + VkBool32 shaderSampleRateInterpolationFunctions; + VkBool32 tessellationIsolines; + VkBool32 tessellationPointMode; + VkBool32 triangleFans; + VkBool32 vertexAttributeAccessBeyondStride; + + safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src); + safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& operator=(const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src); + safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(); + ~safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(); + void initialize(const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePortabilitySubsetFeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDevicePortabilitySubsetFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkPresentIdKHR { +struct safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR { VkStructureType sType; - const void* pNext{}; - uint32_t swapchainCount; - const uint64_t* pPresentIds{}; + void* pNext{}; + uint32_t minVertexInputBindingStrideAlignment; - safe_VkPresentIdKHR(const VkPresentIdKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPresentIdKHR(const safe_VkPresentIdKHR& copy_src); - safe_VkPresentIdKHR& operator=(const safe_VkPresentIdKHR& copy_src); - safe_VkPresentIdKHR(); - ~safe_VkPresentIdKHR(); - void initialize(const VkPresentIdKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPresentIdKHR* copy_src, PNextCopyState* copy_state = {}); - VkPresentIdKHR* ptr() { return reinterpret_cast(this); } - VkPresentIdKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src); + safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& operator=( + const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src); + safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(); + ~safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(); + void initialize(const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePortabilitySubsetPropertiesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDevicePortabilitySubsetPropertiesKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkPhysicalDevicePresentIdFeaturesKHR { +#endif // VK_ENABLE_BETA_EXTENSIONS +struct safe_VkPhysicalDeviceShaderClockFeaturesKHR { VkStructureType sType; void* pNext{}; - VkBool32 presentId; + VkBool32 shaderSubgroupClock; + VkBool32 shaderDeviceClock; - safe_VkPhysicalDevicePresentIdFeaturesKHR(const VkPhysicalDevicePresentIdFeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDevicePresentIdFeaturesKHR(const safe_VkPhysicalDevicePresentIdFeaturesKHR& copy_src); - safe_VkPhysicalDevicePresentIdFeaturesKHR& operator=(const safe_VkPhysicalDevicePresentIdFeaturesKHR& copy_src); - safe_VkPhysicalDevicePresentIdFeaturesKHR(); - ~safe_VkPhysicalDevicePresentIdFeaturesKHR(); - void initialize(const VkPhysicalDevicePresentIdFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDevicePresentIdFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDevicePresentIdFeaturesKHR* ptr() { return reinterpret_cast(this); } - VkPhysicalDevicePresentIdFeaturesKHR const* ptr() const { - return reinterpret_cast(this); + safe_VkPhysicalDeviceShaderClockFeaturesKHR(const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderClockFeaturesKHR(const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src); + safe_VkPhysicalDeviceShaderClockFeaturesKHR& operator=(const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src); + safe_VkPhysicalDeviceShaderClockFeaturesKHR(); + ~safe_VkPhysicalDeviceShaderClockFeaturesKHR(); + void initialize(const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderClockFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderClockFeaturesKHR* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceShaderClockFeaturesKHR const* ptr() const { + return reinterpret_cast(this); } }; -#ifdef VK_ENABLE_BETA_EXTENSIONS -struct safe_VkVideoEncodeInfoKHR { +struct safe_VkVideoDecodeH265ProfileInfoKHR { VkStructureType sType; const void* pNext{}; - VkVideoEncodeFlagsKHR flags; - VkBuffer dstBuffer; - VkDeviceSize dstBufferOffset; - VkDeviceSize dstBufferRange; - safe_VkVideoPictureResourceInfoKHR srcPictureResource; - safe_VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot{}; - uint32_t referenceSlotCount; - safe_VkVideoReferenceSlotInfoKHR* pReferenceSlots{}; - uint32_t precedingExternallyEncodedBytes; + StdVideoH265ProfileIdc stdProfileIdc; - safe_VkVideoEncodeInfoKHR(const VkVideoEncodeInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeInfoKHR(const safe_VkVideoEncodeInfoKHR& copy_src); - safe_VkVideoEncodeInfoKHR& operator=(const safe_VkVideoEncodeInfoKHR& copy_src); - safe_VkVideoEncodeInfoKHR(); - ~safe_VkVideoEncodeInfoKHR(); - void initialize(const VkVideoEncodeInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeInfoKHR* ptr() { return reinterpret_cast(this); } - VkVideoEncodeInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoDecodeH265ProfileInfoKHR(const VkVideoDecodeH265ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoDecodeH265ProfileInfoKHR(const safe_VkVideoDecodeH265ProfileInfoKHR& copy_src); + safe_VkVideoDecodeH265ProfileInfoKHR& operator=(const safe_VkVideoDecodeH265ProfileInfoKHR& copy_src); + safe_VkVideoDecodeH265ProfileInfoKHR(); + ~safe_VkVideoDecodeH265ProfileInfoKHR(); + void initialize(const VkVideoDecodeH265ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeH265ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeH265ProfileInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoDecodeH265ProfileInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeCapabilitiesKHR { +struct safe_VkVideoDecodeH265CapabilitiesKHR { VkStructureType sType; void* pNext{}; - VkVideoEncodeCapabilityFlagsKHR flags; - VkVideoEncodeRateControlModeFlagsKHR rateControlModes; - uint32_t maxRateControlLayers; - uint64_t maxBitrate; - uint32_t maxQualityLevels; - VkExtent2D encodeInputPictureGranularity; - VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags; + StdVideoH265LevelIdc maxLevelIdc; - safe_VkVideoEncodeCapabilitiesKHR(const VkVideoEncodeCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoEncodeCapabilitiesKHR(const safe_VkVideoEncodeCapabilitiesKHR& copy_src); - safe_VkVideoEncodeCapabilitiesKHR& operator=(const safe_VkVideoEncodeCapabilitiesKHR& copy_src); - safe_VkVideoEncodeCapabilitiesKHR(); - ~safe_VkVideoEncodeCapabilitiesKHR(); - void initialize(const VkVideoEncodeCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeCapabilitiesKHR* ptr() { return reinterpret_cast(this); } - VkVideoEncodeCapabilitiesKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoDecodeH265CapabilitiesKHR(const VkVideoDecodeH265CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoDecodeH265CapabilitiesKHR(const safe_VkVideoDecodeH265CapabilitiesKHR& copy_src); + safe_VkVideoDecodeH265CapabilitiesKHR& operator=(const safe_VkVideoDecodeH265CapabilitiesKHR& copy_src); + safe_VkVideoDecodeH265CapabilitiesKHR(); + ~safe_VkVideoDecodeH265CapabilitiesKHR(); + void initialize(const VkVideoDecodeH265CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeH265CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeH265CapabilitiesKHR* ptr() { return reinterpret_cast(this); } + VkVideoDecodeH265CapabilitiesKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR { +struct safe_VkVideoDecodeH265SessionParametersAddInfoKHR { VkStructureType sType; const void* pNext{}; - VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags; + uint32_t stdVPSCount; + const StdVideoH265VideoParameterSet* pStdVPSs{}; + uint32_t stdSPSCount; + const StdVideoH265SequenceParameterSet* pStdSPSs{}; + uint32_t stdPPSCount; + const StdVideoH265PictureParameterSet* pStdPPSs{}; - safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& copy_src); - safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& operator=(const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& copy_src); - safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(); - ~safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(); - void initialize(const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* ptr() { - return reinterpret_cast(this); + safe_VkVideoDecodeH265SessionParametersAddInfoKHR(const VkVideoDecodeH265SessionParametersAddInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoDecodeH265SessionParametersAddInfoKHR(const safe_VkVideoDecodeH265SessionParametersAddInfoKHR& copy_src); + safe_VkVideoDecodeH265SessionParametersAddInfoKHR& operator=(const safe_VkVideoDecodeH265SessionParametersAddInfoKHR& copy_src); + safe_VkVideoDecodeH265SessionParametersAddInfoKHR(); + ~safe_VkVideoDecodeH265SessionParametersAddInfoKHR(); + void initialize(const VkVideoDecodeH265SessionParametersAddInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeH265SessionParametersAddInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeH265SessionParametersAddInfoKHR* ptr() { + return reinterpret_cast(this); } - VkQueryPoolVideoEncodeFeedbackCreateInfoKHR const* ptr() const { - return reinterpret_cast(this); + VkVideoDecodeH265SessionParametersAddInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeUsageInfoKHR { +struct safe_VkVideoDecodeH265SessionParametersCreateInfoKHR { VkStructureType sType; const void* pNext{}; - VkVideoEncodeUsageFlagsKHR videoUsageHints; - VkVideoEncodeContentFlagsKHR videoContentHints; - VkVideoEncodeTuningModeKHR tuningMode; + uint32_t maxStdVPSCount; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + safe_VkVideoDecodeH265SessionParametersAddInfoKHR* pParametersAddInfo{}; - safe_VkVideoEncodeUsageInfoKHR(const VkVideoEncodeUsageInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoEncodeUsageInfoKHR(const safe_VkVideoEncodeUsageInfoKHR& copy_src); - safe_VkVideoEncodeUsageInfoKHR& operator=(const safe_VkVideoEncodeUsageInfoKHR& copy_src); - safe_VkVideoEncodeUsageInfoKHR(); - ~safe_VkVideoEncodeUsageInfoKHR(); - void initialize(const VkVideoEncodeUsageInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeUsageInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeUsageInfoKHR* ptr() { return reinterpret_cast(this); } - VkVideoEncodeUsageInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoDecodeH265SessionParametersCreateInfoKHR(const VkVideoDecodeH265SessionParametersCreateInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoDecodeH265SessionParametersCreateInfoKHR(const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& copy_src); + safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& operator=( + const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& copy_src); + safe_VkVideoDecodeH265SessionParametersCreateInfoKHR(); + ~safe_VkVideoDecodeH265SessionParametersCreateInfoKHR(); + void initialize(const VkVideoDecodeH265SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeH265SessionParametersCreateInfoKHR* ptr() { + return reinterpret_cast(this); + } + VkVideoDecodeH265SessionParametersCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkVideoEncodeRateControlLayerInfoKHR { +struct safe_VkVideoDecodeH265PictureInfoKHR { VkStructureType sType; const void* pNext{}; - uint64_t averageBitrate; - uint64_t maxBitrate; - uint32_t frameRateNumerator; - uint32_t frameRateDenominator; + const StdVideoDecodeH265PictureInfo* pStdPictureInfo{}; + uint32_t sliceSegmentCount; + const uint32_t* pSliceSegmentOffsets{}; - safe_VkVideoEncodeRateControlLayerInfoKHR(const VkVideoEncodeRateControlLayerInfoKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeRateControlLayerInfoKHR(const safe_VkVideoEncodeRateControlLayerInfoKHR& copy_src); - safe_VkVideoEncodeRateControlLayerInfoKHR& operator=(const safe_VkVideoEncodeRateControlLayerInfoKHR& copy_src); - safe_VkVideoEncodeRateControlLayerInfoKHR(); - ~safe_VkVideoEncodeRateControlLayerInfoKHR(); - void initialize(const VkVideoEncodeRateControlLayerInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeRateControlLayerInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeRateControlLayerInfoKHR* ptr() { return reinterpret_cast(this); } - VkVideoEncodeRateControlLayerInfoKHR const* ptr() const { - return reinterpret_cast(this); - } + safe_VkVideoDecodeH265PictureInfoKHR(const VkVideoDecodeH265PictureInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoDecodeH265PictureInfoKHR(const safe_VkVideoDecodeH265PictureInfoKHR& copy_src); + safe_VkVideoDecodeH265PictureInfoKHR& operator=(const safe_VkVideoDecodeH265PictureInfoKHR& copy_src); + safe_VkVideoDecodeH265PictureInfoKHR(); + ~safe_VkVideoDecodeH265PictureInfoKHR(); + void initialize(const VkVideoDecodeH265PictureInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeH265PictureInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeH265PictureInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoDecodeH265PictureInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeRateControlInfoKHR { +struct safe_VkVideoDecodeH265DpbSlotInfoKHR { VkStructureType sType; const void* pNext{}; - VkVideoEncodeRateControlFlagsKHR flags; - VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode; - uint32_t layerCount; - safe_VkVideoEncodeRateControlLayerInfoKHR* pLayers{}; - uint32_t virtualBufferSizeInMs; - uint32_t initialVirtualBufferSizeInMs; + const StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo{}; - safe_VkVideoEncodeRateControlInfoKHR(const VkVideoEncodeRateControlInfoKHR* in_struct, PNextCopyState* copy_state = {}, + safe_VkVideoDecodeH265DpbSlotInfoKHR(const VkVideoDecodeH265DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeRateControlInfoKHR(const safe_VkVideoEncodeRateControlInfoKHR& copy_src); - safe_VkVideoEncodeRateControlInfoKHR& operator=(const safe_VkVideoEncodeRateControlInfoKHR& copy_src); - safe_VkVideoEncodeRateControlInfoKHR(); - ~safe_VkVideoEncodeRateControlInfoKHR(); - void initialize(const VkVideoEncodeRateControlInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeRateControlInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeRateControlInfoKHR* ptr() { return reinterpret_cast(this); } - VkVideoEncodeRateControlInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkVideoDecodeH265DpbSlotInfoKHR(const safe_VkVideoDecodeH265DpbSlotInfoKHR& copy_src); + safe_VkVideoDecodeH265DpbSlotInfoKHR& operator=(const safe_VkVideoDecodeH265DpbSlotInfoKHR& copy_src); + safe_VkVideoDecodeH265DpbSlotInfoKHR(); + ~safe_VkVideoDecodeH265DpbSlotInfoKHR(); + void initialize(const VkVideoDecodeH265DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeH265DpbSlotInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeH265DpbSlotInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoDecodeH265DpbSlotInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR { +struct safe_VkDeviceQueueGlobalPriorityCreateInfoKHR { VkStructureType sType; const void* pNext{}; - safe_VkVideoProfileInfoKHR* pVideoProfile{}; - uint32_t qualityLevel; + VkQueueGlobalPriorityKHR globalPriority; - safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* in_struct, + 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_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& copy_src); - safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& operator=( - const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& copy_src); - safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(); - ~safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(); - void initialize(const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* ptr() { - return reinterpret_cast(this); + 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); } - VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const* ptr() const { - return reinterpret_cast(this); + VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeQualityLevelPropertiesKHR { +struct safe_VkQueueFamilyGlobalPriorityPropertiesKHR { VkStructureType sType; void* pNext{}; - VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode; - uint32_t preferredRateControlLayerCount; + uint32_t priorityCount; + VkQueueGlobalPriorityKHR priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_KHR]; - safe_VkVideoEncodeQualityLevelPropertiesKHR(const VkVideoEncodeQualityLevelPropertiesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeQualityLevelPropertiesKHR(const safe_VkVideoEncodeQualityLevelPropertiesKHR& copy_src); - safe_VkVideoEncodeQualityLevelPropertiesKHR& operator=(const safe_VkVideoEncodeQualityLevelPropertiesKHR& copy_src); - safe_VkVideoEncodeQualityLevelPropertiesKHR(); - ~safe_VkVideoEncodeQualityLevelPropertiesKHR(); - void initialize(const VkVideoEncodeQualityLevelPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeQualityLevelPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeQualityLevelPropertiesKHR* ptr() { return reinterpret_cast(this); } - VkVideoEncodeQualityLevelPropertiesKHR const* ptr() const { - return reinterpret_cast(this); + 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_VkVideoEncodeQualityLevelInfoKHR { +struct safe_VkFragmentShadingRateAttachmentInfoKHR { VkStructureType sType; const void* pNext{}; - uint32_t qualityLevel; + safe_VkAttachmentReference2* pFragmentShadingRateAttachment{}; + VkExtent2D shadingRateAttachmentTexelSize; - safe_VkVideoEncodeQualityLevelInfoKHR(const VkVideoEncodeQualityLevelInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoEncodeQualityLevelInfoKHR(const safe_VkVideoEncodeQualityLevelInfoKHR& copy_src); - safe_VkVideoEncodeQualityLevelInfoKHR& operator=(const safe_VkVideoEncodeQualityLevelInfoKHR& copy_src); - safe_VkVideoEncodeQualityLevelInfoKHR(); - ~safe_VkVideoEncodeQualityLevelInfoKHR(); - void initialize(const VkVideoEncodeQualityLevelInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeQualityLevelInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeQualityLevelInfoKHR* ptr() { return reinterpret_cast(this); } - VkVideoEncodeQualityLevelInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkFragmentShadingRateAttachmentInfoKHR(const VkFragmentShadingRateAttachmentInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkFragmentShadingRateAttachmentInfoKHR(const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src); + safe_VkFragmentShadingRateAttachmentInfoKHR& operator=(const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src); + safe_VkFragmentShadingRateAttachmentInfoKHR(); + ~safe_VkFragmentShadingRateAttachmentInfoKHR(); + void initialize(const VkFragmentShadingRateAttachmentInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkFragmentShadingRateAttachmentInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkFragmentShadingRateAttachmentInfoKHR* ptr() { return reinterpret_cast(this); } + VkFragmentShadingRateAttachmentInfoKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkVideoEncodeSessionParametersGetInfoKHR { +struct safe_VkPipelineFragmentShadingRateStateCreateInfoKHR { VkStructureType sType; const void* pNext{}; - VkVideoSessionParametersKHR videoSessionParameters; + VkExtent2D fragmentSize; + VkFragmentShadingRateCombinerOpKHR combinerOps[2]; - safe_VkVideoEncodeSessionParametersGetInfoKHR(const VkVideoEncodeSessionParametersGetInfoKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeSessionParametersGetInfoKHR(const safe_VkVideoEncodeSessionParametersGetInfoKHR& copy_src); - safe_VkVideoEncodeSessionParametersGetInfoKHR& operator=(const safe_VkVideoEncodeSessionParametersGetInfoKHR& copy_src); - safe_VkVideoEncodeSessionParametersGetInfoKHR(); - ~safe_VkVideoEncodeSessionParametersGetInfoKHR(); - void initialize(const VkVideoEncodeSessionParametersGetInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeSessionParametersGetInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeSessionParametersGetInfoKHR* ptr() { return reinterpret_cast(this); } - VkVideoEncodeSessionParametersGetInfoKHR const* ptr() const { - return reinterpret_cast(this); + safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src); + safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& operator=( + const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src); + safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(); + ~safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(); + void initialize(const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPipelineFragmentShadingRateStateCreateInfoKHR* ptr() { + return reinterpret_cast(this); + } + VkPipelineFragmentShadingRateStateCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeSessionParametersFeedbackInfoKHR { +struct safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR { VkStructureType sType; void* pNext{}; - VkBool32 hasOverrides; + VkBool32 pipelineFragmentShadingRate; + VkBool32 primitiveFragmentShadingRate; + VkBool32 attachmentFragmentShadingRate; - safe_VkVideoEncodeSessionParametersFeedbackInfoKHR(const VkVideoEncodeSessionParametersFeedbackInfoKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeSessionParametersFeedbackInfoKHR(const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& copy_src); - safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& operator=( - const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& copy_src); - safe_VkVideoEncodeSessionParametersFeedbackInfoKHR(); - ~safe_VkVideoEncodeSessionParametersFeedbackInfoKHR(); - void initialize(const VkVideoEncodeSessionParametersFeedbackInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeSessionParametersFeedbackInfoKHR* ptr() { - return reinterpret_cast(this); + safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src); + safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& operator=( + const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src); + safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(); + ~safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(); + void initialize(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceFragmentShadingRateFeaturesKHR* ptr() { + return reinterpret_cast(this); } - VkVideoEncodeSessionParametersFeedbackInfoKHR const* ptr() const { - return reinterpret_cast(this); + VkPhysicalDeviceFragmentShadingRateFeaturesKHR const* ptr() const { + return reinterpret_cast(this); } }; -#endif // VK_ENABLE_BETA_EXTENSIONS -struct safe_VkQueueFamilyCheckpointProperties2NV { +struct safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR { VkStructureType sType; void* pNext{}; - VkPipelineStageFlags2 checkpointExecutionStageMask; + VkExtent2D minFragmentShadingRateAttachmentTexelSize; + VkExtent2D maxFragmentShadingRateAttachmentTexelSize; + uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio; + VkBool32 primitiveFragmentShadingRateWithMultipleViewports; + VkBool32 layeredShadingRateAttachments; + VkBool32 fragmentShadingRateNonTrivialCombinerOps; + VkExtent2D maxFragmentSize; + uint32_t maxFragmentSizeAspectRatio; + uint32_t maxFragmentShadingRateCoverageSamples; + VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples; + VkBool32 fragmentShadingRateWithShaderDepthStencilWrites; + VkBool32 fragmentShadingRateWithSampleMask; + VkBool32 fragmentShadingRateWithShaderSampleMask; + VkBool32 fragmentShadingRateWithConservativeRasterization; + VkBool32 fragmentShadingRateWithFragmentShaderInterlock; + VkBool32 fragmentShadingRateWithCustomSampleLocations; + VkBool32 fragmentShadingRateStrictMultiplyCombiner; - safe_VkQueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkQueueFamilyCheckpointProperties2NV(const safe_VkQueueFamilyCheckpointProperties2NV& copy_src); - safe_VkQueueFamilyCheckpointProperties2NV& operator=(const safe_VkQueueFamilyCheckpointProperties2NV& copy_src); - safe_VkQueueFamilyCheckpointProperties2NV(); - ~safe_VkQueueFamilyCheckpointProperties2NV(); - void initialize(const VkQueueFamilyCheckpointProperties2NV* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkQueueFamilyCheckpointProperties2NV* copy_src, PNextCopyState* copy_state = {}); - VkQueueFamilyCheckpointProperties2NV* ptr() { return reinterpret_cast(this); } - VkQueueFamilyCheckpointProperties2NV const* ptr() const { - return reinterpret_cast(this); + safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src); + safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& operator=( + const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src); + safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(); + ~safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(); + void initialize(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceFragmentShadingRatePropertiesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceFragmentShadingRatePropertiesKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkCheckpointData2NV { +struct safe_VkPhysicalDeviceFragmentShadingRateKHR { VkStructureType sType; void* pNext{}; - VkPipelineStageFlags2 stage; - void* pCheckpointMarker{}; + VkSampleCountFlags sampleCounts; + VkExtent2D fragmentSize; - safe_VkCheckpointData2NV(const VkCheckpointData2NV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkCheckpointData2NV(const safe_VkCheckpointData2NV& copy_src); - safe_VkCheckpointData2NV& operator=(const safe_VkCheckpointData2NV& copy_src); - safe_VkCheckpointData2NV(); - ~safe_VkCheckpointData2NV(); - void initialize(const VkCheckpointData2NV* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkCheckpointData2NV* copy_src, PNextCopyState* copy_state = {}); - VkCheckpointData2NV* ptr() { return reinterpret_cast(this); } - VkCheckpointData2NV const* ptr() const { return reinterpret_cast(this); } + safe_VkPhysicalDeviceFragmentShadingRateKHR(const VkPhysicalDeviceFragmentShadingRateKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceFragmentShadingRateKHR(const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src); + safe_VkPhysicalDeviceFragmentShadingRateKHR& operator=(const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src); + safe_VkPhysicalDeviceFragmentShadingRateKHR(); + ~safe_VkPhysicalDeviceFragmentShadingRateKHR(); + void initialize(const VkPhysicalDeviceFragmentShadingRateKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceFragmentShadingRateKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceFragmentShadingRateKHR* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceFragmentShadingRateKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSurfaceProtectedCapabilitiesKHR { + VkStructureType sType; + const void* pNext{}; + VkBool32 supportsProtected; + + safe_VkSurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSurfaceProtectedCapabilitiesKHR(const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src); + safe_VkSurfaceProtectedCapabilitiesKHR& operator=(const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src); + safe_VkSurfaceProtectedCapabilitiesKHR(); + ~safe_VkSurfaceProtectedCapabilitiesKHR(); + void initialize(const VkSurfaceProtectedCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSurfaceProtectedCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkSurfaceProtectedCapabilitiesKHR* ptr() { return reinterpret_cast(this); } + VkSurfaceProtectedCapabilitiesKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR { +struct safe_VkPhysicalDevicePresentWaitFeaturesKHR { VkStructureType sType; void* pNext{}; - VkBool32 fragmentShaderBarycentric; + VkBool32 presentWait; - safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR( - const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& copy_src); - safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& operator=( - const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& copy_src); - safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(); - ~safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(); - void initialize(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR const* ptr() const { - return reinterpret_cast(this); + safe_VkPhysicalDevicePresentWaitFeaturesKHR(const VkPhysicalDevicePresentWaitFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePresentWaitFeaturesKHR(const safe_VkPhysicalDevicePresentWaitFeaturesKHR& copy_src); + safe_VkPhysicalDevicePresentWaitFeaturesKHR& operator=(const safe_VkPhysicalDevicePresentWaitFeaturesKHR& copy_src); + safe_VkPhysicalDevicePresentWaitFeaturesKHR(); + ~safe_VkPhysicalDevicePresentWaitFeaturesKHR(); + void initialize(const VkPhysicalDevicePresentWaitFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePresentWaitFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePresentWaitFeaturesKHR* ptr() { return reinterpret_cast(this); } + VkPhysicalDevicePresentWaitFeaturesKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR { +struct safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR { VkStructureType sType; void* pNext{}; - VkBool32 triStripVertexOrderIndependentOfProvokingVertex; + VkBool32 pipelineExecutableInfo; - safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR( - const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* in_struct, PNextCopyState* copy_state = {}, + safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR( + const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR( - const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& copy_src); - safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& operator=( - const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& copy_src); - safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(); - ~safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(); - void initialize(const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* ptr() { - return reinterpret_cast(this); + safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR( + const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src); + safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=( + const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src); + safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(); + ~safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(); + void initialize(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* ptr() { + return reinterpret_cast(this); } - VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR const* ptr() const { - return reinterpret_cast(this); + VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { +struct safe_VkPipelineInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkPipeline pipeline; + + safe_VkPipelineInfoKHR(const VkPipelineInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineInfoKHR(const safe_VkPipelineInfoKHR& copy_src); + safe_VkPipelineInfoKHR& operator=(const safe_VkPipelineInfoKHR& copy_src); + safe_VkPipelineInfoKHR(); + ~safe_VkPipelineInfoKHR(); + void initialize(const VkPipelineInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPipelineInfoKHR* ptr() { return reinterpret_cast(this); } + VkPipelineInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPipelineExecutablePropertiesKHR { VkStructureType sType; void* pNext{}; - VkBool32 shaderSubgroupUniformControlFlow; + VkShaderStageFlags stages; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + uint32_t subgroupSize; - safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR( - const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR( - const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& copy_src); - safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& operator=( - const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& copy_src); - safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(); - ~safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(); - void initialize(const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* copy_src, - PNextCopyState* copy_state = {}); - VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const* ptr() const { - return reinterpret_cast(this); + safe_VkPipelineExecutablePropertiesKHR(const VkPipelineExecutablePropertiesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineExecutablePropertiesKHR(const safe_VkPipelineExecutablePropertiesKHR& copy_src); + safe_VkPipelineExecutablePropertiesKHR& operator=(const safe_VkPipelineExecutablePropertiesKHR& copy_src); + safe_VkPipelineExecutablePropertiesKHR(); + ~safe_VkPipelineExecutablePropertiesKHR(); + void initialize(const VkPipelineExecutablePropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineExecutablePropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPipelineExecutablePropertiesKHR* ptr() { return reinterpret_cast(this); } + VkPipelineExecutablePropertiesKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { +struct safe_VkPipelineExecutableInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkPipeline pipeline; + uint32_t executableIndex; + + safe_VkPipelineExecutableInfoKHR(const VkPipelineExecutableInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineExecutableInfoKHR(const safe_VkPipelineExecutableInfoKHR& copy_src); + safe_VkPipelineExecutableInfoKHR& operator=(const safe_VkPipelineExecutableInfoKHR& copy_src); + safe_VkPipelineExecutableInfoKHR(); + ~safe_VkPipelineExecutableInfoKHR(); + void initialize(const VkPipelineExecutableInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineExecutableInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPipelineExecutableInfoKHR* ptr() { return reinterpret_cast(this); } + VkPipelineExecutableInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPipelineExecutableStatisticKHR { VkStructureType sType; void* pNext{}; - VkBool32 workgroupMemoryExplicitLayout; - VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout; - VkBool32 workgroupMemoryExplicitLayout8BitAccess; - VkBool32 workgroupMemoryExplicitLayout16BitAccess; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + VkPipelineExecutableStatisticFormatKHR format; + VkPipelineExecutableStatisticValueKHR value; - safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR( - const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR( - const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& copy_src); - safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& operator=( - const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& copy_src); - safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(); - ~safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(); - void initialize(const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const* ptr() const { - return reinterpret_cast(this); - } + safe_VkPipelineExecutableStatisticKHR(const VkPipelineExecutableStatisticKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineExecutableStatisticKHR(const safe_VkPipelineExecutableStatisticKHR& copy_src); + safe_VkPipelineExecutableStatisticKHR& operator=(const safe_VkPipelineExecutableStatisticKHR& copy_src); + safe_VkPipelineExecutableStatisticKHR(); + ~safe_VkPipelineExecutableStatisticKHR(); + void initialize(const VkPipelineExecutableStatisticKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineExecutableStatisticKHR* copy_src, PNextCopyState* copy_state = {}); + VkPipelineExecutableStatisticKHR* ptr() { return reinterpret_cast(this); } + VkPipelineExecutableStatisticKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR { +struct safe_VkPipelineExecutableInternalRepresentationKHR { VkStructureType sType; void* pNext{}; - VkBool32 rayTracingMaintenance1; - VkBool32 rayTracingPipelineTraceRaysIndirect2; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + VkBool32 isText; + size_t dataSize; + void* pData{}; - safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& copy_src); - safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& operator=( - const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& copy_src); - safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(); - ~safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(); - void initialize(const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* ptr() { - return reinterpret_cast(this); + safe_VkPipelineExecutableInternalRepresentationKHR(const VkPipelineExecutableInternalRepresentationKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineExecutableInternalRepresentationKHR(const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src); + safe_VkPipelineExecutableInternalRepresentationKHR& operator=( + const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src); + safe_VkPipelineExecutableInternalRepresentationKHR(); + ~safe_VkPipelineExecutableInternalRepresentationKHR(); + void initialize(const VkPipelineExecutableInternalRepresentationKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineExecutableInternalRepresentationKHR* copy_src, PNextCopyState* copy_state = {}); + VkPipelineExecutableInternalRepresentationKHR* ptr() { + return reinterpret_cast(this); } - VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR const* ptr() const { - return reinterpret_cast(this); + VkPipelineExecutableInternalRepresentationKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceMaintenance5FeaturesKHR { +struct safe_VkMemoryMapInfoKHR { VkStructureType sType; - void* pNext{}; - VkBool32 maintenance5; + const void* pNext{}; + VkMemoryMapFlags flags; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; - 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); - } + 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_VkPhysicalDeviceMaintenance5PropertiesKHR { +struct safe_VkMemoryUnmapInfoKHR { VkStructureType sType; - void* pNext{}; - VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting; - VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting; - VkBool32 depthStencilSwizzleOneSupport; - VkBool32 polygonModePointSize; - VkBool32 nonStrictSinglePixelWideLinesUseParallelogram; - VkBool32 nonStrictWideLinesUseParallelogram; + 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{}; + uint32_t libraryCount; + VkPipeline* pLibraries{}; - 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); - } + safe_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineLibraryCreateInfoKHR(const safe_VkPipelineLibraryCreateInfoKHR& copy_src); + safe_VkPipelineLibraryCreateInfoKHR& operator=(const safe_VkPipelineLibraryCreateInfoKHR& copy_src); + safe_VkPipelineLibraryCreateInfoKHR(); + ~safe_VkPipelineLibraryCreateInfoKHR(); + void initialize(const VkPipelineLibraryCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineLibraryCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPipelineLibraryCreateInfoKHR* ptr() { return reinterpret_cast(this); } + VkPipelineLibraryCreateInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkRenderingAreaInfoKHR { +struct safe_VkPresentIdKHR { VkStructureType sType; const void* pNext{}; - uint32_t viewMask; - uint32_t colorAttachmentCount; - const VkFormat* pColorAttachmentFormats{}; - VkFormat depthAttachmentFormat; - VkFormat stencilAttachmentFormat; + uint32_t swapchainCount; + const uint64_t* pPresentIds{}; - 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); } + safe_VkPresentIdKHR(const VkPresentIdKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPresentIdKHR(const safe_VkPresentIdKHR& copy_src); + safe_VkPresentIdKHR& operator=(const safe_VkPresentIdKHR& copy_src); + safe_VkPresentIdKHR(); + ~safe_VkPresentIdKHR(); + void initialize(const VkPresentIdKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPresentIdKHR* copy_src, PNextCopyState* copy_state = {}); + VkPresentIdKHR* ptr() { return reinterpret_cast(this); } + VkPresentIdKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkImageSubresource2KHR { +struct safe_VkPhysicalDevicePresentIdFeaturesKHR { VkStructureType sType; void* pNext{}; - VkImageSubresource imageSubresource; + VkBool32 presentId; - 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); } + safe_VkPhysicalDevicePresentIdFeaturesKHR(const VkPhysicalDevicePresentIdFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePresentIdFeaturesKHR(const safe_VkPhysicalDevicePresentIdFeaturesKHR& copy_src); + safe_VkPhysicalDevicePresentIdFeaturesKHR& operator=(const safe_VkPhysicalDevicePresentIdFeaturesKHR& copy_src); + safe_VkPhysicalDevicePresentIdFeaturesKHR(); + ~safe_VkPhysicalDevicePresentIdFeaturesKHR(); + void initialize(const VkPhysicalDevicePresentIdFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePresentIdFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePresentIdFeaturesKHR* ptr() { return reinterpret_cast(this); } + VkPhysicalDevicePresentIdFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkDeviceImageSubresourceInfoKHR { +struct safe_VkVideoEncodeInfoKHR { VkStructureType sType; const void* pNext{}; - safe_VkImageCreateInfo* pCreateInfo{}; - safe_VkImageSubresource2KHR* pSubresource{}; + VkVideoEncodeFlagsKHR flags; + VkBuffer dstBuffer; + VkDeviceSize dstBufferOffset; + VkDeviceSize dstBufferRange; + safe_VkVideoPictureResourceInfoKHR srcPictureResource; + safe_VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot{}; + uint32_t referenceSlotCount; + safe_VkVideoReferenceSlotInfoKHR* pReferenceSlots{}; + uint32_t precedingExternallyEncodedBytes; - 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); } + safe_VkVideoEncodeInfoKHR(const VkVideoEncodeInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeInfoKHR(const safe_VkVideoEncodeInfoKHR& copy_src); + safe_VkVideoEncodeInfoKHR& operator=(const safe_VkVideoEncodeInfoKHR& copy_src); + safe_VkVideoEncodeInfoKHR(); + ~safe_VkVideoEncodeInfoKHR(); + void initialize(const VkVideoEncodeInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkSubresourceLayout2KHR { +struct safe_VkVideoEncodeCapabilitiesKHR { VkStructureType sType; void* pNext{}; - VkSubresourceLayout subresourceLayout; + VkVideoEncodeCapabilityFlagsKHR flags; + VkVideoEncodeRateControlModeFlagsKHR rateControlModes; + uint32_t maxRateControlLayers; + uint64_t maxBitrate; + uint32_t maxQualityLevels; + VkExtent2D encodeInputPictureGranularity; + VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags; - 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); } + safe_VkVideoEncodeCapabilitiesKHR(const VkVideoEncodeCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoEncodeCapabilitiesKHR(const safe_VkVideoEncodeCapabilitiesKHR& copy_src); + safe_VkVideoEncodeCapabilitiesKHR& operator=(const safe_VkVideoEncodeCapabilitiesKHR& copy_src); + safe_VkVideoEncodeCapabilitiesKHR(); + ~safe_VkVideoEncodeCapabilitiesKHR(); + void initialize(const VkVideoEncodeCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeCapabilitiesKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeCapabilitiesKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPipelineCreateFlags2CreateInfoKHR { +struct safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR { VkStructureType sType; const void* pNext{}; - VkPipelineCreateFlags2KHR flags; + VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags; - 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); + safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& copy_src); + safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& operator=(const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& copy_src); + safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(); + ~safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(); + void initialize(const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* ptr() { + return reinterpret_cast(this); + } + VkQueryPoolVideoEncodeFeedbackCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkBufferUsageFlags2CreateInfoKHR { +struct safe_VkVideoEncodeUsageInfoKHR { VkStructureType sType; const void* pNext{}; - VkBufferUsageFlags2KHR usage; + VkVideoEncodeUsageFlagsKHR videoUsageHints; + VkVideoEncodeContentFlagsKHR videoContentHints; + VkVideoEncodeTuningModeKHR tuningMode; - 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); } + safe_VkVideoEncodeUsageInfoKHR(const VkVideoEncodeUsageInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoEncodeUsageInfoKHR(const safe_VkVideoEncodeUsageInfoKHR& copy_src); + safe_VkVideoEncodeUsageInfoKHR& operator=(const safe_VkVideoEncodeUsageInfoKHR& copy_src); + safe_VkVideoEncodeUsageInfoKHR(); + ~safe_VkVideoEncodeUsageInfoKHR(); + void initialize(const VkVideoEncodeUsageInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeUsageInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeUsageInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeUsageInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR { +struct safe_VkVideoEncodeRateControlLayerInfoKHR { VkStructureType sType; - void* pNext{}; - VkBool32 rayTracingPositionFetch; + const void* pNext{}; + uint64_t averageBitrate; + uint64_t maxBitrate; + uint32_t frameRateNumerator; + uint32_t frameRateDenominator; - safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR( - const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src); - safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& operator=( - const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src); - safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(); - ~safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(); - void initialize(const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR const* ptr() const { - return reinterpret_cast(this); + safe_VkVideoEncodeRateControlLayerInfoKHR(const VkVideoEncodeRateControlLayerInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeRateControlLayerInfoKHR(const safe_VkVideoEncodeRateControlLayerInfoKHR& copy_src); + safe_VkVideoEncodeRateControlLayerInfoKHR& operator=(const safe_VkVideoEncodeRateControlLayerInfoKHR& copy_src); + safe_VkVideoEncodeRateControlLayerInfoKHR(); + ~safe_VkVideoEncodeRateControlLayerInfoKHR(); + void initialize(const VkVideoEncodeRateControlLayerInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeRateControlLayerInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeRateControlLayerInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeRateControlLayerInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkCooperativeMatrixPropertiesKHR { - VkStructureType sType; - void* pNext{}; - uint32_t MSize; - uint32_t NSize; - uint32_t KSize; - VkComponentTypeKHR AType; - VkComponentTypeKHR BType; - VkComponentTypeKHR CType; - VkComponentTypeKHR ResultType; - VkBool32 saturatingAccumulation; - VkScopeKHR scope; - - safe_VkCooperativeMatrixPropertiesKHR(const VkCooperativeMatrixPropertiesKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkCooperativeMatrixPropertiesKHR(const safe_VkCooperativeMatrixPropertiesKHR& copy_src); - safe_VkCooperativeMatrixPropertiesKHR& operator=(const safe_VkCooperativeMatrixPropertiesKHR& copy_src); - safe_VkCooperativeMatrixPropertiesKHR(); - ~safe_VkCooperativeMatrixPropertiesKHR(); - void initialize(const VkCooperativeMatrixPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkCooperativeMatrixPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkCooperativeMatrixPropertiesKHR* ptr() { return reinterpret_cast(this); } - VkCooperativeMatrixPropertiesKHR const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR { +struct safe_VkVideoEncodeRateControlInfoKHR { VkStructureType sType; - void* pNext{}; - VkBool32 cooperativeMatrix; - VkBool32 cooperativeMatrixRobustBufferAccess; + const void* pNext{}; + VkVideoEncodeRateControlFlagsKHR flags; + VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode; + uint32_t layerCount; + safe_VkVideoEncodeRateControlLayerInfoKHR* pLayers{}; + uint32_t virtualBufferSizeInMs; + uint32_t initialVirtualBufferSizeInMs; - safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src); - safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& operator=(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src); - safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(); - ~safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(); - void initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceCooperativeMatrixFeaturesKHR* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDeviceCooperativeMatrixFeaturesKHR const* ptr() const { - return reinterpret_cast(this); - } + safe_VkVideoEncodeRateControlInfoKHR(const VkVideoEncodeRateControlInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoEncodeRateControlInfoKHR(const safe_VkVideoEncodeRateControlInfoKHR& copy_src); + safe_VkVideoEncodeRateControlInfoKHR& operator=(const safe_VkVideoEncodeRateControlInfoKHR& copy_src); + safe_VkVideoEncodeRateControlInfoKHR(); + ~safe_VkVideoEncodeRateControlInfoKHR(); + void initialize(const VkVideoEncodeRateControlInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeRateControlInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeRateControlInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeRateControlInfoKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR { +struct safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR { VkStructureType sType; - void* pNext{}; - VkShaderStageFlags cooperativeMatrixSupportedStages; + const void* pNext{}; + safe_VkVideoProfileInfoKHR* pVideoProfile{}; + uint32_t qualityLevel; - safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* in_struct, + safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src); - safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& operator=( - const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src); - safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(); - ~safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(); - void initialize(const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceCooperativeMatrixPropertiesKHR* ptr() { - return reinterpret_cast(this); + safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& copy_src); + safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& operator=( + const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& copy_src); + safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(); + ~safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(); + void initialize(const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* ptr() { + return reinterpret_cast(this); } - VkPhysicalDeviceCooperativeMatrixPropertiesKHR const* ptr() const { - return reinterpret_cast(this); + VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR { +struct safe_VkVideoEncodeQualityLevelPropertiesKHR { VkStructureType sType; void* pNext{}; - uint32_t maxVertexAttribDivisor; - VkBool32 supportsNonZeroFirstInstance; + VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode; + uint32_t preferredRateControlLayerCount; - 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); + safe_VkVideoEncodeQualityLevelPropertiesKHR(const VkVideoEncodeQualityLevelPropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeQualityLevelPropertiesKHR(const safe_VkVideoEncodeQualityLevelPropertiesKHR& copy_src); + safe_VkVideoEncodeQualityLevelPropertiesKHR& operator=(const safe_VkVideoEncodeQualityLevelPropertiesKHR& copy_src); + safe_VkVideoEncodeQualityLevelPropertiesKHR(); + ~safe_VkVideoEncodeQualityLevelPropertiesKHR(); + void initialize(const VkVideoEncodeQualityLevelPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeQualityLevelPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeQualityLevelPropertiesKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeQualityLevelPropertiesKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkPipelineVertexInputDivisorStateCreateInfoKHR { +struct safe_VkVideoEncodeQualityLevelInfoKHR { VkStructureType sType; const void* pNext{}; - uint32_t vertexBindingDivisorCount; - const VkVertexInputBindingDivisorDescriptionKHR* pVertexBindingDivisors{}; + uint32_t qualityLevel; - 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); + safe_VkVideoEncodeQualityLevelInfoKHR(const VkVideoEncodeQualityLevelInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoEncodeQualityLevelInfoKHR(const safe_VkVideoEncodeQualityLevelInfoKHR& copy_src); + safe_VkVideoEncodeQualityLevelInfoKHR& operator=(const safe_VkVideoEncodeQualityLevelInfoKHR& copy_src); + safe_VkVideoEncodeQualityLevelInfoKHR(); + ~safe_VkVideoEncodeQualityLevelInfoKHR(); + void initialize(const VkVideoEncodeQualityLevelInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeQualityLevelInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeQualityLevelInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeQualityLevelInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoEncodeSessionParametersGetInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkVideoSessionParametersKHR videoSessionParameters; + + safe_VkVideoEncodeSessionParametersGetInfoKHR(const VkVideoEncodeSessionParametersGetInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeSessionParametersGetInfoKHR(const safe_VkVideoEncodeSessionParametersGetInfoKHR& copy_src); + safe_VkVideoEncodeSessionParametersGetInfoKHR& operator=(const safe_VkVideoEncodeSessionParametersGetInfoKHR& copy_src); + safe_VkVideoEncodeSessionParametersGetInfoKHR(); + ~safe_VkVideoEncodeSessionParametersGetInfoKHR(); + void initialize(const VkVideoEncodeSessionParametersGetInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeSessionParametersGetInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeSessionParametersGetInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEncodeSessionParametersGetInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR { +struct safe_VkVideoEncodeSessionParametersFeedbackInfoKHR { VkStructureType sType; void* pNext{}; - VkBool32 vertexAttributeInstanceRateDivisor; - VkBool32 vertexAttributeInstanceRateZeroDivisor; + VkBool32 hasOverrides; - 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); + safe_VkVideoEncodeSessionParametersFeedbackInfoKHR(const VkVideoEncodeSessionParametersFeedbackInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeSessionParametersFeedbackInfoKHR(const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& copy_src); + safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& operator=( + const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& copy_src); + safe_VkVideoEncodeSessionParametersFeedbackInfoKHR(); + ~safe_VkVideoEncodeSessionParametersFeedbackInfoKHR(); + void initialize(const VkVideoEncodeSessionParametersFeedbackInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeSessionParametersFeedbackInfoKHR* ptr() { + return reinterpret_cast(this); } - VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR const* ptr() const { - return reinterpret_cast(this); + VkVideoEncodeSessionParametersFeedbackInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkCalibratedTimestampInfoKHR { +struct safe_VkQueueFamilyCheckpointProperties2NV { VkStructureType sType; - const void* pNext{}; - VkTimeDomainKHR timeDomain; + void* pNext{}; + VkPipelineStageFlags2 checkpointExecutionStageMask; - safe_VkCalibratedTimestampInfoKHR(const VkCalibratedTimestampInfoKHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkCalibratedTimestampInfoKHR(const safe_VkCalibratedTimestampInfoKHR& copy_src); - safe_VkCalibratedTimestampInfoKHR& operator=(const safe_VkCalibratedTimestampInfoKHR& copy_src); - safe_VkCalibratedTimestampInfoKHR(); - ~safe_VkCalibratedTimestampInfoKHR(); - void initialize(const VkCalibratedTimestampInfoKHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkCalibratedTimestampInfoKHR* copy_src, PNextCopyState* copy_state = {}); - VkCalibratedTimestampInfoKHR* ptr() { return reinterpret_cast(this); } - VkCalibratedTimestampInfoKHR const* ptr() const { return reinterpret_cast(this); } + safe_VkQueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkQueueFamilyCheckpointProperties2NV(const safe_VkQueueFamilyCheckpointProperties2NV& copy_src); + safe_VkQueueFamilyCheckpointProperties2NV& operator=(const safe_VkQueueFamilyCheckpointProperties2NV& copy_src); + safe_VkQueueFamilyCheckpointProperties2NV(); + ~safe_VkQueueFamilyCheckpointProperties2NV(); + void initialize(const VkQueueFamilyCheckpointProperties2NV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkQueueFamilyCheckpointProperties2NV* copy_src, PNextCopyState* copy_state = {}); + VkQueueFamilyCheckpointProperties2NV* ptr() { return reinterpret_cast(this); } + VkQueueFamilyCheckpointProperties2NV const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkDebugReportCallbackCreateInfoEXT { +struct safe_VkCheckpointData2NV { VkStructureType sType; - const void* pNext{}; - VkDebugReportFlagsEXT flags; - PFN_vkDebugReportCallbackEXT pfnCallback; - void* pUserData{}; + void* pNext{}; + VkPipelineStageFlags2 stage; + void* pCheckpointMarker{}; - safe_VkDebugReportCallbackCreateInfoEXT(const VkDebugReportCallbackCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkDebugReportCallbackCreateInfoEXT(const safe_VkDebugReportCallbackCreateInfoEXT& copy_src); - safe_VkDebugReportCallbackCreateInfoEXT& operator=(const safe_VkDebugReportCallbackCreateInfoEXT& copy_src); - safe_VkDebugReportCallbackCreateInfoEXT(); - ~safe_VkDebugReportCallbackCreateInfoEXT(); - void initialize(const VkDebugReportCallbackCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkDebugReportCallbackCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkDebugReportCallbackCreateInfoEXT* ptr() { return reinterpret_cast(this); } - VkDebugReportCallbackCreateInfoEXT const* ptr() const { - return reinterpret_cast(this); - } + safe_VkCheckpointData2NV(const VkCheckpointData2NV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkCheckpointData2NV(const safe_VkCheckpointData2NV& copy_src); + safe_VkCheckpointData2NV& operator=(const safe_VkCheckpointData2NV& copy_src); + safe_VkCheckpointData2NV(); + ~safe_VkCheckpointData2NV(); + void initialize(const VkCheckpointData2NV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCheckpointData2NV* copy_src, PNextCopyState* copy_state = {}); + VkCheckpointData2NV* ptr() { return reinterpret_cast(this); } + VkCheckpointData2NV const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkPipelineRasterizationStateRasterizationOrderAMD { +struct safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR { VkStructureType sType; - const void* pNext{}; - VkRasterizationOrderAMD rasterizationOrder; + void* pNext{}; + VkBool32 fragmentShaderBarycentric; - safe_VkPipelineRasterizationStateRasterizationOrderAMD(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPipelineRasterizationStateRasterizationOrderAMD(const safe_VkPipelineRasterizationStateRasterizationOrderAMD& copy_src); - safe_VkPipelineRasterizationStateRasterizationOrderAMD& operator=( - const safe_VkPipelineRasterizationStateRasterizationOrderAMD& copy_src); - safe_VkPipelineRasterizationStateRasterizationOrderAMD(); - ~safe_VkPipelineRasterizationStateRasterizationOrderAMD(); - void initialize(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPipelineRasterizationStateRasterizationOrderAMD* copy_src, PNextCopyState* copy_state = {}); - VkPipelineRasterizationStateRasterizationOrderAMD* ptr() { - return reinterpret_cast(this); + safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR( + const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& copy_src); + safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& operator=( + const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& copy_src); + safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(); + ~safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(); + void initialize(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* ptr() { + return reinterpret_cast(this); } - VkPipelineRasterizationStateRasterizationOrderAMD const* ptr() const { - return reinterpret_cast(this); + VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkDebugMarkerObjectNameInfoEXT { +struct safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR { VkStructureType sType; - const void* pNext{}; - VkDebugReportObjectTypeEXT objectType; - uint64_t object; - const char* pObjectName{}; + void* pNext{}; + VkBool32 triStripVertexOrderIndependentOfProvokingVertex; - safe_VkDebugMarkerObjectNameInfoEXT(const VkDebugMarkerObjectNameInfoEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkDebugMarkerObjectNameInfoEXT(const safe_VkDebugMarkerObjectNameInfoEXT& copy_src); - safe_VkDebugMarkerObjectNameInfoEXT& operator=(const safe_VkDebugMarkerObjectNameInfoEXT& copy_src); - safe_VkDebugMarkerObjectNameInfoEXT(); - ~safe_VkDebugMarkerObjectNameInfoEXT(); - void initialize(const VkDebugMarkerObjectNameInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkDebugMarkerObjectNameInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkDebugMarkerObjectNameInfoEXT* ptr() { return reinterpret_cast(this); } - VkDebugMarkerObjectNameInfoEXT const* ptr() const { return reinterpret_cast(this); } + safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR( + const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR( + const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& copy_src); + safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& operator=( + const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& copy_src); + safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(); + ~safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(); + void initialize(const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkDebugMarkerObjectTagInfoEXT { +struct safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { VkStructureType sType; - const void* pNext{}; - VkDebugReportObjectTypeEXT objectType; - uint64_t object; - uint64_t tagName; - size_t tagSize; - const void* pTag{}; + void* pNext{}; + VkBool32 shaderSubgroupUniformControlFlow; - safe_VkDebugMarkerObjectTagInfoEXT(const VkDebugMarkerObjectTagInfoEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkDebugMarkerObjectTagInfoEXT(const safe_VkDebugMarkerObjectTagInfoEXT& copy_src); - safe_VkDebugMarkerObjectTagInfoEXT& operator=(const safe_VkDebugMarkerObjectTagInfoEXT& copy_src); - safe_VkDebugMarkerObjectTagInfoEXT(); - ~safe_VkDebugMarkerObjectTagInfoEXT(); - void initialize(const VkDebugMarkerObjectTagInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkDebugMarkerObjectTagInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkDebugMarkerObjectTagInfoEXT* ptr() { return reinterpret_cast(this); } - VkDebugMarkerObjectTagInfoEXT const* ptr() const { return reinterpret_cast(this); } + safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR( + const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR( + const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& copy_src); + safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& operator=( + const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& copy_src); + safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(); + ~safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(); + void initialize(const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* copy_src, + PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkDebugMarkerMarkerInfoEXT { +struct safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { VkStructureType sType; - const void* pNext{}; - const char* pMarkerName{}; - float color[4]; + void* pNext{}; + VkBool32 workgroupMemoryExplicitLayout; + VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout; + VkBool32 workgroupMemoryExplicitLayout8BitAccess; + VkBool32 workgroupMemoryExplicitLayout16BitAccess; - safe_VkDebugMarkerMarkerInfoEXT(const VkDebugMarkerMarkerInfoEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkDebugMarkerMarkerInfoEXT(const safe_VkDebugMarkerMarkerInfoEXT& copy_src); - safe_VkDebugMarkerMarkerInfoEXT& operator=(const safe_VkDebugMarkerMarkerInfoEXT& copy_src); - safe_VkDebugMarkerMarkerInfoEXT(); - ~safe_VkDebugMarkerMarkerInfoEXT(); - void initialize(const VkDebugMarkerMarkerInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkDebugMarkerMarkerInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkDebugMarkerMarkerInfoEXT* ptr() { return reinterpret_cast(this); } - VkDebugMarkerMarkerInfoEXT const* ptr() const { return reinterpret_cast(this); } + safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR( + const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR( + const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& copy_src); + safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& operator=( + const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& copy_src); + safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(); + ~safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(); + void initialize(const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkDedicatedAllocationImageCreateInfoNV { +struct safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR { VkStructureType sType; - const void* pNext{}; - VkBool32 dedicatedAllocation; + void* pNext{}; + VkBool32 rayTracingMaintenance1; + VkBool32 rayTracingPipelineTraceRaysIndirect2; - safe_VkDedicatedAllocationImageCreateInfoNV(const VkDedicatedAllocationImageCreateInfoNV* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkDedicatedAllocationImageCreateInfoNV(const safe_VkDedicatedAllocationImageCreateInfoNV& copy_src); - safe_VkDedicatedAllocationImageCreateInfoNV& operator=(const safe_VkDedicatedAllocationImageCreateInfoNV& copy_src); - safe_VkDedicatedAllocationImageCreateInfoNV(); - ~safe_VkDedicatedAllocationImageCreateInfoNV(); - void initialize(const VkDedicatedAllocationImageCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkDedicatedAllocationImageCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); - VkDedicatedAllocationImageCreateInfoNV* ptr() { return reinterpret_cast(this); } - VkDedicatedAllocationImageCreateInfoNV const* ptr() const { - return reinterpret_cast(this); + safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& copy_src); + safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& operator=( + const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& copy_src); + safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(); + ~safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(); + void initialize(const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkDedicatedAllocationBufferCreateInfoNV { +struct safe_VkPhysicalDeviceMaintenance5FeaturesKHR { VkStructureType sType; - const void* pNext{}; - VkBool32 dedicatedAllocation; + void* pNext{}; + VkBool32 maintenance5; - safe_VkDedicatedAllocationBufferCreateInfoNV(const VkDedicatedAllocationBufferCreateInfoNV* in_struct, + safe_VkPhysicalDeviceMaintenance5FeaturesKHR(const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkDedicatedAllocationBufferCreateInfoNV(const safe_VkDedicatedAllocationBufferCreateInfoNV& copy_src); - safe_VkDedicatedAllocationBufferCreateInfoNV& operator=(const safe_VkDedicatedAllocationBufferCreateInfoNV& copy_src); - safe_VkDedicatedAllocationBufferCreateInfoNV(); - ~safe_VkDedicatedAllocationBufferCreateInfoNV(); - void initialize(const VkDedicatedAllocationBufferCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkDedicatedAllocationBufferCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); - VkDedicatedAllocationBufferCreateInfoNV* ptr() { return reinterpret_cast(this); } - VkDedicatedAllocationBufferCreateInfoNV const* ptr() const { - return reinterpret_cast(this); + 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_VkDedicatedAllocationMemoryAllocateInfoNV { +struct safe_VkPhysicalDeviceMaintenance5PropertiesKHR { VkStructureType sType; - const void* pNext{}; - VkImage image; - VkBuffer buffer; + void* pNext{}; + VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting; + VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting; + VkBool32 depthStencilSwizzleOneSupport; + VkBool32 polygonModePointSize; + VkBool32 nonStrictSinglePixelWideLinesUseParallelogram; + VkBool32 nonStrictWideLinesUseParallelogram; - safe_VkDedicatedAllocationMemoryAllocateInfoNV(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct, + safe_VkPhysicalDeviceMaintenance5PropertiesKHR(const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkDedicatedAllocationMemoryAllocateInfoNV(const safe_VkDedicatedAllocationMemoryAllocateInfoNV& copy_src); - safe_VkDedicatedAllocationMemoryAllocateInfoNV& operator=(const safe_VkDedicatedAllocationMemoryAllocateInfoNV& copy_src); - safe_VkDedicatedAllocationMemoryAllocateInfoNV(); - ~safe_VkDedicatedAllocationMemoryAllocateInfoNV(); - void initialize(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkDedicatedAllocationMemoryAllocateInfoNV* copy_src, PNextCopyState* copy_state = {}); - VkDedicatedAllocationMemoryAllocateInfoNV* ptr() { return reinterpret_cast(this); } - VkDedicatedAllocationMemoryAllocateInfoNV const* ptr() const { - return reinterpret_cast(this); + 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_VkPhysicalDeviceTransformFeedbackFeaturesEXT { +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{}; - VkBool32 transformFeedback; - VkBool32 geometryStreams; + VkImageSubresource imageSubresource; - safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& copy_src); - safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& operator=(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& copy_src); - safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(); - ~safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(); - void initialize(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceTransformFeedbackFeaturesEXT* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDeviceTransformFeedbackFeaturesEXT const* ptr() const { - return reinterpret_cast(this); - } + 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_VkPhysicalDeviceTransformFeedbackPropertiesEXT { +struct safe_VkDeviceImageSubresourceInfoKHR { VkStructureType sType; - void* pNext{}; - uint32_t maxTransformFeedbackStreams; - uint32_t maxTransformFeedbackBuffers; - VkDeviceSize maxTransformFeedbackBufferSize; - uint32_t maxTransformFeedbackStreamDataSize; - uint32_t maxTransformFeedbackBufferDataSize; - uint32_t maxTransformFeedbackBufferDataStride; - VkBool32 transformFeedbackQueries; - VkBool32 transformFeedbackStreamsLinesTriangles; - VkBool32 transformFeedbackRasterizationStreamSelect; - VkBool32 transformFeedbackDraw; + const void* pNext{}; + safe_VkImageCreateInfo* pCreateInfo{}; + safe_VkImageSubresource2KHR* pSubresource{}; - safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& copy_src); - safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& operator=( - const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& copy_src); - safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(); - ~safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(); - void initialize(const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceTransformFeedbackPropertiesEXT* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDeviceTransformFeedbackPropertiesEXT const* ptr() const { - return reinterpret_cast(this); - } + 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_VkPipelineRasterizationStateStreamCreateInfoEXT { +struct safe_VkSubresourceLayout2KHR { VkStructureType sType; - const void* pNext{}; - VkPipelineRasterizationStateStreamCreateFlagsEXT flags; - uint32_t rasterizationStream; + void* pNext{}; + VkSubresourceLayout subresourceLayout; - safe_VkPipelineRasterizationStateStreamCreateInfoEXT(const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPipelineRasterizationStateStreamCreateInfoEXT(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& copy_src); - safe_VkPipelineRasterizationStateStreamCreateInfoEXT& operator=( - const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& copy_src); - safe_VkPipelineRasterizationStateStreamCreateInfoEXT(); - ~safe_VkPipelineRasterizationStateStreamCreateInfoEXT(); - void initialize(const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkPipelineRasterizationStateStreamCreateInfoEXT* ptr() { - return reinterpret_cast(this); - } - VkPipelineRasterizationStateStreamCreateInfoEXT const* ptr() const { - return reinterpret_cast(this); - } + 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_VkCuModuleCreateInfoNVX { +struct safe_VkPipelineCreateFlags2CreateInfoKHR { VkStructureType sType; const void* pNext{}; - size_t dataSize; - const void* pData{}; + VkPipelineCreateFlags2KHR flags; - safe_VkCuModuleCreateInfoNVX(const VkCuModuleCreateInfoNVX* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkCuModuleCreateInfoNVX(const safe_VkCuModuleCreateInfoNVX& copy_src); - safe_VkCuModuleCreateInfoNVX& operator=(const safe_VkCuModuleCreateInfoNVX& copy_src); - safe_VkCuModuleCreateInfoNVX(); - ~safe_VkCuModuleCreateInfoNVX(); - void initialize(const VkCuModuleCreateInfoNVX* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkCuModuleCreateInfoNVX* copy_src, PNextCopyState* copy_state = {}); - VkCuModuleCreateInfoNVX* ptr() { return reinterpret_cast(this); } - VkCuModuleCreateInfoNVX const* ptr() const { return reinterpret_cast(this); } + 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_VkCuFunctionCreateInfoNVX { +struct safe_VkBufferUsageFlags2CreateInfoKHR { VkStructureType sType; const void* pNext{}; - VkCuModuleNVX module; - const char* pName{}; + VkBufferUsageFlags2KHR usage; - safe_VkCuFunctionCreateInfoNVX(const VkCuFunctionCreateInfoNVX* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkCuFunctionCreateInfoNVX(const safe_VkCuFunctionCreateInfoNVX& copy_src); - safe_VkCuFunctionCreateInfoNVX& operator=(const safe_VkCuFunctionCreateInfoNVX& copy_src); - safe_VkCuFunctionCreateInfoNVX(); - ~safe_VkCuFunctionCreateInfoNVX(); - void initialize(const VkCuFunctionCreateInfoNVX* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkCuFunctionCreateInfoNVX* copy_src, PNextCopyState* copy_state = {}); - VkCuFunctionCreateInfoNVX* ptr() { return reinterpret_cast(this); } - VkCuFunctionCreateInfoNVX const* ptr() const { return reinterpret_cast(this); } + 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_VkCuLaunchInfoNVX { +struct safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR { VkStructureType sType; - const void* pNext{}; - VkCuFunctionNVX function; - uint32_t gridDimX; - uint32_t gridDimY; - uint32_t gridDimZ; - uint32_t blockDimX; - uint32_t blockDimY; - uint32_t blockDimZ; - uint32_t sharedMemBytes; - size_t paramCount; - const void* const* pParams{}; - size_t extraCount; - const void* const* pExtras{}; + void* pNext{}; + VkBool32 rayTracingPositionFetch; - safe_VkCuLaunchInfoNVX(const VkCuLaunchInfoNVX* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkCuLaunchInfoNVX(const safe_VkCuLaunchInfoNVX& copy_src); - safe_VkCuLaunchInfoNVX& operator=(const safe_VkCuLaunchInfoNVX& copy_src); - safe_VkCuLaunchInfoNVX(); - ~safe_VkCuLaunchInfoNVX(); - void initialize(const VkCuLaunchInfoNVX* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkCuLaunchInfoNVX* copy_src, PNextCopyState* copy_state = {}); - VkCuLaunchInfoNVX* ptr() { return reinterpret_cast(this); } - VkCuLaunchInfoNVX const* ptr() const { return reinterpret_cast(this); } + safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR( + const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src); + safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& operator=( + const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src); + safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(); + ~safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(); + void initialize(const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkImageViewHandleInfoNVX { +struct safe_VkCooperativeMatrixPropertiesKHR { VkStructureType sType; - const void* pNext{}; - VkImageView imageView; - VkDescriptorType descriptorType; - VkSampler sampler; + void* pNext{}; + uint32_t MSize; + uint32_t NSize; + uint32_t KSize; + VkComponentTypeKHR AType; + VkComponentTypeKHR BType; + VkComponentTypeKHR CType; + VkComponentTypeKHR ResultType; + VkBool32 saturatingAccumulation; + VkScopeKHR scope; - safe_VkImageViewHandleInfoNVX(const VkImageViewHandleInfoNVX* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkImageViewHandleInfoNVX(const safe_VkImageViewHandleInfoNVX& copy_src); - safe_VkImageViewHandleInfoNVX& operator=(const safe_VkImageViewHandleInfoNVX& copy_src); - safe_VkImageViewHandleInfoNVX(); - ~safe_VkImageViewHandleInfoNVX(); - void initialize(const VkImageViewHandleInfoNVX* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkImageViewHandleInfoNVX* copy_src, PNextCopyState* copy_state = {}); - VkImageViewHandleInfoNVX* ptr() { return reinterpret_cast(this); } - VkImageViewHandleInfoNVX const* ptr() const { return reinterpret_cast(this); } + safe_VkCooperativeMatrixPropertiesKHR(const VkCooperativeMatrixPropertiesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCooperativeMatrixPropertiesKHR(const safe_VkCooperativeMatrixPropertiesKHR& copy_src); + safe_VkCooperativeMatrixPropertiesKHR& operator=(const safe_VkCooperativeMatrixPropertiesKHR& copy_src); + safe_VkCooperativeMatrixPropertiesKHR(); + ~safe_VkCooperativeMatrixPropertiesKHR(); + void initialize(const VkCooperativeMatrixPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCooperativeMatrixPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkCooperativeMatrixPropertiesKHR* ptr() { return reinterpret_cast(this); } + VkCooperativeMatrixPropertiesKHR const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkImageViewAddressPropertiesNVX { +struct safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR { VkStructureType sType; void* pNext{}; - VkDeviceAddress deviceAddress; - VkDeviceSize size; + VkBool32 cooperativeMatrix; + VkBool32 cooperativeMatrixRobustBufferAccess; - safe_VkImageViewAddressPropertiesNVX(const VkImageViewAddressPropertiesNVX* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkImageViewAddressPropertiesNVX(const safe_VkImageViewAddressPropertiesNVX& copy_src); - safe_VkImageViewAddressPropertiesNVX& operator=(const safe_VkImageViewAddressPropertiesNVX& copy_src); - safe_VkImageViewAddressPropertiesNVX(); - ~safe_VkImageViewAddressPropertiesNVX(); - void initialize(const VkImageViewAddressPropertiesNVX* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkImageViewAddressPropertiesNVX* copy_src, PNextCopyState* copy_state = {}); - VkImageViewAddressPropertiesNVX* ptr() { return reinterpret_cast(this); } - VkImageViewAddressPropertiesNVX const* ptr() const { return reinterpret_cast(this); } + safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src); + safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& operator=(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src); + safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(); + ~safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(); + void initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceCooperativeMatrixFeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceCooperativeMatrixFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } }; -#ifdef VK_ENABLE_BETA_EXTENSIONS -struct safe_VkVideoEncodeH264CapabilitiesEXT { +struct safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR { VkStructureType sType; void* pNext{}; - VkVideoEncodeH264CapabilityFlagsEXT flags; - StdVideoH264LevelIdc maxLevelIdc; - uint32_t maxSliceCount; - uint32_t maxPPictureL0ReferenceCount; - uint32_t maxBPictureL0ReferenceCount; - uint32_t maxL1ReferenceCount; - uint32_t maxTemporalLayerCount; - VkBool32 expectDyadicTemporalLayerPattern; - int32_t minQp; - int32_t maxQp; - VkBool32 prefersGopRemainingFrames; - VkBool32 requiresGopRemainingFrames; - VkVideoEncodeH264StdFlagsEXT stdSyntaxFlags; + VkShaderStageFlags cooperativeMatrixSupportedStages; - safe_VkVideoEncodeH264CapabilitiesEXT(const VkVideoEncodeH264CapabilitiesEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoEncodeH264CapabilitiesEXT(const safe_VkVideoEncodeH264CapabilitiesEXT& copy_src); - safe_VkVideoEncodeH264CapabilitiesEXT& operator=(const safe_VkVideoEncodeH264CapabilitiesEXT& copy_src); - safe_VkVideoEncodeH264CapabilitiesEXT(); - ~safe_VkVideoEncodeH264CapabilitiesEXT(); - void initialize(const VkVideoEncodeH264CapabilitiesEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH264CapabilitiesEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH264CapabilitiesEXT* ptr() { return reinterpret_cast(this); } - VkVideoEncodeH264CapabilitiesEXT const* ptr() const { return reinterpret_cast(this); } + safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src); + safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& operator=( + const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src); + safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(); + ~safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(); + void initialize(const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceCooperativeMatrixPropertiesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceCooperativeMatrixPropertiesKHR const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkVideoEncodeH264QualityLevelPropertiesEXT { +struct safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR { VkStructureType sType; void* pNext{}; - VkVideoEncodeH264RateControlFlagsEXT preferredRateControlFlags; - uint32_t preferredGopFrameCount; - uint32_t preferredIdrPeriod; - uint32_t preferredConsecutiveBFrameCount; - uint32_t preferredTemporalLayerCount; - VkVideoEncodeH264QpEXT preferredConstantQp; - uint32_t preferredMaxL0ReferenceCount; - uint32_t preferredMaxL1ReferenceCount; - VkBool32 preferredStdEntropyCodingModeFlag; + VkBool32 videoMaintenance1; - safe_VkVideoEncodeH264QualityLevelPropertiesEXT(const VkVideoEncodeH264QualityLevelPropertiesEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeH264QualityLevelPropertiesEXT(const safe_VkVideoEncodeH264QualityLevelPropertiesEXT& copy_src); - safe_VkVideoEncodeH264QualityLevelPropertiesEXT& operator=(const safe_VkVideoEncodeH264QualityLevelPropertiesEXT& copy_src); - safe_VkVideoEncodeH264QualityLevelPropertiesEXT(); - ~safe_VkVideoEncodeH264QualityLevelPropertiesEXT(); - void initialize(const VkVideoEncodeH264QualityLevelPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH264QualityLevelPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH264QualityLevelPropertiesEXT* 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); } - VkVideoEncodeH264QualityLevelPropertiesEXT const* ptr() const { - return reinterpret_cast(this); + VkPhysicalDeviceVideoMaintenance1FeaturesKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeH264SessionCreateInfoEXT { +struct safe_VkVideoInlineQueryInfoKHR { VkStructureType sType; const void* pNext{}; - VkBool32 useMaxLevelIdc; - StdVideoH264LevelIdc maxLevelIdc; + VkQueryPool queryPool; + uint32_t firstQuery; + uint32_t queryCount; - safe_VkVideoEncodeH264SessionCreateInfoEXT(const VkVideoEncodeH264SessionCreateInfoEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeH264SessionCreateInfoEXT(const safe_VkVideoEncodeH264SessionCreateInfoEXT& copy_src); - safe_VkVideoEncodeH264SessionCreateInfoEXT& operator=(const safe_VkVideoEncodeH264SessionCreateInfoEXT& copy_src); - safe_VkVideoEncodeH264SessionCreateInfoEXT(); - ~safe_VkVideoEncodeH264SessionCreateInfoEXT(); - void initialize(const VkVideoEncodeH264SessionCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH264SessionCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH264SessionCreateInfoEXT* ptr() { return reinterpret_cast(this); } - VkVideoEncodeH264SessionCreateInfoEXT 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_VkVideoEncodeH264SessionParametersAddInfoEXT { +struct safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR { VkStructureType sType; - const void* pNext{}; - uint32_t stdSPSCount; - const StdVideoH264SequenceParameterSet* pStdSPSs{}; - uint32_t stdPPSCount; - const StdVideoH264PictureParameterSet* pStdPPSs{}; + void* pNext{}; + uint32_t maxVertexAttribDivisor; + VkBool32 supportsNonZeroFirstInstance; - safe_VkVideoEncodeH264SessionParametersAddInfoEXT(const VkVideoEncodeH264SessionParametersAddInfoEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeH264SessionParametersAddInfoEXT(const safe_VkVideoEncodeH264SessionParametersAddInfoEXT& copy_src); - safe_VkVideoEncodeH264SessionParametersAddInfoEXT& operator=(const safe_VkVideoEncodeH264SessionParametersAddInfoEXT& copy_src); - safe_VkVideoEncodeH264SessionParametersAddInfoEXT(); - ~safe_VkVideoEncodeH264SessionParametersAddInfoEXT(); - void initialize(const VkVideoEncodeH264SessionParametersAddInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH264SessionParametersAddInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH264SessionParametersAddInfoEXT* ptr() { - return reinterpret_cast(this); + 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); } - VkVideoEncodeH264SessionParametersAddInfoEXT const* ptr() const { - return reinterpret_cast(this); + VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeH264SessionParametersCreateInfoEXT { +struct safe_VkPipelineVertexInputDivisorStateCreateInfoKHR { VkStructureType sType; const void* pNext{}; - uint32_t maxStdSPSCount; - uint32_t maxStdPPSCount; - safe_VkVideoEncodeH264SessionParametersAddInfoEXT* pParametersAddInfo{}; + uint32_t vertexBindingDivisorCount; + const VkVertexInputBindingDivisorDescriptionKHR* pVertexBindingDivisors{}; - safe_VkVideoEncodeH264SessionParametersCreateInfoEXT(const VkVideoEncodeH264SessionParametersCreateInfoEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeH264SessionParametersCreateInfoEXT(const safe_VkVideoEncodeH264SessionParametersCreateInfoEXT& copy_src); - safe_VkVideoEncodeH264SessionParametersCreateInfoEXT& operator=( - const safe_VkVideoEncodeH264SessionParametersCreateInfoEXT& copy_src); - safe_VkVideoEncodeH264SessionParametersCreateInfoEXT(); - ~safe_VkVideoEncodeH264SessionParametersCreateInfoEXT(); - void initialize(const VkVideoEncodeH264SessionParametersCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH264SessionParametersCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH264SessionParametersCreateInfoEXT* ptr() { - return reinterpret_cast(this); + 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); } - VkVideoEncodeH264SessionParametersCreateInfoEXT const* ptr() const { - return reinterpret_cast(this); + VkPipelineVertexInputDivisorStateCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeH264SessionParametersGetInfoEXT { +struct safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR { VkStructureType sType; - const void* pNext{}; - VkBool32 writeStdSPS; - VkBool32 writeStdPPS; - uint32_t stdSPSId; - uint32_t stdPPSId; + void* pNext{}; + VkBool32 vertexAttributeInstanceRateDivisor; + VkBool32 vertexAttributeInstanceRateZeroDivisor; - safe_VkVideoEncodeH264SessionParametersGetInfoEXT(const VkVideoEncodeH264SessionParametersGetInfoEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeH264SessionParametersGetInfoEXT(const safe_VkVideoEncodeH264SessionParametersGetInfoEXT& copy_src); - safe_VkVideoEncodeH264SessionParametersGetInfoEXT& operator=(const safe_VkVideoEncodeH264SessionParametersGetInfoEXT& copy_src); - safe_VkVideoEncodeH264SessionParametersGetInfoEXT(); - ~safe_VkVideoEncodeH264SessionParametersGetInfoEXT(); - void initialize(const VkVideoEncodeH264SessionParametersGetInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH264SessionParametersGetInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH264SessionParametersGetInfoEXT* ptr() { - return reinterpret_cast(this); + 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); } - VkVideoEncodeH264SessionParametersGetInfoEXT const* ptr() const { - return reinterpret_cast(this); + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT { +struct safe_VkCalibratedTimestampInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkTimeDomainKHR timeDomain; + + safe_VkCalibratedTimestampInfoKHR(const VkCalibratedTimestampInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCalibratedTimestampInfoKHR(const safe_VkCalibratedTimestampInfoKHR& copy_src); + safe_VkCalibratedTimestampInfoKHR& operator=(const safe_VkCalibratedTimestampInfoKHR& copy_src); + safe_VkCalibratedTimestampInfoKHR(); + ~safe_VkCalibratedTimestampInfoKHR(); + void initialize(const VkCalibratedTimestampInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCalibratedTimestampInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkCalibratedTimestampInfoKHR* ptr() { return reinterpret_cast(this); } + VkCalibratedTimestampInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceMaintenance6FeaturesKHR { VkStructureType sType; void* pNext{}; - VkBool32 hasStdSPSOverrides; - VkBool32 hasStdPPSOverrides; + VkBool32 maintenance6; - safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT(const VkVideoEncodeH264SessionParametersFeedbackInfoEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT(const safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT& copy_src); - safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT& operator=( - const safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT& copy_src); - safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT(); - ~safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT(); - void initialize(const VkVideoEncodeH264SessionParametersFeedbackInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH264SessionParametersFeedbackInfoEXT* ptr() { - return reinterpret_cast(this); + 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); } - VkVideoEncodeH264SessionParametersFeedbackInfoEXT 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_VkVideoEncodeH264NaluSliceInfoEXT { +struct safe_VkBindMemoryStatusKHR { VkStructureType sType; const void* pNext{}; - int32_t constantQp; - const StdVideoEncodeH264SliceHeader* pStdSliceHeader{}; + VkResult* pResult{}; - safe_VkVideoEncodeH264NaluSliceInfoEXT(const VkVideoEncodeH264NaluSliceInfoEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoEncodeH264NaluSliceInfoEXT(const safe_VkVideoEncodeH264NaluSliceInfoEXT& copy_src); - safe_VkVideoEncodeH264NaluSliceInfoEXT& operator=(const safe_VkVideoEncodeH264NaluSliceInfoEXT& copy_src); - safe_VkVideoEncodeH264NaluSliceInfoEXT(); - ~safe_VkVideoEncodeH264NaluSliceInfoEXT(); - void initialize(const VkVideoEncodeH264NaluSliceInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH264NaluSliceInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH264NaluSliceInfoEXT* ptr() { return reinterpret_cast(this); } - VkVideoEncodeH264NaluSliceInfoEXT const* ptr() const { - return reinterpret_cast(this); - } + 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_VkVideoEncodeH264PictureInfoEXT { +struct safe_VkBindDescriptorSetsInfoKHR { VkStructureType sType; const void* pNext{}; - uint32_t naluSliceEntryCount; - safe_VkVideoEncodeH264NaluSliceInfoEXT* pNaluSliceEntries{}; - const StdVideoEncodeH264PictureInfo* pStdPictureInfo{}; - VkBool32 generatePrefixNalu; + VkShaderStageFlags stageFlags; + VkPipelineLayout layout; + uint32_t firstSet; + uint32_t descriptorSetCount; + VkDescriptorSet* pDescriptorSets{}; + uint32_t dynamicOffsetCount; + const uint32_t* pDynamicOffsets{}; - safe_VkVideoEncodeH264PictureInfoEXT(const VkVideoEncodeH264PictureInfoEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoEncodeH264PictureInfoEXT(const safe_VkVideoEncodeH264PictureInfoEXT& copy_src); - safe_VkVideoEncodeH264PictureInfoEXT& operator=(const safe_VkVideoEncodeH264PictureInfoEXT& copy_src); - safe_VkVideoEncodeH264PictureInfoEXT(); - ~safe_VkVideoEncodeH264PictureInfoEXT(); - void initialize(const VkVideoEncodeH264PictureInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH264PictureInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH264PictureInfoEXT* ptr() { return reinterpret_cast(this); } - VkVideoEncodeH264PictureInfoEXT const* ptr() const { return reinterpret_cast(this); } + 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_VkVideoEncodeH264DpbSlotInfoEXT { +struct safe_VkPushConstantsInfoKHR { VkStructureType sType; const void* pNext{}; - const StdVideoEncodeH264ReferenceInfo* pStdReferenceInfo{}; + VkPipelineLayout layout; + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; + const void* pValues{}; - safe_VkVideoEncodeH264DpbSlotInfoEXT(const VkVideoEncodeH264DpbSlotInfoEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoEncodeH264DpbSlotInfoEXT(const safe_VkVideoEncodeH264DpbSlotInfoEXT& copy_src); - safe_VkVideoEncodeH264DpbSlotInfoEXT& operator=(const safe_VkVideoEncodeH264DpbSlotInfoEXT& copy_src); - safe_VkVideoEncodeH264DpbSlotInfoEXT(); - ~safe_VkVideoEncodeH264DpbSlotInfoEXT(); - void initialize(const VkVideoEncodeH264DpbSlotInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH264DpbSlotInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH264DpbSlotInfoEXT* ptr() { return reinterpret_cast(this); } - VkVideoEncodeH264DpbSlotInfoEXT const* ptr() const { return reinterpret_cast(this); } + 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_VkVideoEncodeH264ProfileInfoEXT { +struct safe_VkPushDescriptorSetInfoKHR { VkStructureType sType; const void* pNext{}; - StdVideoH264ProfileIdc stdProfileIdc; + VkShaderStageFlags stageFlags; + VkPipelineLayout layout; + uint32_t set; + uint32_t descriptorWriteCount; + safe_VkWriteDescriptorSet* pDescriptorWrites{}; - safe_VkVideoEncodeH264ProfileInfoEXT(const VkVideoEncodeH264ProfileInfoEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoEncodeH264ProfileInfoEXT(const safe_VkVideoEncodeH264ProfileInfoEXT& copy_src); - safe_VkVideoEncodeH264ProfileInfoEXT& operator=(const safe_VkVideoEncodeH264ProfileInfoEXT& copy_src); - safe_VkVideoEncodeH264ProfileInfoEXT(); - ~safe_VkVideoEncodeH264ProfileInfoEXT(); - void initialize(const VkVideoEncodeH264ProfileInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH264ProfileInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH264ProfileInfoEXT* ptr() { return reinterpret_cast(this); } - VkVideoEncodeH264ProfileInfoEXT const* ptr() const { return reinterpret_cast(this); } + 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_VkVideoEncodeH264RateControlInfoEXT { +struct safe_VkPushDescriptorSetWithTemplateInfoKHR { VkStructureType sType; const void* pNext{}; - VkVideoEncodeH264RateControlFlagsEXT flags; - uint32_t gopFrameCount; - uint32_t idrPeriod; - uint32_t consecutiveBFrameCount; - uint32_t temporalLayerCount; + VkDescriptorUpdateTemplate descriptorUpdateTemplate; + VkPipelineLayout layout; + uint32_t set; + const void* pData{}; - safe_VkVideoEncodeH264RateControlInfoEXT(const VkVideoEncodeH264RateControlInfoEXT* in_struct, PNextCopyState* copy_state = {}, + 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{}; + VkShaderStageFlags stageFlags; + VkPipelineLayout layout; + uint32_t firstSet; + uint32_t setCount; + const uint32_t* pBufferIndices{}; + const VkDeviceSize* pOffsets{}; + + safe_VkSetDescriptorBufferOffsetsInfoEXT(const VkSetDescriptorBufferOffsetsInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeH264RateControlInfoEXT(const safe_VkVideoEncodeH264RateControlInfoEXT& copy_src); - safe_VkVideoEncodeH264RateControlInfoEXT& operator=(const safe_VkVideoEncodeH264RateControlInfoEXT& copy_src); - safe_VkVideoEncodeH264RateControlInfoEXT(); - ~safe_VkVideoEncodeH264RateControlInfoEXT(); - void initialize(const VkVideoEncodeH264RateControlInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH264RateControlInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH264RateControlInfoEXT* ptr() { return reinterpret_cast(this); } - VkVideoEncodeH264RateControlInfoEXT const* ptr() const { - return reinterpret_cast(this); + safe_VkSetDescriptorBufferOffsetsInfoEXT(const safe_VkSetDescriptorBufferOffsetsInfoEXT& copy_src); + safe_VkSetDescriptorBufferOffsetsInfoEXT& operator=(const safe_VkSetDescriptorBufferOffsetsInfoEXT& copy_src); + safe_VkSetDescriptorBufferOffsetsInfoEXT(); + ~safe_VkSetDescriptorBufferOffsetsInfoEXT(); + void initialize(const VkSetDescriptorBufferOffsetsInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSetDescriptorBufferOffsetsInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkSetDescriptorBufferOffsetsInfoEXT* ptr() { return reinterpret_cast(this); } + VkSetDescriptorBufferOffsetsInfoEXT const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeH264RateControlLayerInfoEXT { +struct safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT { VkStructureType sType; const void* pNext{}; - VkBool32 useMinQp; - VkVideoEncodeH264QpEXT minQp; - VkBool32 useMaxQp; - VkVideoEncodeH264QpEXT maxQp; - VkBool32 useMaxFrameSize; - VkVideoEncodeH264FrameSizeEXT maxFrameSize; + VkShaderStageFlags stageFlags; + VkPipelineLayout layout; + uint32_t set; - safe_VkVideoEncodeH264RateControlLayerInfoEXT(const VkVideoEncodeH264RateControlLayerInfoEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeH264RateControlLayerInfoEXT(const safe_VkVideoEncodeH264RateControlLayerInfoEXT& copy_src); - safe_VkVideoEncodeH264RateControlLayerInfoEXT& operator=(const safe_VkVideoEncodeH264RateControlLayerInfoEXT& copy_src); - safe_VkVideoEncodeH264RateControlLayerInfoEXT(); - ~safe_VkVideoEncodeH264RateControlLayerInfoEXT(); - void initialize(const VkVideoEncodeH264RateControlLayerInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH264RateControlLayerInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH264RateControlLayerInfoEXT* ptr() { return reinterpret_cast(this); } - VkVideoEncodeH264RateControlLayerInfoEXT const* ptr() const { - return reinterpret_cast(this); + safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT(const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT(const safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT& copy_src); + safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT& operator=( + const safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT& copy_src); + safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT(); + ~safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT(); + void initialize(const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkBindDescriptorBufferEmbeddedSamplersInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkBindDescriptorBufferEmbeddedSamplersInfoEXT const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeH264GopRemainingFrameInfoEXT { +struct safe_VkDebugReportCallbackCreateInfoEXT { VkStructureType sType; const void* pNext{}; - VkBool32 useGopRemainingFrames; - uint32_t gopRemainingI; - uint32_t gopRemainingP; - uint32_t gopRemainingB; + VkDebugReportFlagsEXT flags; + PFN_vkDebugReportCallbackEXT pfnCallback; + void* pUserData{}; - safe_VkVideoEncodeH264GopRemainingFrameInfoEXT(const VkVideoEncodeH264GopRemainingFrameInfoEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeH264GopRemainingFrameInfoEXT(const safe_VkVideoEncodeH264GopRemainingFrameInfoEXT& copy_src); - safe_VkVideoEncodeH264GopRemainingFrameInfoEXT& operator=(const safe_VkVideoEncodeH264GopRemainingFrameInfoEXT& copy_src); - safe_VkVideoEncodeH264GopRemainingFrameInfoEXT(); - ~safe_VkVideoEncodeH264GopRemainingFrameInfoEXT(); - void initialize(const VkVideoEncodeH264GopRemainingFrameInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH264GopRemainingFrameInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH264GopRemainingFrameInfoEXT* ptr() { return reinterpret_cast(this); } - VkVideoEncodeH264GopRemainingFrameInfoEXT const* ptr() const { - return reinterpret_cast(this); + safe_VkDebugReportCallbackCreateInfoEXT(const VkDebugReportCallbackCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDebugReportCallbackCreateInfoEXT(const safe_VkDebugReportCallbackCreateInfoEXT& copy_src); + safe_VkDebugReportCallbackCreateInfoEXT& operator=(const safe_VkDebugReportCallbackCreateInfoEXT& copy_src); + safe_VkDebugReportCallbackCreateInfoEXT(); + ~safe_VkDebugReportCallbackCreateInfoEXT(); + void initialize(const VkDebugReportCallbackCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDebugReportCallbackCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkDebugReportCallbackCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkDebugReportCallbackCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeH265CapabilitiesEXT { +struct safe_VkPipelineRasterizationStateRasterizationOrderAMD { VkStructureType sType; - void* pNext{}; - VkVideoEncodeH265CapabilityFlagsEXT flags; - StdVideoH265LevelIdc maxLevelIdc; - uint32_t maxSliceSegmentCount; - VkExtent2D maxTiles; - VkVideoEncodeH265CtbSizeFlagsEXT ctbSizes; - VkVideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes; - uint32_t maxPPictureL0ReferenceCount; - uint32_t maxBPictureL0ReferenceCount; - uint32_t maxL1ReferenceCount; - uint32_t maxSubLayerCount; - VkBool32 expectDyadicTemporalSubLayerPattern; - int32_t minQp; - int32_t maxQp; - VkBool32 prefersGopRemainingFrames; - VkBool32 requiresGopRemainingFrames; - VkVideoEncodeH265StdFlagsEXT stdSyntaxFlags; + const void* pNext{}; + VkRasterizationOrderAMD rasterizationOrder; - safe_VkVideoEncodeH265CapabilitiesEXT(const VkVideoEncodeH265CapabilitiesEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoEncodeH265CapabilitiesEXT(const safe_VkVideoEncodeH265CapabilitiesEXT& copy_src); - safe_VkVideoEncodeH265CapabilitiesEXT& operator=(const safe_VkVideoEncodeH265CapabilitiesEXT& copy_src); - safe_VkVideoEncodeH265CapabilitiesEXT(); - ~safe_VkVideoEncodeH265CapabilitiesEXT(); - void initialize(const VkVideoEncodeH265CapabilitiesEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH265CapabilitiesEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH265CapabilitiesEXT* ptr() { return reinterpret_cast(this); } - VkVideoEncodeH265CapabilitiesEXT const* ptr() const { return reinterpret_cast(this); } + safe_VkPipelineRasterizationStateRasterizationOrderAMD(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineRasterizationStateRasterizationOrderAMD(const safe_VkPipelineRasterizationStateRasterizationOrderAMD& copy_src); + safe_VkPipelineRasterizationStateRasterizationOrderAMD& operator=( + const safe_VkPipelineRasterizationStateRasterizationOrderAMD& copy_src); + safe_VkPipelineRasterizationStateRasterizationOrderAMD(); + ~safe_VkPipelineRasterizationStateRasterizationOrderAMD(); + void initialize(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineRasterizationStateRasterizationOrderAMD* copy_src, PNextCopyState* copy_state = {}); + VkPipelineRasterizationStateRasterizationOrderAMD* ptr() { + return reinterpret_cast(this); + } + VkPipelineRasterizationStateRasterizationOrderAMD const* ptr() const { + return reinterpret_cast(this); + } }; -struct safe_VkVideoEncodeH265SessionCreateInfoEXT { +struct safe_VkDebugMarkerObjectNameInfoEXT { VkStructureType sType; const void* pNext{}; - VkBool32 useMaxLevelIdc; - StdVideoH265LevelIdc maxLevelIdc; + VkDebugReportObjectTypeEXT objectType; + uint64_t object; + const char* pObjectName{}; + + safe_VkDebugMarkerObjectNameInfoEXT(const VkDebugMarkerObjectNameInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDebugMarkerObjectNameInfoEXT(const safe_VkDebugMarkerObjectNameInfoEXT& copy_src); + safe_VkDebugMarkerObjectNameInfoEXT& operator=(const safe_VkDebugMarkerObjectNameInfoEXT& copy_src); + safe_VkDebugMarkerObjectNameInfoEXT(); + ~safe_VkDebugMarkerObjectNameInfoEXT(); + void initialize(const VkDebugMarkerObjectNameInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDebugMarkerObjectNameInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkDebugMarkerObjectNameInfoEXT* ptr() { return reinterpret_cast(this); } + VkDebugMarkerObjectNameInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDebugMarkerObjectTagInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkDebugReportObjectTypeEXT objectType; + uint64_t object; + uint64_t tagName; + size_t tagSize; + const void* pTag{}; + + safe_VkDebugMarkerObjectTagInfoEXT(const VkDebugMarkerObjectTagInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDebugMarkerObjectTagInfoEXT(const safe_VkDebugMarkerObjectTagInfoEXT& copy_src); + safe_VkDebugMarkerObjectTagInfoEXT& operator=(const safe_VkDebugMarkerObjectTagInfoEXT& copy_src); + safe_VkDebugMarkerObjectTagInfoEXT(); + ~safe_VkDebugMarkerObjectTagInfoEXT(); + void initialize(const VkDebugMarkerObjectTagInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDebugMarkerObjectTagInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkDebugMarkerObjectTagInfoEXT* ptr() { return reinterpret_cast(this); } + VkDebugMarkerObjectTagInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDebugMarkerMarkerInfoEXT { + VkStructureType sType; + const void* pNext{}; + const char* pMarkerName{}; + float color[4]; - safe_VkVideoEncodeH265SessionCreateInfoEXT(const VkVideoEncodeH265SessionCreateInfoEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeH265SessionCreateInfoEXT(const safe_VkVideoEncodeH265SessionCreateInfoEXT& copy_src); - safe_VkVideoEncodeH265SessionCreateInfoEXT& operator=(const safe_VkVideoEncodeH265SessionCreateInfoEXT& copy_src); - safe_VkVideoEncodeH265SessionCreateInfoEXT(); - ~safe_VkVideoEncodeH265SessionCreateInfoEXT(); - void initialize(const VkVideoEncodeH265SessionCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH265SessionCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH265SessionCreateInfoEXT* ptr() { return reinterpret_cast(this); } - VkVideoEncodeH265SessionCreateInfoEXT const* ptr() const { - return reinterpret_cast(this); - } + safe_VkDebugMarkerMarkerInfoEXT(const VkDebugMarkerMarkerInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDebugMarkerMarkerInfoEXT(const safe_VkDebugMarkerMarkerInfoEXT& copy_src); + safe_VkDebugMarkerMarkerInfoEXT& operator=(const safe_VkDebugMarkerMarkerInfoEXT& copy_src); + safe_VkDebugMarkerMarkerInfoEXT(); + ~safe_VkDebugMarkerMarkerInfoEXT(); + void initialize(const VkDebugMarkerMarkerInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDebugMarkerMarkerInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkDebugMarkerMarkerInfoEXT* ptr() { return reinterpret_cast(this); } + VkDebugMarkerMarkerInfoEXT const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeH265QualityLevelPropertiesEXT { +struct safe_VkDedicatedAllocationImageCreateInfoNV { VkStructureType sType; - void* pNext{}; - VkVideoEncodeH265RateControlFlagsEXT preferredRateControlFlags; - uint32_t preferredGopFrameCount; - uint32_t preferredIdrPeriod; - uint32_t preferredConsecutiveBFrameCount; - uint32_t preferredSubLayerCount; - VkVideoEncodeH265QpEXT preferredConstantQp; - uint32_t preferredMaxL0ReferenceCount; - uint32_t preferredMaxL1ReferenceCount; + const void* pNext{}; + VkBool32 dedicatedAllocation; - safe_VkVideoEncodeH265QualityLevelPropertiesEXT(const VkVideoEncodeH265QualityLevelPropertiesEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeH265QualityLevelPropertiesEXT(const safe_VkVideoEncodeH265QualityLevelPropertiesEXT& copy_src); - safe_VkVideoEncodeH265QualityLevelPropertiesEXT& operator=(const safe_VkVideoEncodeH265QualityLevelPropertiesEXT& copy_src); - safe_VkVideoEncodeH265QualityLevelPropertiesEXT(); - ~safe_VkVideoEncodeH265QualityLevelPropertiesEXT(); - void initialize(const VkVideoEncodeH265QualityLevelPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH265QualityLevelPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH265QualityLevelPropertiesEXT* ptr() { - return reinterpret_cast(this); - } - VkVideoEncodeH265QualityLevelPropertiesEXT const* ptr() const { - return reinterpret_cast(this); + safe_VkDedicatedAllocationImageCreateInfoNV(const VkDedicatedAllocationImageCreateInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDedicatedAllocationImageCreateInfoNV(const safe_VkDedicatedAllocationImageCreateInfoNV& copy_src); + safe_VkDedicatedAllocationImageCreateInfoNV& operator=(const safe_VkDedicatedAllocationImageCreateInfoNV& copy_src); + safe_VkDedicatedAllocationImageCreateInfoNV(); + ~safe_VkDedicatedAllocationImageCreateInfoNV(); + void initialize(const VkDedicatedAllocationImageCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDedicatedAllocationImageCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkDedicatedAllocationImageCreateInfoNV* ptr() { return reinterpret_cast(this); } + VkDedicatedAllocationImageCreateInfoNV const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeH265SessionParametersAddInfoEXT { +struct safe_VkDedicatedAllocationBufferCreateInfoNV { VkStructureType sType; const void* pNext{}; - uint32_t stdVPSCount; - const StdVideoH265VideoParameterSet* pStdVPSs{}; - uint32_t stdSPSCount; - const StdVideoH265SequenceParameterSet* pStdSPSs{}; - uint32_t stdPPSCount; - const StdVideoH265PictureParameterSet* pStdPPSs{}; + VkBool32 dedicatedAllocation; - safe_VkVideoEncodeH265SessionParametersAddInfoEXT(const VkVideoEncodeH265SessionParametersAddInfoEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeH265SessionParametersAddInfoEXT(const safe_VkVideoEncodeH265SessionParametersAddInfoEXT& copy_src); - safe_VkVideoEncodeH265SessionParametersAddInfoEXT& operator=(const safe_VkVideoEncodeH265SessionParametersAddInfoEXT& copy_src); - safe_VkVideoEncodeH265SessionParametersAddInfoEXT(); - ~safe_VkVideoEncodeH265SessionParametersAddInfoEXT(); - void initialize(const VkVideoEncodeH265SessionParametersAddInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH265SessionParametersAddInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH265SessionParametersAddInfoEXT* ptr() { - return reinterpret_cast(this); - } - VkVideoEncodeH265SessionParametersAddInfoEXT const* ptr() const { - return reinterpret_cast(this); + safe_VkDedicatedAllocationBufferCreateInfoNV(const VkDedicatedAllocationBufferCreateInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDedicatedAllocationBufferCreateInfoNV(const safe_VkDedicatedAllocationBufferCreateInfoNV& copy_src); + safe_VkDedicatedAllocationBufferCreateInfoNV& operator=(const safe_VkDedicatedAllocationBufferCreateInfoNV& copy_src); + safe_VkDedicatedAllocationBufferCreateInfoNV(); + ~safe_VkDedicatedAllocationBufferCreateInfoNV(); + void initialize(const VkDedicatedAllocationBufferCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDedicatedAllocationBufferCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkDedicatedAllocationBufferCreateInfoNV* ptr() { return reinterpret_cast(this); } + VkDedicatedAllocationBufferCreateInfoNV const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeH265SessionParametersCreateInfoEXT { +struct safe_VkDedicatedAllocationMemoryAllocateInfoNV { VkStructureType sType; const void* pNext{}; - uint32_t maxStdVPSCount; - uint32_t maxStdSPSCount; - uint32_t maxStdPPSCount; - safe_VkVideoEncodeH265SessionParametersAddInfoEXT* pParametersAddInfo{}; + VkImage image; + VkBuffer buffer; - safe_VkVideoEncodeH265SessionParametersCreateInfoEXT(const VkVideoEncodeH265SessionParametersCreateInfoEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeH265SessionParametersCreateInfoEXT(const safe_VkVideoEncodeH265SessionParametersCreateInfoEXT& copy_src); - safe_VkVideoEncodeH265SessionParametersCreateInfoEXT& operator=( - const safe_VkVideoEncodeH265SessionParametersCreateInfoEXT& copy_src); - safe_VkVideoEncodeH265SessionParametersCreateInfoEXT(); - ~safe_VkVideoEncodeH265SessionParametersCreateInfoEXT(); - void initialize(const VkVideoEncodeH265SessionParametersCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH265SessionParametersCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH265SessionParametersCreateInfoEXT* ptr() { - return reinterpret_cast(this); - } - VkVideoEncodeH265SessionParametersCreateInfoEXT const* ptr() const { - return reinterpret_cast(this); + safe_VkDedicatedAllocationMemoryAllocateInfoNV(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDedicatedAllocationMemoryAllocateInfoNV(const safe_VkDedicatedAllocationMemoryAllocateInfoNV& copy_src); + safe_VkDedicatedAllocationMemoryAllocateInfoNV& operator=(const safe_VkDedicatedAllocationMemoryAllocateInfoNV& copy_src); + safe_VkDedicatedAllocationMemoryAllocateInfoNV(); + ~safe_VkDedicatedAllocationMemoryAllocateInfoNV(); + void initialize(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDedicatedAllocationMemoryAllocateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkDedicatedAllocationMemoryAllocateInfoNV* ptr() { return reinterpret_cast(this); } + VkDedicatedAllocationMemoryAllocateInfoNV const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeH265SessionParametersGetInfoEXT { +struct safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT { VkStructureType sType; - const void* pNext{}; - VkBool32 writeStdVPS; - VkBool32 writeStdSPS; - VkBool32 writeStdPPS; - uint32_t stdVPSId; - uint32_t stdSPSId; - uint32_t stdPPSId; + void* pNext{}; + VkBool32 transformFeedback; + VkBool32 geometryStreams; - safe_VkVideoEncodeH265SessionParametersGetInfoEXT(const VkVideoEncodeH265SessionParametersGetInfoEXT* in_struct, + safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeH265SessionParametersGetInfoEXT(const safe_VkVideoEncodeH265SessionParametersGetInfoEXT& copy_src); - safe_VkVideoEncodeH265SessionParametersGetInfoEXT& operator=(const safe_VkVideoEncodeH265SessionParametersGetInfoEXT& copy_src); - safe_VkVideoEncodeH265SessionParametersGetInfoEXT(); - ~safe_VkVideoEncodeH265SessionParametersGetInfoEXT(); - void initialize(const VkVideoEncodeH265SessionParametersGetInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH265SessionParametersGetInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH265SessionParametersGetInfoEXT* ptr() { - return reinterpret_cast(this); + safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& copy_src); + safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& operator=(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& copy_src); + safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(); + ~safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(); + void initialize(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceTransformFeedbackFeaturesEXT* ptr() { + return reinterpret_cast(this); } - VkVideoEncodeH265SessionParametersGetInfoEXT const* ptr() const { - return reinterpret_cast(this); + VkPhysicalDeviceTransformFeedbackFeaturesEXT const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT { +struct safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT { VkStructureType sType; void* pNext{}; - VkBool32 hasStdVPSOverrides; - VkBool32 hasStdSPSOverrides; - VkBool32 hasStdPPSOverrides; + uint32_t maxTransformFeedbackStreams; + uint32_t maxTransformFeedbackBuffers; + VkDeviceSize maxTransformFeedbackBufferSize; + uint32_t maxTransformFeedbackStreamDataSize; + uint32_t maxTransformFeedbackBufferDataSize; + uint32_t maxTransformFeedbackBufferDataStride; + VkBool32 transformFeedbackQueries; + VkBool32 transformFeedbackStreamsLinesTriangles; + VkBool32 transformFeedbackRasterizationStreamSelect; + VkBool32 transformFeedbackDraw; - safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT(const VkVideoEncodeH265SessionParametersFeedbackInfoEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT(const safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT& copy_src); - safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT& operator=( - const safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT& copy_src); - safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT(); - ~safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT(); - void initialize(const VkVideoEncodeH265SessionParametersFeedbackInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH265SessionParametersFeedbackInfoEXT* ptr() { - return reinterpret_cast(this); + safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& copy_src); + safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& operator=( + const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& copy_src); + safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(); + ~safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(); + void initialize(const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceTransformFeedbackPropertiesEXT* ptr() { + return reinterpret_cast(this); } - VkVideoEncodeH265SessionParametersFeedbackInfoEXT const* ptr() const { - return reinterpret_cast(this); + VkPhysicalDeviceTransformFeedbackPropertiesEXT const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT { +struct safe_VkPipelineRasterizationStateStreamCreateInfoEXT { VkStructureType sType; const void* pNext{}; - int32_t constantQp; - const StdVideoEncodeH265SliceSegmentHeader* pStdSliceSegmentHeader{}; + VkPipelineRasterizationStateStreamCreateFlagsEXT flags; + uint32_t rasterizationStream; - safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT(const VkVideoEncodeH265NaluSliceSegmentInfoEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT(const safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT& copy_src); - safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT& operator=(const safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT& copy_src); - safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT(); - ~safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT(); - void initialize(const VkVideoEncodeH265NaluSliceSegmentInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH265NaluSliceSegmentInfoEXT* ptr() { return reinterpret_cast(this); } - VkVideoEncodeH265NaluSliceSegmentInfoEXT const* ptr() const { - return reinterpret_cast(this); + safe_VkPipelineRasterizationStateStreamCreateInfoEXT(const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineRasterizationStateStreamCreateInfoEXT(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& copy_src); + safe_VkPipelineRasterizationStateStreamCreateInfoEXT& operator=( + const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& copy_src); + safe_VkPipelineRasterizationStateStreamCreateInfoEXT(); + ~safe_VkPipelineRasterizationStateStreamCreateInfoEXT(); + void initialize(const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkPipelineRasterizationStateStreamCreateInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkPipelineRasterizationStateStreamCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeH265PictureInfoEXT { - VkStructureType sType; - const void* pNext{}; - uint32_t naluSliceSegmentEntryCount; - safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT* pNaluSliceSegmentEntries{}; - const StdVideoEncodeH265PictureInfo* pStdPictureInfo{}; - - safe_VkVideoEncodeH265PictureInfoEXT(const VkVideoEncodeH265PictureInfoEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoEncodeH265PictureInfoEXT(const safe_VkVideoEncodeH265PictureInfoEXT& copy_src); - safe_VkVideoEncodeH265PictureInfoEXT& operator=(const safe_VkVideoEncodeH265PictureInfoEXT& copy_src); - safe_VkVideoEncodeH265PictureInfoEXT(); - ~safe_VkVideoEncodeH265PictureInfoEXT(); - void initialize(const VkVideoEncodeH265PictureInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH265PictureInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH265PictureInfoEXT* ptr() { return reinterpret_cast(this); } - VkVideoEncodeH265PictureInfoEXT const* ptr() const { return reinterpret_cast(this); } -}; -struct safe_VkVideoEncodeH265DpbSlotInfoEXT { +struct safe_VkCuModuleCreateInfoNVX { VkStructureType sType; const void* pNext{}; - const StdVideoEncodeH265ReferenceInfo* pStdReferenceInfo{}; + size_t dataSize; + const void* pData{}; - safe_VkVideoEncodeH265DpbSlotInfoEXT(const VkVideoEncodeH265DpbSlotInfoEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoEncodeH265DpbSlotInfoEXT(const safe_VkVideoEncodeH265DpbSlotInfoEXT& copy_src); - safe_VkVideoEncodeH265DpbSlotInfoEXT& operator=(const safe_VkVideoEncodeH265DpbSlotInfoEXT& copy_src); - safe_VkVideoEncodeH265DpbSlotInfoEXT(); - ~safe_VkVideoEncodeH265DpbSlotInfoEXT(); - void initialize(const VkVideoEncodeH265DpbSlotInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH265DpbSlotInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH265DpbSlotInfoEXT* ptr() { return reinterpret_cast(this); } - VkVideoEncodeH265DpbSlotInfoEXT const* ptr() const { return reinterpret_cast(this); } + safe_VkCuModuleCreateInfoNVX(const VkCuModuleCreateInfoNVX* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkCuModuleCreateInfoNVX(const safe_VkCuModuleCreateInfoNVX& copy_src); + safe_VkCuModuleCreateInfoNVX& operator=(const safe_VkCuModuleCreateInfoNVX& copy_src); + safe_VkCuModuleCreateInfoNVX(); + ~safe_VkCuModuleCreateInfoNVX(); + void initialize(const VkCuModuleCreateInfoNVX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCuModuleCreateInfoNVX* copy_src, PNextCopyState* copy_state = {}); + VkCuModuleCreateInfoNVX* ptr() { return reinterpret_cast(this); } + VkCuModuleCreateInfoNVX const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeH265ProfileInfoEXT { +struct safe_VkCuFunctionCreateInfoNVX { VkStructureType sType; const void* pNext{}; - StdVideoH265ProfileIdc stdProfileIdc; + VkCuModuleNVX module; + const char* pName{}; - safe_VkVideoEncodeH265ProfileInfoEXT(const VkVideoEncodeH265ProfileInfoEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoEncodeH265ProfileInfoEXT(const safe_VkVideoEncodeH265ProfileInfoEXT& copy_src); - safe_VkVideoEncodeH265ProfileInfoEXT& operator=(const safe_VkVideoEncodeH265ProfileInfoEXT& copy_src); - safe_VkVideoEncodeH265ProfileInfoEXT(); - ~safe_VkVideoEncodeH265ProfileInfoEXT(); - void initialize(const VkVideoEncodeH265ProfileInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH265ProfileInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH265ProfileInfoEXT* ptr() { return reinterpret_cast(this); } - VkVideoEncodeH265ProfileInfoEXT const* ptr() const { return reinterpret_cast(this); } + safe_VkCuFunctionCreateInfoNVX(const VkCuFunctionCreateInfoNVX* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCuFunctionCreateInfoNVX(const safe_VkCuFunctionCreateInfoNVX& copy_src); + safe_VkCuFunctionCreateInfoNVX& operator=(const safe_VkCuFunctionCreateInfoNVX& copy_src); + safe_VkCuFunctionCreateInfoNVX(); + ~safe_VkCuFunctionCreateInfoNVX(); + void initialize(const VkCuFunctionCreateInfoNVX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCuFunctionCreateInfoNVX* copy_src, PNextCopyState* copy_state = {}); + VkCuFunctionCreateInfoNVX* ptr() { return reinterpret_cast(this); } + VkCuFunctionCreateInfoNVX const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeH265RateControlInfoEXT { +struct safe_VkCuLaunchInfoNVX { VkStructureType sType; const void* pNext{}; - VkVideoEncodeH265RateControlFlagsEXT flags; - uint32_t gopFrameCount; - uint32_t idrPeriod; - uint32_t consecutiveBFrameCount; - uint32_t subLayerCount; + VkCuFunctionNVX function; + uint32_t gridDimX; + uint32_t gridDimY; + uint32_t gridDimZ; + uint32_t blockDimX; + uint32_t blockDimY; + uint32_t blockDimZ; + uint32_t sharedMemBytes; + size_t paramCount; + const void* const* pParams{}; + size_t extraCount; + const void* const* pExtras{}; - safe_VkVideoEncodeH265RateControlInfoEXT(const VkVideoEncodeH265RateControlInfoEXT* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkVideoEncodeH265RateControlInfoEXT(const safe_VkVideoEncodeH265RateControlInfoEXT& copy_src); - safe_VkVideoEncodeH265RateControlInfoEXT& operator=(const safe_VkVideoEncodeH265RateControlInfoEXT& copy_src); - safe_VkVideoEncodeH265RateControlInfoEXT(); - ~safe_VkVideoEncodeH265RateControlInfoEXT(); - void initialize(const VkVideoEncodeH265RateControlInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH265RateControlInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH265RateControlInfoEXT* ptr() { return reinterpret_cast(this); } - VkVideoEncodeH265RateControlInfoEXT const* ptr() const { - return reinterpret_cast(this); - } + safe_VkCuLaunchInfoNVX(const VkCuLaunchInfoNVX* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkCuLaunchInfoNVX(const safe_VkCuLaunchInfoNVX& copy_src); + safe_VkCuLaunchInfoNVX& operator=(const safe_VkCuLaunchInfoNVX& copy_src); + safe_VkCuLaunchInfoNVX(); + ~safe_VkCuLaunchInfoNVX(); + void initialize(const VkCuLaunchInfoNVX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCuLaunchInfoNVX* copy_src, PNextCopyState* copy_state = {}); + VkCuLaunchInfoNVX* ptr() { return reinterpret_cast(this); } + VkCuLaunchInfoNVX const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeH265RateControlLayerInfoEXT { +struct safe_VkImageViewHandleInfoNVX { VkStructureType sType; const void* pNext{}; - VkBool32 useMinQp; - VkVideoEncodeH265QpEXT minQp; - VkBool32 useMaxQp; - VkVideoEncodeH265QpEXT maxQp; - VkBool32 useMaxFrameSize; - VkVideoEncodeH265FrameSizeEXT maxFrameSize; + VkImageView imageView; + VkDescriptorType descriptorType; + VkSampler sampler; - safe_VkVideoEncodeH265RateControlLayerInfoEXT(const VkVideoEncodeH265RateControlLayerInfoEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeH265RateControlLayerInfoEXT(const safe_VkVideoEncodeH265RateControlLayerInfoEXT& copy_src); - safe_VkVideoEncodeH265RateControlLayerInfoEXT& operator=(const safe_VkVideoEncodeH265RateControlLayerInfoEXT& copy_src); - safe_VkVideoEncodeH265RateControlLayerInfoEXT(); - ~safe_VkVideoEncodeH265RateControlLayerInfoEXT(); - void initialize(const VkVideoEncodeH265RateControlLayerInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH265RateControlLayerInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH265RateControlLayerInfoEXT* ptr() { return reinterpret_cast(this); } - VkVideoEncodeH265RateControlLayerInfoEXT const* ptr() const { - return reinterpret_cast(this); - } + safe_VkImageViewHandleInfoNVX(const VkImageViewHandleInfoNVX* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImageViewHandleInfoNVX(const safe_VkImageViewHandleInfoNVX& copy_src); + safe_VkImageViewHandleInfoNVX& operator=(const safe_VkImageViewHandleInfoNVX& copy_src); + safe_VkImageViewHandleInfoNVX(); + ~safe_VkImageViewHandleInfoNVX(); + void initialize(const VkImageViewHandleInfoNVX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageViewHandleInfoNVX* copy_src, PNextCopyState* copy_state = {}); + VkImageViewHandleInfoNVX* ptr() { return reinterpret_cast(this); } + VkImageViewHandleInfoNVX const* ptr() const { return reinterpret_cast(this); } }; -struct safe_VkVideoEncodeH265GopRemainingFrameInfoEXT { +struct safe_VkImageViewAddressPropertiesNVX { VkStructureType sType; - const void* pNext{}; - VkBool32 useGopRemainingFrames; - uint32_t gopRemainingI; - uint32_t gopRemainingP; - uint32_t gopRemainingB; + void* pNext{}; + VkDeviceAddress deviceAddress; + VkDeviceSize size; - safe_VkVideoEncodeH265GopRemainingFrameInfoEXT(const VkVideoEncodeH265GopRemainingFrameInfoEXT* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkVideoEncodeH265GopRemainingFrameInfoEXT(const safe_VkVideoEncodeH265GopRemainingFrameInfoEXT& copy_src); - safe_VkVideoEncodeH265GopRemainingFrameInfoEXT& operator=(const safe_VkVideoEncodeH265GopRemainingFrameInfoEXT& copy_src); - safe_VkVideoEncodeH265GopRemainingFrameInfoEXT(); - ~safe_VkVideoEncodeH265GopRemainingFrameInfoEXT(); - void initialize(const VkVideoEncodeH265GopRemainingFrameInfoEXT* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkVideoEncodeH265GopRemainingFrameInfoEXT* copy_src, PNextCopyState* copy_state = {}); - VkVideoEncodeH265GopRemainingFrameInfoEXT* ptr() { return reinterpret_cast(this); } - VkVideoEncodeH265GopRemainingFrameInfoEXT const* ptr() const { - return reinterpret_cast(this); - } + safe_VkImageViewAddressPropertiesNVX(const VkImageViewAddressPropertiesNVX* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImageViewAddressPropertiesNVX(const safe_VkImageViewAddressPropertiesNVX& copy_src); + safe_VkImageViewAddressPropertiesNVX& operator=(const safe_VkImageViewAddressPropertiesNVX& copy_src); + safe_VkImageViewAddressPropertiesNVX(); + ~safe_VkImageViewAddressPropertiesNVX(); + void initialize(const VkImageViewAddressPropertiesNVX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageViewAddressPropertiesNVX* copy_src, PNextCopyState* copy_state = {}); + VkImageViewAddressPropertiesNVX* ptr() { return reinterpret_cast(this); } + VkImageViewAddressPropertiesNVX const* ptr() const { return reinterpret_cast(this); } }; -#endif // VK_ENABLE_BETA_EXTENSIONS struct safe_VkTextureLODGatherFormatPropertiesAMD { VkStructureType sType; void* pNext{}; @@ -17113,6 +17328,28 @@ struct safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM { return reinterpret_cast(this); } }; +struct safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 perStageDescriptorSet; + VkBool32 dynamicPipelineLayout; + + safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV(const VkPhysicalDevicePerStageDescriptorSetFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV(const safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV& copy_src); + safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV& operator=( + const safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV& copy_src); + safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV(); + ~safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV(); + void initialize(const VkPhysicalDevicePerStageDescriptorSetFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePerStageDescriptorSetFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDevicePerStageDescriptorSetFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; struct safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM { VkStructureType sType; void* pNext{}; diff --git a/layers/vulkan/generated/vk_safe_struct_ext.cpp b/layers/vulkan/generated/vk_safe_struct_ext.cpp index 2bdea67abed..1c98cbbb4f5 100644 --- a/layers/vulkan/generated/vk_safe_struct_ext.cpp +++ b/layers/vulkan/generated/vk_safe_struct_ext.cpp @@ -88,6 +88,200 @@ void safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::initialize( pNext = SafePnextCopy(copy_src->pNext); } +safe_VkSetDescriptorBufferOffsetsInfoEXT::safe_VkSetDescriptorBufferOffsetsInfoEXT( + const VkSetDescriptorBufferOffsetsInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + stageFlags(in_struct->stageFlags), + layout(in_struct->layout), + firstSet(in_struct->firstSet), + setCount(in_struct->setCount), + pBufferIndices(nullptr), + pOffsets(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pBufferIndices) { + pBufferIndices = new uint32_t[in_struct->setCount]; + memcpy((void*)pBufferIndices, (void*)in_struct->pBufferIndices, sizeof(uint32_t) * in_struct->setCount); + } + + if (in_struct->pOffsets) { + pOffsets = new VkDeviceSize[in_struct->setCount]; + memcpy((void*)pOffsets, (void*)in_struct->pOffsets, sizeof(VkDeviceSize) * in_struct->setCount); + } +} + +safe_VkSetDescriptorBufferOffsetsInfoEXT::safe_VkSetDescriptorBufferOffsetsInfoEXT() + : sType(VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT), + pNext(nullptr), + stageFlags(), + layout(), + firstSet(), + setCount(), + pBufferIndices(nullptr), + pOffsets(nullptr) {} + +safe_VkSetDescriptorBufferOffsetsInfoEXT::safe_VkSetDescriptorBufferOffsetsInfoEXT( + const safe_VkSetDescriptorBufferOffsetsInfoEXT& copy_src) { + sType = copy_src.sType; + stageFlags = copy_src.stageFlags; + layout = copy_src.layout; + firstSet = copy_src.firstSet; + setCount = copy_src.setCount; + pBufferIndices = nullptr; + pOffsets = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pBufferIndices) { + pBufferIndices = new uint32_t[copy_src.setCount]; + memcpy((void*)pBufferIndices, (void*)copy_src.pBufferIndices, sizeof(uint32_t) * copy_src.setCount); + } + + if (copy_src.pOffsets) { + pOffsets = new VkDeviceSize[copy_src.setCount]; + memcpy((void*)pOffsets, (void*)copy_src.pOffsets, sizeof(VkDeviceSize) * copy_src.setCount); + } +} + +safe_VkSetDescriptorBufferOffsetsInfoEXT& safe_VkSetDescriptorBufferOffsetsInfoEXT::operator=( + const safe_VkSetDescriptorBufferOffsetsInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pBufferIndices) delete[] pBufferIndices; + if (pOffsets) delete[] pOffsets; + FreePnextChain(pNext); + + sType = copy_src.sType; + stageFlags = copy_src.stageFlags; + layout = copy_src.layout; + firstSet = copy_src.firstSet; + setCount = copy_src.setCount; + pBufferIndices = nullptr; + pOffsets = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pBufferIndices) { + pBufferIndices = new uint32_t[copy_src.setCount]; + memcpy((void*)pBufferIndices, (void*)copy_src.pBufferIndices, sizeof(uint32_t) * copy_src.setCount); + } + + if (copy_src.pOffsets) { + pOffsets = new VkDeviceSize[copy_src.setCount]; + memcpy((void*)pOffsets, (void*)copy_src.pOffsets, sizeof(VkDeviceSize) * copy_src.setCount); + } + + return *this; +} + +safe_VkSetDescriptorBufferOffsetsInfoEXT::~safe_VkSetDescriptorBufferOffsetsInfoEXT() { + if (pBufferIndices) delete[] pBufferIndices; + if (pOffsets) delete[] pOffsets; + FreePnextChain(pNext); +} + +void safe_VkSetDescriptorBufferOffsetsInfoEXT::initialize(const VkSetDescriptorBufferOffsetsInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pBufferIndices) delete[] pBufferIndices; + if (pOffsets) delete[] pOffsets; + FreePnextChain(pNext); + sType = in_struct->sType; + stageFlags = in_struct->stageFlags; + layout = in_struct->layout; + firstSet = in_struct->firstSet; + setCount = in_struct->setCount; + pBufferIndices = nullptr; + pOffsets = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pBufferIndices) { + pBufferIndices = new uint32_t[in_struct->setCount]; + memcpy((void*)pBufferIndices, (void*)in_struct->pBufferIndices, sizeof(uint32_t) * in_struct->setCount); + } + + if (in_struct->pOffsets) { + pOffsets = new VkDeviceSize[in_struct->setCount]; + memcpy((void*)pOffsets, (void*)in_struct->pOffsets, sizeof(VkDeviceSize) * in_struct->setCount); + } +} + +void safe_VkSetDescriptorBufferOffsetsInfoEXT::initialize(const safe_VkSetDescriptorBufferOffsetsInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stageFlags = copy_src->stageFlags; + layout = copy_src->layout; + firstSet = copy_src->firstSet; + setCount = copy_src->setCount; + pBufferIndices = nullptr; + pOffsets = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pBufferIndices) { + pBufferIndices = new uint32_t[copy_src->setCount]; + memcpy((void*)pBufferIndices, (void*)copy_src->pBufferIndices, sizeof(uint32_t) * copy_src->setCount); + } + + if (copy_src->pOffsets) { + pOffsets = new VkDeviceSize[copy_src->setCount]; + memcpy((void*)pOffsets, (void*)copy_src->pOffsets, sizeof(VkDeviceSize) * copy_src->setCount); + } +} + +safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT::safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT( + const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* 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) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT::safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT() + : sType(VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT), pNext(nullptr), stageFlags(), layout(), set() {} + +safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT::safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT( + const safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT& copy_src) { + sType = copy_src.sType; + stageFlags = copy_src.stageFlags; + layout = copy_src.layout; + set = copy_src.set; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT& safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT::operator=( + const safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + stageFlags = copy_src.stageFlags; + layout = copy_src.layout; + set = copy_src.set; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT::~safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT() { FreePnextChain(pNext); } + +void safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT::initialize(const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* 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; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT::initialize( + const safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stageFlags = copy_src->stageFlags; + layout = copy_src->layout; + set = copy_src->set; + pNext = SafePnextCopy(copy_src->pNext); +} + safe_VkDebugReportCallbackCreateInfoEXT::safe_VkDebugReportCallbackCreateInfoEXT( const VkDebugReportCallbackCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), flags(in_struct->flags), pfnCallback(in_struct->pfnCallback), pUserData(in_struct->pUserData) { @@ -570,2394 +764,6 @@ void safe_VkPipelineRasterizationStateStreamCreateInfoEXT::initialize( rasterizationStream = copy_src->rasterizationStream; pNext = SafePnextCopy(copy_src->pNext); } -#ifdef VK_ENABLE_BETA_EXTENSIONS - -safe_VkVideoEncodeH264CapabilitiesEXT::safe_VkVideoEncodeH264CapabilitiesEXT(const VkVideoEncodeH264CapabilitiesEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), - flags(in_struct->flags), - maxLevelIdc(in_struct->maxLevelIdc), - maxSliceCount(in_struct->maxSliceCount), - maxPPictureL0ReferenceCount(in_struct->maxPPictureL0ReferenceCount), - maxBPictureL0ReferenceCount(in_struct->maxBPictureL0ReferenceCount), - maxL1ReferenceCount(in_struct->maxL1ReferenceCount), - maxTemporalLayerCount(in_struct->maxTemporalLayerCount), - expectDyadicTemporalLayerPattern(in_struct->expectDyadicTemporalLayerPattern), - minQp(in_struct->minQp), - maxQp(in_struct->maxQp), - prefersGopRemainingFrames(in_struct->prefersGopRemainingFrames), - requiresGopRemainingFrames(in_struct->requiresGopRemainingFrames), - stdSyntaxFlags(in_struct->stdSyntaxFlags) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeH264CapabilitiesEXT::safe_VkVideoEncodeH264CapabilitiesEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT), - pNext(nullptr), - flags(), - maxLevelIdc(), - maxSliceCount(), - maxPPictureL0ReferenceCount(), - maxBPictureL0ReferenceCount(), - maxL1ReferenceCount(), - maxTemporalLayerCount(), - expectDyadicTemporalLayerPattern(), - minQp(), - maxQp(), - prefersGopRemainingFrames(), - requiresGopRemainingFrames(), - stdSyntaxFlags() {} - -safe_VkVideoEncodeH264CapabilitiesEXT::safe_VkVideoEncodeH264CapabilitiesEXT( - const safe_VkVideoEncodeH264CapabilitiesEXT& copy_src) { - sType = copy_src.sType; - flags = copy_src.flags; - maxLevelIdc = copy_src.maxLevelIdc; - maxSliceCount = copy_src.maxSliceCount; - maxPPictureL0ReferenceCount = copy_src.maxPPictureL0ReferenceCount; - maxBPictureL0ReferenceCount = copy_src.maxBPictureL0ReferenceCount; - maxL1ReferenceCount = copy_src.maxL1ReferenceCount; - maxTemporalLayerCount = copy_src.maxTemporalLayerCount; - expectDyadicTemporalLayerPattern = copy_src.expectDyadicTemporalLayerPattern; - minQp = copy_src.minQp; - maxQp = copy_src.maxQp; - prefersGopRemainingFrames = copy_src.prefersGopRemainingFrames; - requiresGopRemainingFrames = copy_src.requiresGopRemainingFrames; - stdSyntaxFlags = copy_src.stdSyntaxFlags; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeH264CapabilitiesEXT& safe_VkVideoEncodeH264CapabilitiesEXT::operator=( - const safe_VkVideoEncodeH264CapabilitiesEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - flags = copy_src.flags; - maxLevelIdc = copy_src.maxLevelIdc; - maxSliceCount = copy_src.maxSliceCount; - maxPPictureL0ReferenceCount = copy_src.maxPPictureL0ReferenceCount; - maxBPictureL0ReferenceCount = copy_src.maxBPictureL0ReferenceCount; - maxL1ReferenceCount = copy_src.maxL1ReferenceCount; - maxTemporalLayerCount = copy_src.maxTemporalLayerCount; - expectDyadicTemporalLayerPattern = copy_src.expectDyadicTemporalLayerPattern; - minQp = copy_src.minQp; - maxQp = copy_src.maxQp; - prefersGopRemainingFrames = copy_src.prefersGopRemainingFrames; - requiresGopRemainingFrames = copy_src.requiresGopRemainingFrames; - stdSyntaxFlags = copy_src.stdSyntaxFlags; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeH264CapabilitiesEXT::~safe_VkVideoEncodeH264CapabilitiesEXT() { FreePnextChain(pNext); } - -void safe_VkVideoEncodeH264CapabilitiesEXT::initialize(const VkVideoEncodeH264CapabilitiesEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - flags = in_struct->flags; - maxLevelIdc = in_struct->maxLevelIdc; - maxSliceCount = in_struct->maxSliceCount; - maxPPictureL0ReferenceCount = in_struct->maxPPictureL0ReferenceCount; - maxBPictureL0ReferenceCount = in_struct->maxBPictureL0ReferenceCount; - maxL1ReferenceCount = in_struct->maxL1ReferenceCount; - maxTemporalLayerCount = in_struct->maxTemporalLayerCount; - expectDyadicTemporalLayerPattern = in_struct->expectDyadicTemporalLayerPattern; - minQp = in_struct->minQp; - maxQp = in_struct->maxQp; - prefersGopRemainingFrames = in_struct->prefersGopRemainingFrames; - requiresGopRemainingFrames = in_struct->requiresGopRemainingFrames; - stdSyntaxFlags = in_struct->stdSyntaxFlags; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeH264CapabilitiesEXT::initialize(const safe_VkVideoEncodeH264CapabilitiesEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - flags = copy_src->flags; - maxLevelIdc = copy_src->maxLevelIdc; - maxSliceCount = copy_src->maxSliceCount; - maxPPictureL0ReferenceCount = copy_src->maxPPictureL0ReferenceCount; - maxBPictureL0ReferenceCount = copy_src->maxBPictureL0ReferenceCount; - maxL1ReferenceCount = copy_src->maxL1ReferenceCount; - maxTemporalLayerCount = copy_src->maxTemporalLayerCount; - expectDyadicTemporalLayerPattern = copy_src->expectDyadicTemporalLayerPattern; - minQp = copy_src->minQp; - maxQp = copy_src->maxQp; - prefersGopRemainingFrames = copy_src->prefersGopRemainingFrames; - requiresGopRemainingFrames = copy_src->requiresGopRemainingFrames; - stdSyntaxFlags = copy_src->stdSyntaxFlags; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeH264QualityLevelPropertiesEXT::safe_VkVideoEncodeH264QualityLevelPropertiesEXT( - const VkVideoEncodeH264QualityLevelPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - preferredRateControlFlags(in_struct->preferredRateControlFlags), - preferredGopFrameCount(in_struct->preferredGopFrameCount), - preferredIdrPeriod(in_struct->preferredIdrPeriod), - preferredConsecutiveBFrameCount(in_struct->preferredConsecutiveBFrameCount), - preferredTemporalLayerCount(in_struct->preferredTemporalLayerCount), - preferredConstantQp(in_struct->preferredConstantQp), - preferredMaxL0ReferenceCount(in_struct->preferredMaxL0ReferenceCount), - preferredMaxL1ReferenceCount(in_struct->preferredMaxL1ReferenceCount), - preferredStdEntropyCodingModeFlag(in_struct->preferredStdEntropyCodingModeFlag) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeH264QualityLevelPropertiesEXT::safe_VkVideoEncodeH264QualityLevelPropertiesEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT), - pNext(nullptr), - preferredRateControlFlags(), - preferredGopFrameCount(), - preferredIdrPeriod(), - preferredConsecutiveBFrameCount(), - preferredTemporalLayerCount(), - preferredConstantQp(), - preferredMaxL0ReferenceCount(), - preferredMaxL1ReferenceCount(), - preferredStdEntropyCodingModeFlag() {} - -safe_VkVideoEncodeH264QualityLevelPropertiesEXT::safe_VkVideoEncodeH264QualityLevelPropertiesEXT( - const safe_VkVideoEncodeH264QualityLevelPropertiesEXT& copy_src) { - sType = copy_src.sType; - preferredRateControlFlags = copy_src.preferredRateControlFlags; - preferredGopFrameCount = copy_src.preferredGopFrameCount; - preferredIdrPeriod = copy_src.preferredIdrPeriod; - preferredConsecutiveBFrameCount = copy_src.preferredConsecutiveBFrameCount; - preferredTemporalLayerCount = copy_src.preferredTemporalLayerCount; - preferredConstantQp = copy_src.preferredConstantQp; - preferredMaxL0ReferenceCount = copy_src.preferredMaxL0ReferenceCount; - preferredMaxL1ReferenceCount = copy_src.preferredMaxL1ReferenceCount; - preferredStdEntropyCodingModeFlag = copy_src.preferredStdEntropyCodingModeFlag; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeH264QualityLevelPropertiesEXT& safe_VkVideoEncodeH264QualityLevelPropertiesEXT::operator=( - const safe_VkVideoEncodeH264QualityLevelPropertiesEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - preferredRateControlFlags = copy_src.preferredRateControlFlags; - preferredGopFrameCount = copy_src.preferredGopFrameCount; - preferredIdrPeriod = copy_src.preferredIdrPeriod; - preferredConsecutiveBFrameCount = copy_src.preferredConsecutiveBFrameCount; - preferredTemporalLayerCount = copy_src.preferredTemporalLayerCount; - preferredConstantQp = copy_src.preferredConstantQp; - preferredMaxL0ReferenceCount = copy_src.preferredMaxL0ReferenceCount; - preferredMaxL1ReferenceCount = copy_src.preferredMaxL1ReferenceCount; - preferredStdEntropyCodingModeFlag = copy_src.preferredStdEntropyCodingModeFlag; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeH264QualityLevelPropertiesEXT::~safe_VkVideoEncodeH264QualityLevelPropertiesEXT() { FreePnextChain(pNext); } - -void safe_VkVideoEncodeH264QualityLevelPropertiesEXT::initialize(const VkVideoEncodeH264QualityLevelPropertiesEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - preferredRateControlFlags = in_struct->preferredRateControlFlags; - preferredGopFrameCount = in_struct->preferredGopFrameCount; - preferredIdrPeriod = in_struct->preferredIdrPeriod; - preferredConsecutiveBFrameCount = in_struct->preferredConsecutiveBFrameCount; - preferredTemporalLayerCount = in_struct->preferredTemporalLayerCount; - preferredConstantQp = in_struct->preferredConstantQp; - preferredMaxL0ReferenceCount = in_struct->preferredMaxL0ReferenceCount; - preferredMaxL1ReferenceCount = in_struct->preferredMaxL1ReferenceCount; - preferredStdEntropyCodingModeFlag = in_struct->preferredStdEntropyCodingModeFlag; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeH264QualityLevelPropertiesEXT::initialize(const safe_VkVideoEncodeH264QualityLevelPropertiesEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - preferredRateControlFlags = copy_src->preferredRateControlFlags; - preferredGopFrameCount = copy_src->preferredGopFrameCount; - preferredIdrPeriod = copy_src->preferredIdrPeriod; - preferredConsecutiveBFrameCount = copy_src->preferredConsecutiveBFrameCount; - preferredTemporalLayerCount = copy_src->preferredTemporalLayerCount; - preferredConstantQp = copy_src->preferredConstantQp; - preferredMaxL0ReferenceCount = copy_src->preferredMaxL0ReferenceCount; - preferredMaxL1ReferenceCount = copy_src->preferredMaxL1ReferenceCount; - preferredStdEntropyCodingModeFlag = copy_src->preferredStdEntropyCodingModeFlag; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeH264SessionCreateInfoEXT::safe_VkVideoEncodeH264SessionCreateInfoEXT( - const VkVideoEncodeH264SessionCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), useMaxLevelIdc(in_struct->useMaxLevelIdc), maxLevelIdc(in_struct->maxLevelIdc) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeH264SessionCreateInfoEXT::safe_VkVideoEncodeH264SessionCreateInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT), pNext(nullptr), useMaxLevelIdc(), maxLevelIdc() {} - -safe_VkVideoEncodeH264SessionCreateInfoEXT::safe_VkVideoEncodeH264SessionCreateInfoEXT( - const safe_VkVideoEncodeH264SessionCreateInfoEXT& copy_src) { - sType = copy_src.sType; - useMaxLevelIdc = copy_src.useMaxLevelIdc; - maxLevelIdc = copy_src.maxLevelIdc; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeH264SessionCreateInfoEXT& safe_VkVideoEncodeH264SessionCreateInfoEXT::operator=( - const safe_VkVideoEncodeH264SessionCreateInfoEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - useMaxLevelIdc = copy_src.useMaxLevelIdc; - maxLevelIdc = copy_src.maxLevelIdc; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeH264SessionCreateInfoEXT::~safe_VkVideoEncodeH264SessionCreateInfoEXT() { FreePnextChain(pNext); } - -void safe_VkVideoEncodeH264SessionCreateInfoEXT::initialize(const VkVideoEncodeH264SessionCreateInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - useMaxLevelIdc = in_struct->useMaxLevelIdc; - maxLevelIdc = in_struct->maxLevelIdc; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeH264SessionCreateInfoEXT::initialize(const safe_VkVideoEncodeH264SessionCreateInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - useMaxLevelIdc = copy_src->useMaxLevelIdc; - maxLevelIdc = copy_src->maxLevelIdc; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeH264SessionParametersAddInfoEXT::safe_VkVideoEncodeH264SessionParametersAddInfoEXT( - const VkVideoEncodeH264SessionParametersAddInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - stdSPSCount(in_struct->stdSPSCount), - pStdSPSs(nullptr), - stdPPSCount(in_struct->stdPPSCount), - pStdPPSs(nullptr) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } - if (in_struct->pStdSPSs) { - pStdSPSs = new StdVideoH264SequenceParameterSet[in_struct->stdSPSCount]; - memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * in_struct->stdSPSCount); - } - - if (in_struct->pStdPPSs) { - pStdPPSs = new StdVideoH264PictureParameterSet[in_struct->stdPPSCount]; - memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * in_struct->stdPPSCount); - } -} - -safe_VkVideoEncodeH264SessionParametersAddInfoEXT::safe_VkVideoEncodeH264SessionParametersAddInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT), - pNext(nullptr), - stdSPSCount(), - pStdSPSs(nullptr), - stdPPSCount(), - pStdPPSs(nullptr) {} - -safe_VkVideoEncodeH264SessionParametersAddInfoEXT::safe_VkVideoEncodeH264SessionParametersAddInfoEXT( - const safe_VkVideoEncodeH264SessionParametersAddInfoEXT& copy_src) { - sType = copy_src.sType; - stdSPSCount = copy_src.stdSPSCount; - pStdSPSs = nullptr; - stdPPSCount = copy_src.stdPPSCount; - pStdPPSs = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdSPSs) { - pStdSPSs = new StdVideoH264SequenceParameterSet[copy_src.stdSPSCount]; - memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * copy_src.stdSPSCount); - } - - if (copy_src.pStdPPSs) { - pStdPPSs = new StdVideoH264PictureParameterSet[copy_src.stdPPSCount]; - memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * copy_src.stdPPSCount); - } -} - -safe_VkVideoEncodeH264SessionParametersAddInfoEXT& safe_VkVideoEncodeH264SessionParametersAddInfoEXT::operator=( - const safe_VkVideoEncodeH264SessionParametersAddInfoEXT& copy_src) { - if (©_src == this) return *this; - - if (pStdSPSs) delete[] pStdSPSs; - if (pStdPPSs) delete[] pStdPPSs; - FreePnextChain(pNext); - - sType = copy_src.sType; - stdSPSCount = copy_src.stdSPSCount; - pStdSPSs = nullptr; - stdPPSCount = copy_src.stdPPSCount; - pStdPPSs = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdSPSs) { - pStdSPSs = new StdVideoH264SequenceParameterSet[copy_src.stdSPSCount]; - memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * copy_src.stdSPSCount); - } - - if (copy_src.pStdPPSs) { - pStdPPSs = new StdVideoH264PictureParameterSet[copy_src.stdPPSCount]; - memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * copy_src.stdPPSCount); - } - - return *this; -} - -safe_VkVideoEncodeH264SessionParametersAddInfoEXT::~safe_VkVideoEncodeH264SessionParametersAddInfoEXT() { - if (pStdSPSs) delete[] pStdSPSs; - if (pStdPPSs) delete[] pStdPPSs; - FreePnextChain(pNext); -} - -void safe_VkVideoEncodeH264SessionParametersAddInfoEXT::initialize(const VkVideoEncodeH264SessionParametersAddInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pStdSPSs) delete[] pStdSPSs; - if (pStdPPSs) delete[] pStdPPSs; - FreePnextChain(pNext); - sType = in_struct->sType; - stdSPSCount = in_struct->stdSPSCount; - pStdSPSs = nullptr; - stdPPSCount = in_struct->stdPPSCount; - pStdPPSs = nullptr; - pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pStdSPSs) { - pStdSPSs = new StdVideoH264SequenceParameterSet[in_struct->stdSPSCount]; - memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * in_struct->stdSPSCount); - } - - if (in_struct->pStdPPSs) { - pStdPPSs = new StdVideoH264PictureParameterSet[in_struct->stdPPSCount]; - memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * in_struct->stdPPSCount); - } -} - -void safe_VkVideoEncodeH264SessionParametersAddInfoEXT::initialize( - const safe_VkVideoEncodeH264SessionParametersAddInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - stdSPSCount = copy_src->stdSPSCount; - pStdSPSs = nullptr; - stdPPSCount = copy_src->stdPPSCount; - pStdPPSs = nullptr; - pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pStdSPSs) { - pStdSPSs = new StdVideoH264SequenceParameterSet[copy_src->stdSPSCount]; - memcpy((void*)pStdSPSs, (void*)copy_src->pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * copy_src->stdSPSCount); - } - - if (copy_src->pStdPPSs) { - pStdPPSs = new StdVideoH264PictureParameterSet[copy_src->stdPPSCount]; - memcpy((void*)pStdPPSs, (void*)copy_src->pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * copy_src->stdPPSCount); - } -} - -safe_VkVideoEncodeH264SessionParametersCreateInfoEXT::safe_VkVideoEncodeH264SessionParametersCreateInfoEXT( - const VkVideoEncodeH264SessionParametersCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - maxStdSPSCount(in_struct->maxStdSPSCount), - maxStdPPSCount(in_struct->maxStdPPSCount), - pParametersAddInfo(nullptr) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } - if (in_struct->pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoEXT(in_struct->pParametersAddInfo); -} - -safe_VkVideoEncodeH264SessionParametersCreateInfoEXT::safe_VkVideoEncodeH264SessionParametersCreateInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT), - pNext(nullptr), - maxStdSPSCount(), - maxStdPPSCount(), - pParametersAddInfo(nullptr) {} - -safe_VkVideoEncodeH264SessionParametersCreateInfoEXT::safe_VkVideoEncodeH264SessionParametersCreateInfoEXT( - const safe_VkVideoEncodeH264SessionParametersCreateInfoEXT& copy_src) { - sType = copy_src.sType; - maxStdSPSCount = copy_src.maxStdSPSCount; - maxStdPPSCount = copy_src.maxStdPPSCount; - pParametersAddInfo = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoEXT(*copy_src.pParametersAddInfo); -} - -safe_VkVideoEncodeH264SessionParametersCreateInfoEXT& safe_VkVideoEncodeH264SessionParametersCreateInfoEXT::operator=( - const safe_VkVideoEncodeH264SessionParametersCreateInfoEXT& copy_src) { - if (©_src == this) return *this; - - if (pParametersAddInfo) delete pParametersAddInfo; - FreePnextChain(pNext); - - sType = copy_src.sType; - maxStdSPSCount = copy_src.maxStdSPSCount; - maxStdPPSCount = copy_src.maxStdPPSCount; - pParametersAddInfo = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoEXT(*copy_src.pParametersAddInfo); - - return *this; -} - -safe_VkVideoEncodeH264SessionParametersCreateInfoEXT::~safe_VkVideoEncodeH264SessionParametersCreateInfoEXT() { - if (pParametersAddInfo) delete pParametersAddInfo; - FreePnextChain(pNext); -} - -void safe_VkVideoEncodeH264SessionParametersCreateInfoEXT::initialize( - const VkVideoEncodeH264SessionParametersCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - if (pParametersAddInfo) delete pParametersAddInfo; - FreePnextChain(pNext); - sType = in_struct->sType; - maxStdSPSCount = in_struct->maxStdSPSCount; - maxStdPPSCount = in_struct->maxStdPPSCount; - pParametersAddInfo = nullptr; - pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (in_struct->pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoEXT(in_struct->pParametersAddInfo); -} - -void safe_VkVideoEncodeH264SessionParametersCreateInfoEXT::initialize( - const safe_VkVideoEncodeH264SessionParametersCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - maxStdSPSCount = copy_src->maxStdSPSCount; - maxStdPPSCount = copy_src->maxStdPPSCount; - pParametersAddInfo = nullptr; - pNext = SafePnextCopy(copy_src->pNext); - if (copy_src->pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoEXT(*copy_src->pParametersAddInfo); -} - -safe_VkVideoEncodeH264SessionParametersGetInfoEXT::safe_VkVideoEncodeH264SessionParametersGetInfoEXT( - const VkVideoEncodeH264SessionParametersGetInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - writeStdSPS(in_struct->writeStdSPS), - writeStdPPS(in_struct->writeStdPPS), - stdSPSId(in_struct->stdSPSId), - stdPPSId(in_struct->stdPPSId) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeH264SessionParametersGetInfoEXT::safe_VkVideoEncodeH264SessionParametersGetInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT), - pNext(nullptr), - writeStdSPS(), - writeStdPPS(), - stdSPSId(), - stdPPSId() {} - -safe_VkVideoEncodeH264SessionParametersGetInfoEXT::safe_VkVideoEncodeH264SessionParametersGetInfoEXT( - const safe_VkVideoEncodeH264SessionParametersGetInfoEXT& copy_src) { - sType = copy_src.sType; - writeStdSPS = copy_src.writeStdSPS; - writeStdPPS = copy_src.writeStdPPS; - stdSPSId = copy_src.stdSPSId; - stdPPSId = copy_src.stdPPSId; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeH264SessionParametersGetInfoEXT& safe_VkVideoEncodeH264SessionParametersGetInfoEXT::operator=( - const safe_VkVideoEncodeH264SessionParametersGetInfoEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - writeStdSPS = copy_src.writeStdSPS; - writeStdPPS = copy_src.writeStdPPS; - stdSPSId = copy_src.stdSPSId; - stdPPSId = copy_src.stdPPSId; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeH264SessionParametersGetInfoEXT::~safe_VkVideoEncodeH264SessionParametersGetInfoEXT() { FreePnextChain(pNext); } - -void safe_VkVideoEncodeH264SessionParametersGetInfoEXT::initialize(const VkVideoEncodeH264SessionParametersGetInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - writeStdSPS = in_struct->writeStdSPS; - writeStdPPS = in_struct->writeStdPPS; - stdSPSId = in_struct->stdSPSId; - stdPPSId = in_struct->stdPPSId; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeH264SessionParametersGetInfoEXT::initialize( - const safe_VkVideoEncodeH264SessionParametersGetInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - writeStdSPS = copy_src->writeStdSPS; - writeStdPPS = copy_src->writeStdPPS; - stdSPSId = copy_src->stdSPSId; - stdPPSId = copy_src->stdPPSId; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT::safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT( - const VkVideoEncodeH264SessionParametersFeedbackInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), - hasStdSPSOverrides(in_struct->hasStdSPSOverrides), - hasStdPPSOverrides(in_struct->hasStdPPSOverrides) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT::safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT), - pNext(nullptr), - hasStdSPSOverrides(), - hasStdPPSOverrides() {} - -safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT::safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT( - const safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT& copy_src) { - sType = copy_src.sType; - hasStdSPSOverrides = copy_src.hasStdSPSOverrides; - hasStdPPSOverrides = copy_src.hasStdPPSOverrides; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT& safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT::operator=( - const safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - hasStdSPSOverrides = copy_src.hasStdSPSOverrides; - hasStdPPSOverrides = copy_src.hasStdPPSOverrides; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT::~safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT() { - FreePnextChain(pNext); -} - -void safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT::initialize( - const VkVideoEncodeH264SessionParametersFeedbackInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - hasStdSPSOverrides = in_struct->hasStdSPSOverrides; - hasStdPPSOverrides = in_struct->hasStdPPSOverrides; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT::initialize( - const safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - hasStdSPSOverrides = copy_src->hasStdSPSOverrides; - hasStdPPSOverrides = copy_src->hasStdPPSOverrides; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeH264NaluSliceInfoEXT::safe_VkVideoEncodeH264NaluSliceInfoEXT(const VkVideoEncodeH264NaluSliceInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), constantQp(in_struct->constantQp), pStdSliceHeader(nullptr) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } - if (in_struct->pStdSliceHeader) { - pStdSliceHeader = new StdVideoEncodeH264SliceHeader(*in_struct->pStdSliceHeader); - } -} - -safe_VkVideoEncodeH264NaluSliceInfoEXT::safe_VkVideoEncodeH264NaluSliceInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT), pNext(nullptr), constantQp(), pStdSliceHeader(nullptr) {} - -safe_VkVideoEncodeH264NaluSliceInfoEXT::safe_VkVideoEncodeH264NaluSliceInfoEXT( - const safe_VkVideoEncodeH264NaluSliceInfoEXT& copy_src) { - sType = copy_src.sType; - constantQp = copy_src.constantQp; - pStdSliceHeader = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdSliceHeader) { - pStdSliceHeader = new StdVideoEncodeH264SliceHeader(*copy_src.pStdSliceHeader); - } -} - -safe_VkVideoEncodeH264NaluSliceInfoEXT& safe_VkVideoEncodeH264NaluSliceInfoEXT::operator=( - const safe_VkVideoEncodeH264NaluSliceInfoEXT& copy_src) { - if (©_src == this) return *this; - - if (pStdSliceHeader) delete pStdSliceHeader; - FreePnextChain(pNext); - - sType = copy_src.sType; - constantQp = copy_src.constantQp; - pStdSliceHeader = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdSliceHeader) { - pStdSliceHeader = new StdVideoEncodeH264SliceHeader(*copy_src.pStdSliceHeader); - } - - return *this; -} - -safe_VkVideoEncodeH264NaluSliceInfoEXT::~safe_VkVideoEncodeH264NaluSliceInfoEXT() { - if (pStdSliceHeader) delete pStdSliceHeader; - FreePnextChain(pNext); -} - -void safe_VkVideoEncodeH264NaluSliceInfoEXT::initialize(const VkVideoEncodeH264NaluSliceInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pStdSliceHeader) delete pStdSliceHeader; - FreePnextChain(pNext); - sType = in_struct->sType; - constantQp = in_struct->constantQp; - pStdSliceHeader = nullptr; - pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pStdSliceHeader) { - pStdSliceHeader = new StdVideoEncodeH264SliceHeader(*in_struct->pStdSliceHeader); - } -} - -void safe_VkVideoEncodeH264NaluSliceInfoEXT::initialize(const safe_VkVideoEncodeH264NaluSliceInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - constantQp = copy_src->constantQp; - pStdSliceHeader = nullptr; - pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pStdSliceHeader) { - pStdSliceHeader = new StdVideoEncodeH264SliceHeader(*copy_src->pStdSliceHeader); - } -} - -safe_VkVideoEncodeH264PictureInfoEXT::safe_VkVideoEncodeH264PictureInfoEXT(const VkVideoEncodeH264PictureInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), - naluSliceEntryCount(in_struct->naluSliceEntryCount), - pNaluSliceEntries(nullptr), - pStdPictureInfo(nullptr), - generatePrefixNalu(in_struct->generatePrefixNalu) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } - if (naluSliceEntryCount && in_struct->pNaluSliceEntries) { - pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceInfoEXT[naluSliceEntryCount]; - for (uint32_t i = 0; i < naluSliceEntryCount; ++i) { - pNaluSliceEntries[i].initialize(&in_struct->pNaluSliceEntries[i]); - } - } - - if (in_struct->pStdPictureInfo) { - pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*in_struct->pStdPictureInfo); - } -} - -safe_VkVideoEncodeH264PictureInfoEXT::safe_VkVideoEncodeH264PictureInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT), - pNext(nullptr), - naluSliceEntryCount(), - pNaluSliceEntries(nullptr), - pStdPictureInfo(nullptr), - generatePrefixNalu() {} - -safe_VkVideoEncodeH264PictureInfoEXT::safe_VkVideoEncodeH264PictureInfoEXT(const safe_VkVideoEncodeH264PictureInfoEXT& copy_src) { - sType = copy_src.sType; - naluSliceEntryCount = copy_src.naluSliceEntryCount; - pNaluSliceEntries = nullptr; - pStdPictureInfo = nullptr; - generatePrefixNalu = copy_src.generatePrefixNalu; - pNext = SafePnextCopy(copy_src.pNext); - if (naluSliceEntryCount && copy_src.pNaluSliceEntries) { - pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceInfoEXT[naluSliceEntryCount]; - for (uint32_t i = 0; i < naluSliceEntryCount; ++i) { - pNaluSliceEntries[i].initialize(©_src.pNaluSliceEntries[i]); - } - } - - if (copy_src.pStdPictureInfo) { - pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*copy_src.pStdPictureInfo); - } -} - -safe_VkVideoEncodeH264PictureInfoEXT& safe_VkVideoEncodeH264PictureInfoEXT::operator=( - const safe_VkVideoEncodeH264PictureInfoEXT& copy_src) { - if (©_src == this) return *this; - - if (pNaluSliceEntries) delete[] pNaluSliceEntries; - if (pStdPictureInfo) delete pStdPictureInfo; - FreePnextChain(pNext); - - sType = copy_src.sType; - naluSliceEntryCount = copy_src.naluSliceEntryCount; - pNaluSliceEntries = nullptr; - pStdPictureInfo = nullptr; - generatePrefixNalu = copy_src.generatePrefixNalu; - pNext = SafePnextCopy(copy_src.pNext); - if (naluSliceEntryCount && copy_src.pNaluSliceEntries) { - pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceInfoEXT[naluSliceEntryCount]; - for (uint32_t i = 0; i < naluSliceEntryCount; ++i) { - pNaluSliceEntries[i].initialize(©_src.pNaluSliceEntries[i]); - } - } - - if (copy_src.pStdPictureInfo) { - pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*copy_src.pStdPictureInfo); - } - - return *this; -} - -safe_VkVideoEncodeH264PictureInfoEXT::~safe_VkVideoEncodeH264PictureInfoEXT() { - if (pNaluSliceEntries) delete[] pNaluSliceEntries; - if (pStdPictureInfo) delete pStdPictureInfo; - FreePnextChain(pNext); -} - -void safe_VkVideoEncodeH264PictureInfoEXT::initialize(const VkVideoEncodeH264PictureInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pNaluSliceEntries) delete[] pNaluSliceEntries; - if (pStdPictureInfo) delete pStdPictureInfo; - FreePnextChain(pNext); - sType = in_struct->sType; - naluSliceEntryCount = in_struct->naluSliceEntryCount; - pNaluSliceEntries = nullptr; - pStdPictureInfo = nullptr; - generatePrefixNalu = in_struct->generatePrefixNalu; - pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (naluSliceEntryCount && in_struct->pNaluSliceEntries) { - pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceInfoEXT[naluSliceEntryCount]; - for (uint32_t i = 0; i < naluSliceEntryCount; ++i) { - pNaluSliceEntries[i].initialize(&in_struct->pNaluSliceEntries[i]); - } - } - - if (in_struct->pStdPictureInfo) { - pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*in_struct->pStdPictureInfo); - } -} - -void safe_VkVideoEncodeH264PictureInfoEXT::initialize(const safe_VkVideoEncodeH264PictureInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - naluSliceEntryCount = copy_src->naluSliceEntryCount; - pNaluSliceEntries = nullptr; - pStdPictureInfo = nullptr; - generatePrefixNalu = copy_src->generatePrefixNalu; - pNext = SafePnextCopy(copy_src->pNext); - if (naluSliceEntryCount && copy_src->pNaluSliceEntries) { - pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceInfoEXT[naluSliceEntryCount]; - for (uint32_t i = 0; i < naluSliceEntryCount; ++i) { - pNaluSliceEntries[i].initialize(©_src->pNaluSliceEntries[i]); - } - } - - if (copy_src->pStdPictureInfo) { - pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*copy_src->pStdPictureInfo); - } -} - -safe_VkVideoEncodeH264DpbSlotInfoEXT::safe_VkVideoEncodeH264DpbSlotInfoEXT(const VkVideoEncodeH264DpbSlotInfoEXT* 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 StdVideoEncodeH264ReferenceInfo(*in_struct->pStdReferenceInfo); - } -} - -safe_VkVideoEncodeH264DpbSlotInfoEXT::safe_VkVideoEncodeH264DpbSlotInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT), pNext(nullptr), pStdReferenceInfo(nullptr) {} - -safe_VkVideoEncodeH264DpbSlotInfoEXT::safe_VkVideoEncodeH264DpbSlotInfoEXT(const safe_VkVideoEncodeH264DpbSlotInfoEXT& copy_src) { - sType = copy_src.sType; - pStdReferenceInfo = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoEncodeH264ReferenceInfo(*copy_src.pStdReferenceInfo); - } -} - -safe_VkVideoEncodeH264DpbSlotInfoEXT& safe_VkVideoEncodeH264DpbSlotInfoEXT::operator=( - const safe_VkVideoEncodeH264DpbSlotInfoEXT& 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 StdVideoEncodeH264ReferenceInfo(*copy_src.pStdReferenceInfo); - } - - return *this; -} - -safe_VkVideoEncodeH264DpbSlotInfoEXT::~safe_VkVideoEncodeH264DpbSlotInfoEXT() { - if (pStdReferenceInfo) delete pStdReferenceInfo; - FreePnextChain(pNext); -} - -void safe_VkVideoEncodeH264DpbSlotInfoEXT::initialize(const VkVideoEncodeH264DpbSlotInfoEXT* 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 StdVideoEncodeH264ReferenceInfo(*in_struct->pStdReferenceInfo); - } -} - -void safe_VkVideoEncodeH264DpbSlotInfoEXT::initialize(const safe_VkVideoEncodeH264DpbSlotInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - pStdReferenceInfo = nullptr; - pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoEncodeH264ReferenceInfo(*copy_src->pStdReferenceInfo); - } -} - -safe_VkVideoEncodeH264ProfileInfoEXT::safe_VkVideoEncodeH264ProfileInfoEXT(const VkVideoEncodeH264ProfileInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), stdProfileIdc(in_struct->stdProfileIdc) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeH264ProfileInfoEXT::safe_VkVideoEncodeH264ProfileInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT), pNext(nullptr), stdProfileIdc() {} - -safe_VkVideoEncodeH264ProfileInfoEXT::safe_VkVideoEncodeH264ProfileInfoEXT(const safe_VkVideoEncodeH264ProfileInfoEXT& copy_src) { - sType = copy_src.sType; - stdProfileIdc = copy_src.stdProfileIdc; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeH264ProfileInfoEXT& safe_VkVideoEncodeH264ProfileInfoEXT::operator=( - const safe_VkVideoEncodeH264ProfileInfoEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - stdProfileIdc = copy_src.stdProfileIdc; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeH264ProfileInfoEXT::~safe_VkVideoEncodeH264ProfileInfoEXT() { FreePnextChain(pNext); } - -void safe_VkVideoEncodeH264ProfileInfoEXT::initialize(const VkVideoEncodeH264ProfileInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - stdProfileIdc = in_struct->stdProfileIdc; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeH264ProfileInfoEXT::initialize(const safe_VkVideoEncodeH264ProfileInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - stdProfileIdc = copy_src->stdProfileIdc; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeH264RateControlInfoEXT::safe_VkVideoEncodeH264RateControlInfoEXT( - const VkVideoEncodeH264RateControlInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - flags(in_struct->flags), - gopFrameCount(in_struct->gopFrameCount), - idrPeriod(in_struct->idrPeriod), - consecutiveBFrameCount(in_struct->consecutiveBFrameCount), - temporalLayerCount(in_struct->temporalLayerCount) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeH264RateControlInfoEXT::safe_VkVideoEncodeH264RateControlInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT), - pNext(nullptr), - flags(), - gopFrameCount(), - idrPeriod(), - consecutiveBFrameCount(), - temporalLayerCount() {} - -safe_VkVideoEncodeH264RateControlInfoEXT::safe_VkVideoEncodeH264RateControlInfoEXT( - const safe_VkVideoEncodeH264RateControlInfoEXT& copy_src) { - sType = copy_src.sType; - flags = copy_src.flags; - gopFrameCount = copy_src.gopFrameCount; - idrPeriod = copy_src.idrPeriod; - consecutiveBFrameCount = copy_src.consecutiveBFrameCount; - temporalLayerCount = copy_src.temporalLayerCount; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeH264RateControlInfoEXT& safe_VkVideoEncodeH264RateControlInfoEXT::operator=( - const safe_VkVideoEncodeH264RateControlInfoEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - flags = copy_src.flags; - gopFrameCount = copy_src.gopFrameCount; - idrPeriod = copy_src.idrPeriod; - consecutiveBFrameCount = copy_src.consecutiveBFrameCount; - temporalLayerCount = copy_src.temporalLayerCount; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeH264RateControlInfoEXT::~safe_VkVideoEncodeH264RateControlInfoEXT() { FreePnextChain(pNext); } - -void safe_VkVideoEncodeH264RateControlInfoEXT::initialize(const VkVideoEncodeH264RateControlInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - flags = in_struct->flags; - gopFrameCount = in_struct->gopFrameCount; - idrPeriod = in_struct->idrPeriod; - consecutiveBFrameCount = in_struct->consecutiveBFrameCount; - temporalLayerCount = in_struct->temporalLayerCount; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeH264RateControlInfoEXT::initialize(const safe_VkVideoEncodeH264RateControlInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - flags = copy_src->flags; - gopFrameCount = copy_src->gopFrameCount; - idrPeriod = copy_src->idrPeriod; - consecutiveBFrameCount = copy_src->consecutiveBFrameCount; - temporalLayerCount = copy_src->temporalLayerCount; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeH264RateControlLayerInfoEXT::safe_VkVideoEncodeH264RateControlLayerInfoEXT( - const VkVideoEncodeH264RateControlLayerInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - useMinQp(in_struct->useMinQp), - minQp(in_struct->minQp), - useMaxQp(in_struct->useMaxQp), - maxQp(in_struct->maxQp), - useMaxFrameSize(in_struct->useMaxFrameSize), - maxFrameSize(in_struct->maxFrameSize) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeH264RateControlLayerInfoEXT::safe_VkVideoEncodeH264RateControlLayerInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT), - pNext(nullptr), - useMinQp(), - minQp(), - useMaxQp(), - maxQp(), - useMaxFrameSize(), - maxFrameSize() {} - -safe_VkVideoEncodeH264RateControlLayerInfoEXT::safe_VkVideoEncodeH264RateControlLayerInfoEXT( - const safe_VkVideoEncodeH264RateControlLayerInfoEXT& copy_src) { - sType = copy_src.sType; - useMinQp = copy_src.useMinQp; - minQp = copy_src.minQp; - useMaxQp = copy_src.useMaxQp; - maxQp = copy_src.maxQp; - useMaxFrameSize = copy_src.useMaxFrameSize; - maxFrameSize = copy_src.maxFrameSize; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeH264RateControlLayerInfoEXT& safe_VkVideoEncodeH264RateControlLayerInfoEXT::operator=( - const safe_VkVideoEncodeH264RateControlLayerInfoEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - useMinQp = copy_src.useMinQp; - minQp = copy_src.minQp; - useMaxQp = copy_src.useMaxQp; - maxQp = copy_src.maxQp; - useMaxFrameSize = copy_src.useMaxFrameSize; - maxFrameSize = copy_src.maxFrameSize; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeH264RateControlLayerInfoEXT::~safe_VkVideoEncodeH264RateControlLayerInfoEXT() { FreePnextChain(pNext); } - -void safe_VkVideoEncodeH264RateControlLayerInfoEXT::initialize(const VkVideoEncodeH264RateControlLayerInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - useMinQp = in_struct->useMinQp; - minQp = in_struct->minQp; - useMaxQp = in_struct->useMaxQp; - maxQp = in_struct->maxQp; - useMaxFrameSize = in_struct->useMaxFrameSize; - maxFrameSize = in_struct->maxFrameSize; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeH264RateControlLayerInfoEXT::initialize(const safe_VkVideoEncodeH264RateControlLayerInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - useMinQp = copy_src->useMinQp; - minQp = copy_src->minQp; - useMaxQp = copy_src->useMaxQp; - maxQp = copy_src->maxQp; - useMaxFrameSize = copy_src->useMaxFrameSize; - maxFrameSize = copy_src->maxFrameSize; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeH264GopRemainingFrameInfoEXT::safe_VkVideoEncodeH264GopRemainingFrameInfoEXT( - const VkVideoEncodeH264GopRemainingFrameInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - useGopRemainingFrames(in_struct->useGopRemainingFrames), - gopRemainingI(in_struct->gopRemainingI), - gopRemainingP(in_struct->gopRemainingP), - gopRemainingB(in_struct->gopRemainingB) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeH264GopRemainingFrameInfoEXT::safe_VkVideoEncodeH264GopRemainingFrameInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT), - pNext(nullptr), - useGopRemainingFrames(), - gopRemainingI(), - gopRemainingP(), - gopRemainingB() {} - -safe_VkVideoEncodeH264GopRemainingFrameInfoEXT::safe_VkVideoEncodeH264GopRemainingFrameInfoEXT( - const safe_VkVideoEncodeH264GopRemainingFrameInfoEXT& copy_src) { - sType = copy_src.sType; - useGopRemainingFrames = copy_src.useGopRemainingFrames; - gopRemainingI = copy_src.gopRemainingI; - gopRemainingP = copy_src.gopRemainingP; - gopRemainingB = copy_src.gopRemainingB; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeH264GopRemainingFrameInfoEXT& safe_VkVideoEncodeH264GopRemainingFrameInfoEXT::operator=( - const safe_VkVideoEncodeH264GopRemainingFrameInfoEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - useGopRemainingFrames = copy_src.useGopRemainingFrames; - gopRemainingI = copy_src.gopRemainingI; - gopRemainingP = copy_src.gopRemainingP; - gopRemainingB = copy_src.gopRemainingB; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeH264GopRemainingFrameInfoEXT::~safe_VkVideoEncodeH264GopRemainingFrameInfoEXT() { FreePnextChain(pNext); } - -void safe_VkVideoEncodeH264GopRemainingFrameInfoEXT::initialize(const VkVideoEncodeH264GopRemainingFrameInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - useGopRemainingFrames = in_struct->useGopRemainingFrames; - gopRemainingI = in_struct->gopRemainingI; - gopRemainingP = in_struct->gopRemainingP; - gopRemainingB = in_struct->gopRemainingB; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeH264GopRemainingFrameInfoEXT::initialize(const safe_VkVideoEncodeH264GopRemainingFrameInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - useGopRemainingFrames = copy_src->useGopRemainingFrames; - gopRemainingI = copy_src->gopRemainingI; - gopRemainingP = copy_src->gopRemainingP; - gopRemainingB = copy_src->gopRemainingB; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeH265CapabilitiesEXT::safe_VkVideoEncodeH265CapabilitiesEXT(const VkVideoEncodeH265CapabilitiesEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), - flags(in_struct->flags), - maxLevelIdc(in_struct->maxLevelIdc), - maxSliceSegmentCount(in_struct->maxSliceSegmentCount), - maxTiles(in_struct->maxTiles), - ctbSizes(in_struct->ctbSizes), - transformBlockSizes(in_struct->transformBlockSizes), - maxPPictureL0ReferenceCount(in_struct->maxPPictureL0ReferenceCount), - maxBPictureL0ReferenceCount(in_struct->maxBPictureL0ReferenceCount), - maxL1ReferenceCount(in_struct->maxL1ReferenceCount), - maxSubLayerCount(in_struct->maxSubLayerCount), - expectDyadicTemporalSubLayerPattern(in_struct->expectDyadicTemporalSubLayerPattern), - minQp(in_struct->minQp), - maxQp(in_struct->maxQp), - prefersGopRemainingFrames(in_struct->prefersGopRemainingFrames), - requiresGopRemainingFrames(in_struct->requiresGopRemainingFrames), - stdSyntaxFlags(in_struct->stdSyntaxFlags) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeH265CapabilitiesEXT::safe_VkVideoEncodeH265CapabilitiesEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT), - pNext(nullptr), - flags(), - maxLevelIdc(), - maxSliceSegmentCount(), - maxTiles(), - ctbSizes(), - transformBlockSizes(), - maxPPictureL0ReferenceCount(), - maxBPictureL0ReferenceCount(), - maxL1ReferenceCount(), - maxSubLayerCount(), - expectDyadicTemporalSubLayerPattern(), - minQp(), - maxQp(), - prefersGopRemainingFrames(), - requiresGopRemainingFrames(), - stdSyntaxFlags() {} - -safe_VkVideoEncodeH265CapabilitiesEXT::safe_VkVideoEncodeH265CapabilitiesEXT( - const safe_VkVideoEncodeH265CapabilitiesEXT& copy_src) { - sType = copy_src.sType; - flags = copy_src.flags; - maxLevelIdc = copy_src.maxLevelIdc; - maxSliceSegmentCount = copy_src.maxSliceSegmentCount; - maxTiles = copy_src.maxTiles; - ctbSizes = copy_src.ctbSizes; - transformBlockSizes = copy_src.transformBlockSizes; - maxPPictureL0ReferenceCount = copy_src.maxPPictureL0ReferenceCount; - maxBPictureL0ReferenceCount = copy_src.maxBPictureL0ReferenceCount; - maxL1ReferenceCount = copy_src.maxL1ReferenceCount; - maxSubLayerCount = copy_src.maxSubLayerCount; - expectDyadicTemporalSubLayerPattern = copy_src.expectDyadicTemporalSubLayerPattern; - minQp = copy_src.minQp; - maxQp = copy_src.maxQp; - prefersGopRemainingFrames = copy_src.prefersGopRemainingFrames; - requiresGopRemainingFrames = copy_src.requiresGopRemainingFrames; - stdSyntaxFlags = copy_src.stdSyntaxFlags; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeH265CapabilitiesEXT& safe_VkVideoEncodeH265CapabilitiesEXT::operator=( - const safe_VkVideoEncodeH265CapabilitiesEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - flags = copy_src.flags; - maxLevelIdc = copy_src.maxLevelIdc; - maxSliceSegmentCount = copy_src.maxSliceSegmentCount; - maxTiles = copy_src.maxTiles; - ctbSizes = copy_src.ctbSizes; - transformBlockSizes = copy_src.transformBlockSizes; - maxPPictureL0ReferenceCount = copy_src.maxPPictureL0ReferenceCount; - maxBPictureL0ReferenceCount = copy_src.maxBPictureL0ReferenceCount; - maxL1ReferenceCount = copy_src.maxL1ReferenceCount; - maxSubLayerCount = copy_src.maxSubLayerCount; - expectDyadicTemporalSubLayerPattern = copy_src.expectDyadicTemporalSubLayerPattern; - minQp = copy_src.minQp; - maxQp = copy_src.maxQp; - prefersGopRemainingFrames = copy_src.prefersGopRemainingFrames; - requiresGopRemainingFrames = copy_src.requiresGopRemainingFrames; - stdSyntaxFlags = copy_src.stdSyntaxFlags; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeH265CapabilitiesEXT::~safe_VkVideoEncodeH265CapabilitiesEXT() { FreePnextChain(pNext); } - -void safe_VkVideoEncodeH265CapabilitiesEXT::initialize(const VkVideoEncodeH265CapabilitiesEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - flags = in_struct->flags; - maxLevelIdc = in_struct->maxLevelIdc; - maxSliceSegmentCount = in_struct->maxSliceSegmentCount; - maxTiles = in_struct->maxTiles; - ctbSizes = in_struct->ctbSizes; - transformBlockSizes = in_struct->transformBlockSizes; - maxPPictureL0ReferenceCount = in_struct->maxPPictureL0ReferenceCount; - maxBPictureL0ReferenceCount = in_struct->maxBPictureL0ReferenceCount; - maxL1ReferenceCount = in_struct->maxL1ReferenceCount; - maxSubLayerCount = in_struct->maxSubLayerCount; - expectDyadicTemporalSubLayerPattern = in_struct->expectDyadicTemporalSubLayerPattern; - minQp = in_struct->minQp; - maxQp = in_struct->maxQp; - prefersGopRemainingFrames = in_struct->prefersGopRemainingFrames; - requiresGopRemainingFrames = in_struct->requiresGopRemainingFrames; - stdSyntaxFlags = in_struct->stdSyntaxFlags; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeH265CapabilitiesEXT::initialize(const safe_VkVideoEncodeH265CapabilitiesEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - flags = copy_src->flags; - maxLevelIdc = copy_src->maxLevelIdc; - maxSliceSegmentCount = copy_src->maxSliceSegmentCount; - maxTiles = copy_src->maxTiles; - ctbSizes = copy_src->ctbSizes; - transformBlockSizes = copy_src->transformBlockSizes; - maxPPictureL0ReferenceCount = copy_src->maxPPictureL0ReferenceCount; - maxBPictureL0ReferenceCount = copy_src->maxBPictureL0ReferenceCount; - maxL1ReferenceCount = copy_src->maxL1ReferenceCount; - maxSubLayerCount = copy_src->maxSubLayerCount; - expectDyadicTemporalSubLayerPattern = copy_src->expectDyadicTemporalSubLayerPattern; - minQp = copy_src->minQp; - maxQp = copy_src->maxQp; - prefersGopRemainingFrames = copy_src->prefersGopRemainingFrames; - requiresGopRemainingFrames = copy_src->requiresGopRemainingFrames; - stdSyntaxFlags = copy_src->stdSyntaxFlags; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeH265SessionCreateInfoEXT::safe_VkVideoEncodeH265SessionCreateInfoEXT( - const VkVideoEncodeH265SessionCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), useMaxLevelIdc(in_struct->useMaxLevelIdc), maxLevelIdc(in_struct->maxLevelIdc) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeH265SessionCreateInfoEXT::safe_VkVideoEncodeH265SessionCreateInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT), pNext(nullptr), useMaxLevelIdc(), maxLevelIdc() {} - -safe_VkVideoEncodeH265SessionCreateInfoEXT::safe_VkVideoEncodeH265SessionCreateInfoEXT( - const safe_VkVideoEncodeH265SessionCreateInfoEXT& copy_src) { - sType = copy_src.sType; - useMaxLevelIdc = copy_src.useMaxLevelIdc; - maxLevelIdc = copy_src.maxLevelIdc; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeH265SessionCreateInfoEXT& safe_VkVideoEncodeH265SessionCreateInfoEXT::operator=( - const safe_VkVideoEncodeH265SessionCreateInfoEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - useMaxLevelIdc = copy_src.useMaxLevelIdc; - maxLevelIdc = copy_src.maxLevelIdc; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeH265SessionCreateInfoEXT::~safe_VkVideoEncodeH265SessionCreateInfoEXT() { FreePnextChain(pNext); } - -void safe_VkVideoEncodeH265SessionCreateInfoEXT::initialize(const VkVideoEncodeH265SessionCreateInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - useMaxLevelIdc = in_struct->useMaxLevelIdc; - maxLevelIdc = in_struct->maxLevelIdc; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeH265SessionCreateInfoEXT::initialize(const safe_VkVideoEncodeH265SessionCreateInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - useMaxLevelIdc = copy_src->useMaxLevelIdc; - maxLevelIdc = copy_src->maxLevelIdc; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeH265QualityLevelPropertiesEXT::safe_VkVideoEncodeH265QualityLevelPropertiesEXT( - const VkVideoEncodeH265QualityLevelPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - preferredRateControlFlags(in_struct->preferredRateControlFlags), - preferredGopFrameCount(in_struct->preferredGopFrameCount), - preferredIdrPeriod(in_struct->preferredIdrPeriod), - preferredConsecutiveBFrameCount(in_struct->preferredConsecutiveBFrameCount), - preferredSubLayerCount(in_struct->preferredSubLayerCount), - preferredConstantQp(in_struct->preferredConstantQp), - preferredMaxL0ReferenceCount(in_struct->preferredMaxL0ReferenceCount), - preferredMaxL1ReferenceCount(in_struct->preferredMaxL1ReferenceCount) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeH265QualityLevelPropertiesEXT::safe_VkVideoEncodeH265QualityLevelPropertiesEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT), - pNext(nullptr), - preferredRateControlFlags(), - preferredGopFrameCount(), - preferredIdrPeriod(), - preferredConsecutiveBFrameCount(), - preferredSubLayerCount(), - preferredConstantQp(), - preferredMaxL0ReferenceCount(), - preferredMaxL1ReferenceCount() {} - -safe_VkVideoEncodeH265QualityLevelPropertiesEXT::safe_VkVideoEncodeH265QualityLevelPropertiesEXT( - const safe_VkVideoEncodeH265QualityLevelPropertiesEXT& copy_src) { - sType = copy_src.sType; - preferredRateControlFlags = copy_src.preferredRateControlFlags; - preferredGopFrameCount = copy_src.preferredGopFrameCount; - preferredIdrPeriod = copy_src.preferredIdrPeriod; - preferredConsecutiveBFrameCount = copy_src.preferredConsecutiveBFrameCount; - preferredSubLayerCount = copy_src.preferredSubLayerCount; - preferredConstantQp = copy_src.preferredConstantQp; - preferredMaxL0ReferenceCount = copy_src.preferredMaxL0ReferenceCount; - preferredMaxL1ReferenceCount = copy_src.preferredMaxL1ReferenceCount; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeH265QualityLevelPropertiesEXT& safe_VkVideoEncodeH265QualityLevelPropertiesEXT::operator=( - const safe_VkVideoEncodeH265QualityLevelPropertiesEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - preferredRateControlFlags = copy_src.preferredRateControlFlags; - preferredGopFrameCount = copy_src.preferredGopFrameCount; - preferredIdrPeriod = copy_src.preferredIdrPeriod; - preferredConsecutiveBFrameCount = copy_src.preferredConsecutiveBFrameCount; - preferredSubLayerCount = copy_src.preferredSubLayerCount; - preferredConstantQp = copy_src.preferredConstantQp; - preferredMaxL0ReferenceCount = copy_src.preferredMaxL0ReferenceCount; - preferredMaxL1ReferenceCount = copy_src.preferredMaxL1ReferenceCount; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeH265QualityLevelPropertiesEXT::~safe_VkVideoEncodeH265QualityLevelPropertiesEXT() { FreePnextChain(pNext); } - -void safe_VkVideoEncodeH265QualityLevelPropertiesEXT::initialize(const VkVideoEncodeH265QualityLevelPropertiesEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - preferredRateControlFlags = in_struct->preferredRateControlFlags; - preferredGopFrameCount = in_struct->preferredGopFrameCount; - preferredIdrPeriod = in_struct->preferredIdrPeriod; - preferredConsecutiveBFrameCount = in_struct->preferredConsecutiveBFrameCount; - preferredSubLayerCount = in_struct->preferredSubLayerCount; - preferredConstantQp = in_struct->preferredConstantQp; - preferredMaxL0ReferenceCount = in_struct->preferredMaxL0ReferenceCount; - preferredMaxL1ReferenceCount = in_struct->preferredMaxL1ReferenceCount; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeH265QualityLevelPropertiesEXT::initialize(const safe_VkVideoEncodeH265QualityLevelPropertiesEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - preferredRateControlFlags = copy_src->preferredRateControlFlags; - preferredGopFrameCount = copy_src->preferredGopFrameCount; - preferredIdrPeriod = copy_src->preferredIdrPeriod; - preferredConsecutiveBFrameCount = copy_src->preferredConsecutiveBFrameCount; - preferredSubLayerCount = copy_src->preferredSubLayerCount; - preferredConstantQp = copy_src->preferredConstantQp; - preferredMaxL0ReferenceCount = copy_src->preferredMaxL0ReferenceCount; - preferredMaxL1ReferenceCount = copy_src->preferredMaxL1ReferenceCount; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeH265SessionParametersAddInfoEXT::safe_VkVideoEncodeH265SessionParametersAddInfoEXT( - const VkVideoEncodeH265SessionParametersAddInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - stdVPSCount(in_struct->stdVPSCount), - pStdVPSs(nullptr), - stdSPSCount(in_struct->stdSPSCount), - pStdSPSs(nullptr), - stdPPSCount(in_struct->stdPPSCount), - pStdPPSs(nullptr) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } - if (in_struct->pStdVPSs) { - pStdVPSs = new StdVideoH265VideoParameterSet[in_struct->stdVPSCount]; - memcpy((void*)pStdVPSs, (void*)in_struct->pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * in_struct->stdVPSCount); - } - - if (in_struct->pStdSPSs) { - pStdSPSs = new StdVideoH265SequenceParameterSet[in_struct->stdSPSCount]; - memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * in_struct->stdSPSCount); - } - - if (in_struct->pStdPPSs) { - pStdPPSs = new StdVideoH265PictureParameterSet[in_struct->stdPPSCount]; - memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * in_struct->stdPPSCount); - } -} - -safe_VkVideoEncodeH265SessionParametersAddInfoEXT::safe_VkVideoEncodeH265SessionParametersAddInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT), - pNext(nullptr), - stdVPSCount(), - pStdVPSs(nullptr), - stdSPSCount(), - pStdSPSs(nullptr), - stdPPSCount(), - pStdPPSs(nullptr) {} - -safe_VkVideoEncodeH265SessionParametersAddInfoEXT::safe_VkVideoEncodeH265SessionParametersAddInfoEXT( - const safe_VkVideoEncodeH265SessionParametersAddInfoEXT& copy_src) { - sType = copy_src.sType; - stdVPSCount = copy_src.stdVPSCount; - pStdVPSs = nullptr; - stdSPSCount = copy_src.stdSPSCount; - pStdSPSs = nullptr; - stdPPSCount = copy_src.stdPPSCount; - pStdPPSs = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdVPSs) { - pStdVPSs = new StdVideoH265VideoParameterSet[copy_src.stdVPSCount]; - memcpy((void*)pStdVPSs, (void*)copy_src.pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * copy_src.stdVPSCount); - } - - if (copy_src.pStdSPSs) { - pStdSPSs = new StdVideoH265SequenceParameterSet[copy_src.stdSPSCount]; - memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * copy_src.stdSPSCount); - } - - if (copy_src.pStdPPSs) { - pStdPPSs = new StdVideoH265PictureParameterSet[copy_src.stdPPSCount]; - memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * copy_src.stdPPSCount); - } -} - -safe_VkVideoEncodeH265SessionParametersAddInfoEXT& safe_VkVideoEncodeH265SessionParametersAddInfoEXT::operator=( - const safe_VkVideoEncodeH265SessionParametersAddInfoEXT& copy_src) { - if (©_src == this) return *this; - - if (pStdVPSs) delete[] pStdVPSs; - if (pStdSPSs) delete[] pStdSPSs; - if (pStdPPSs) delete[] pStdPPSs; - FreePnextChain(pNext); - - sType = copy_src.sType; - stdVPSCount = copy_src.stdVPSCount; - pStdVPSs = nullptr; - stdSPSCount = copy_src.stdSPSCount; - pStdSPSs = nullptr; - stdPPSCount = copy_src.stdPPSCount; - pStdPPSs = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdVPSs) { - pStdVPSs = new StdVideoH265VideoParameterSet[copy_src.stdVPSCount]; - memcpy((void*)pStdVPSs, (void*)copy_src.pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * copy_src.stdVPSCount); - } - - if (copy_src.pStdSPSs) { - pStdSPSs = new StdVideoH265SequenceParameterSet[copy_src.stdSPSCount]; - memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * copy_src.stdSPSCount); - } - - if (copy_src.pStdPPSs) { - pStdPPSs = new StdVideoH265PictureParameterSet[copy_src.stdPPSCount]; - memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * copy_src.stdPPSCount); - } - - return *this; -} - -safe_VkVideoEncodeH265SessionParametersAddInfoEXT::~safe_VkVideoEncodeH265SessionParametersAddInfoEXT() { - if (pStdVPSs) delete[] pStdVPSs; - if (pStdSPSs) delete[] pStdSPSs; - if (pStdPPSs) delete[] pStdPPSs; - FreePnextChain(pNext); -} - -void safe_VkVideoEncodeH265SessionParametersAddInfoEXT::initialize(const VkVideoEncodeH265SessionParametersAddInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pStdVPSs) delete[] pStdVPSs; - if (pStdSPSs) delete[] pStdSPSs; - if (pStdPPSs) delete[] pStdPPSs; - FreePnextChain(pNext); - sType = in_struct->sType; - stdVPSCount = in_struct->stdVPSCount; - pStdVPSs = nullptr; - stdSPSCount = in_struct->stdSPSCount; - pStdSPSs = nullptr; - stdPPSCount = in_struct->stdPPSCount; - pStdPPSs = nullptr; - pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pStdVPSs) { - pStdVPSs = new StdVideoH265VideoParameterSet[in_struct->stdVPSCount]; - memcpy((void*)pStdVPSs, (void*)in_struct->pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * in_struct->stdVPSCount); - } - - if (in_struct->pStdSPSs) { - pStdSPSs = new StdVideoH265SequenceParameterSet[in_struct->stdSPSCount]; - memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * in_struct->stdSPSCount); - } - - if (in_struct->pStdPPSs) { - pStdPPSs = new StdVideoH265PictureParameterSet[in_struct->stdPPSCount]; - memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * in_struct->stdPPSCount); - } -} - -void safe_VkVideoEncodeH265SessionParametersAddInfoEXT::initialize( - const safe_VkVideoEncodeH265SessionParametersAddInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - stdVPSCount = copy_src->stdVPSCount; - pStdVPSs = nullptr; - stdSPSCount = copy_src->stdSPSCount; - pStdSPSs = nullptr; - stdPPSCount = copy_src->stdPPSCount; - pStdPPSs = nullptr; - pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pStdVPSs) { - pStdVPSs = new StdVideoH265VideoParameterSet[copy_src->stdVPSCount]; - memcpy((void*)pStdVPSs, (void*)copy_src->pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * copy_src->stdVPSCount); - } - - if (copy_src->pStdSPSs) { - pStdSPSs = new StdVideoH265SequenceParameterSet[copy_src->stdSPSCount]; - memcpy((void*)pStdSPSs, (void*)copy_src->pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * copy_src->stdSPSCount); - } - - if (copy_src->pStdPPSs) { - pStdPPSs = new StdVideoH265PictureParameterSet[copy_src->stdPPSCount]; - memcpy((void*)pStdPPSs, (void*)copy_src->pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * copy_src->stdPPSCount); - } -} - -safe_VkVideoEncodeH265SessionParametersCreateInfoEXT::safe_VkVideoEncodeH265SessionParametersCreateInfoEXT( - const VkVideoEncodeH265SessionParametersCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - maxStdVPSCount(in_struct->maxStdVPSCount), - maxStdSPSCount(in_struct->maxStdSPSCount), - maxStdPPSCount(in_struct->maxStdPPSCount), - pParametersAddInfo(nullptr) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } - if (in_struct->pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoEncodeH265SessionParametersAddInfoEXT(in_struct->pParametersAddInfo); -} - -safe_VkVideoEncodeH265SessionParametersCreateInfoEXT::safe_VkVideoEncodeH265SessionParametersCreateInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT), - pNext(nullptr), - maxStdVPSCount(), - maxStdSPSCount(), - maxStdPPSCount(), - pParametersAddInfo(nullptr) {} - -safe_VkVideoEncodeH265SessionParametersCreateInfoEXT::safe_VkVideoEncodeH265SessionParametersCreateInfoEXT( - const safe_VkVideoEncodeH265SessionParametersCreateInfoEXT& copy_src) { - sType = copy_src.sType; - maxStdVPSCount = copy_src.maxStdVPSCount; - maxStdSPSCount = copy_src.maxStdSPSCount; - maxStdPPSCount = copy_src.maxStdPPSCount; - pParametersAddInfo = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoEncodeH265SessionParametersAddInfoEXT(*copy_src.pParametersAddInfo); -} - -safe_VkVideoEncodeH265SessionParametersCreateInfoEXT& safe_VkVideoEncodeH265SessionParametersCreateInfoEXT::operator=( - const safe_VkVideoEncodeH265SessionParametersCreateInfoEXT& copy_src) { - if (©_src == this) return *this; - - if (pParametersAddInfo) delete pParametersAddInfo; - FreePnextChain(pNext); - - sType = copy_src.sType; - maxStdVPSCount = copy_src.maxStdVPSCount; - maxStdSPSCount = copy_src.maxStdSPSCount; - maxStdPPSCount = copy_src.maxStdPPSCount; - pParametersAddInfo = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoEncodeH265SessionParametersAddInfoEXT(*copy_src.pParametersAddInfo); - - return *this; -} - -safe_VkVideoEncodeH265SessionParametersCreateInfoEXT::~safe_VkVideoEncodeH265SessionParametersCreateInfoEXT() { - if (pParametersAddInfo) delete pParametersAddInfo; - FreePnextChain(pNext); -} - -void safe_VkVideoEncodeH265SessionParametersCreateInfoEXT::initialize( - const VkVideoEncodeH265SessionParametersCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - if (pParametersAddInfo) delete pParametersAddInfo; - FreePnextChain(pNext); - sType = in_struct->sType; - maxStdVPSCount = in_struct->maxStdVPSCount; - maxStdSPSCount = in_struct->maxStdSPSCount; - maxStdPPSCount = in_struct->maxStdPPSCount; - pParametersAddInfo = nullptr; - pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (in_struct->pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoEncodeH265SessionParametersAddInfoEXT(in_struct->pParametersAddInfo); -} - -void safe_VkVideoEncodeH265SessionParametersCreateInfoEXT::initialize( - const safe_VkVideoEncodeH265SessionParametersCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - maxStdVPSCount = copy_src->maxStdVPSCount; - maxStdSPSCount = copy_src->maxStdSPSCount; - maxStdPPSCount = copy_src->maxStdPPSCount; - pParametersAddInfo = nullptr; - pNext = SafePnextCopy(copy_src->pNext); - if (copy_src->pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoEncodeH265SessionParametersAddInfoEXT(*copy_src->pParametersAddInfo); -} - -safe_VkVideoEncodeH265SessionParametersGetInfoEXT::safe_VkVideoEncodeH265SessionParametersGetInfoEXT( - const VkVideoEncodeH265SessionParametersGetInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - writeStdVPS(in_struct->writeStdVPS), - writeStdSPS(in_struct->writeStdSPS), - writeStdPPS(in_struct->writeStdPPS), - stdVPSId(in_struct->stdVPSId), - stdSPSId(in_struct->stdSPSId), - stdPPSId(in_struct->stdPPSId) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeH265SessionParametersGetInfoEXT::safe_VkVideoEncodeH265SessionParametersGetInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT), - pNext(nullptr), - writeStdVPS(), - writeStdSPS(), - writeStdPPS(), - stdVPSId(), - stdSPSId(), - stdPPSId() {} - -safe_VkVideoEncodeH265SessionParametersGetInfoEXT::safe_VkVideoEncodeH265SessionParametersGetInfoEXT( - const safe_VkVideoEncodeH265SessionParametersGetInfoEXT& copy_src) { - sType = copy_src.sType; - writeStdVPS = copy_src.writeStdVPS; - writeStdSPS = copy_src.writeStdSPS; - writeStdPPS = copy_src.writeStdPPS; - stdVPSId = copy_src.stdVPSId; - stdSPSId = copy_src.stdSPSId; - stdPPSId = copy_src.stdPPSId; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeH265SessionParametersGetInfoEXT& safe_VkVideoEncodeH265SessionParametersGetInfoEXT::operator=( - const safe_VkVideoEncodeH265SessionParametersGetInfoEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - writeStdVPS = copy_src.writeStdVPS; - writeStdSPS = copy_src.writeStdSPS; - writeStdPPS = copy_src.writeStdPPS; - stdVPSId = copy_src.stdVPSId; - stdSPSId = copy_src.stdSPSId; - stdPPSId = copy_src.stdPPSId; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeH265SessionParametersGetInfoEXT::~safe_VkVideoEncodeH265SessionParametersGetInfoEXT() { FreePnextChain(pNext); } - -void safe_VkVideoEncodeH265SessionParametersGetInfoEXT::initialize(const VkVideoEncodeH265SessionParametersGetInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - writeStdVPS = in_struct->writeStdVPS; - writeStdSPS = in_struct->writeStdSPS; - writeStdPPS = in_struct->writeStdPPS; - stdVPSId = in_struct->stdVPSId; - stdSPSId = in_struct->stdSPSId; - stdPPSId = in_struct->stdPPSId; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeH265SessionParametersGetInfoEXT::initialize( - const safe_VkVideoEncodeH265SessionParametersGetInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - writeStdVPS = copy_src->writeStdVPS; - writeStdSPS = copy_src->writeStdSPS; - writeStdPPS = copy_src->writeStdPPS; - stdVPSId = copy_src->stdVPSId; - stdSPSId = copy_src->stdSPSId; - stdPPSId = copy_src->stdPPSId; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT::safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT( - const VkVideoEncodeH265SessionParametersFeedbackInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), - hasStdVPSOverrides(in_struct->hasStdVPSOverrides), - hasStdSPSOverrides(in_struct->hasStdSPSOverrides), - hasStdPPSOverrides(in_struct->hasStdPPSOverrides) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT::safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT), - pNext(nullptr), - hasStdVPSOverrides(), - hasStdSPSOverrides(), - hasStdPPSOverrides() {} - -safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT::safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT( - const safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT& copy_src) { - sType = copy_src.sType; - hasStdVPSOverrides = copy_src.hasStdVPSOverrides; - hasStdSPSOverrides = copy_src.hasStdSPSOverrides; - hasStdPPSOverrides = copy_src.hasStdPPSOverrides; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT& safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT::operator=( - const safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - hasStdVPSOverrides = copy_src.hasStdVPSOverrides; - hasStdSPSOverrides = copy_src.hasStdSPSOverrides; - hasStdPPSOverrides = copy_src.hasStdPPSOverrides; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT::~safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT() { - FreePnextChain(pNext); -} - -void safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT::initialize( - const VkVideoEncodeH265SessionParametersFeedbackInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - hasStdVPSOverrides = in_struct->hasStdVPSOverrides; - hasStdSPSOverrides = in_struct->hasStdSPSOverrides; - hasStdPPSOverrides = in_struct->hasStdPPSOverrides; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT::initialize( - const safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - hasStdVPSOverrides = copy_src->hasStdVPSOverrides; - hasStdSPSOverrides = copy_src->hasStdSPSOverrides; - hasStdPPSOverrides = copy_src->hasStdPPSOverrides; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT::safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT( - const VkVideoEncodeH265NaluSliceSegmentInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), constantQp(in_struct->constantQp), pStdSliceSegmentHeader(nullptr) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } - if (in_struct->pStdSliceSegmentHeader) { - pStdSliceSegmentHeader = new StdVideoEncodeH265SliceSegmentHeader(*in_struct->pStdSliceSegmentHeader); - } -} - -safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT::safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT), - pNext(nullptr), - constantQp(), - pStdSliceSegmentHeader(nullptr) {} - -safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT::safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT( - const safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT& copy_src) { - sType = copy_src.sType; - constantQp = copy_src.constantQp; - pStdSliceSegmentHeader = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdSliceSegmentHeader) { - pStdSliceSegmentHeader = new StdVideoEncodeH265SliceSegmentHeader(*copy_src.pStdSliceSegmentHeader); - } -} - -safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT& safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT::operator=( - const safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT& copy_src) { - if (©_src == this) return *this; - - if (pStdSliceSegmentHeader) delete pStdSliceSegmentHeader; - FreePnextChain(pNext); - - sType = copy_src.sType; - constantQp = copy_src.constantQp; - pStdSliceSegmentHeader = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdSliceSegmentHeader) { - pStdSliceSegmentHeader = new StdVideoEncodeH265SliceSegmentHeader(*copy_src.pStdSliceSegmentHeader); - } - - return *this; -} - -safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT::~safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT() { - if (pStdSliceSegmentHeader) delete pStdSliceSegmentHeader; - FreePnextChain(pNext); -} - -void safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT::initialize(const VkVideoEncodeH265NaluSliceSegmentInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pStdSliceSegmentHeader) delete pStdSliceSegmentHeader; - FreePnextChain(pNext); - sType = in_struct->sType; - constantQp = in_struct->constantQp; - pStdSliceSegmentHeader = nullptr; - pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pStdSliceSegmentHeader) { - pStdSliceSegmentHeader = new StdVideoEncodeH265SliceSegmentHeader(*in_struct->pStdSliceSegmentHeader); - } -} - -void safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT::initialize(const safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - constantQp = copy_src->constantQp; - pStdSliceSegmentHeader = nullptr; - pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pStdSliceSegmentHeader) { - pStdSliceSegmentHeader = new StdVideoEncodeH265SliceSegmentHeader(*copy_src->pStdSliceSegmentHeader); - } -} - -safe_VkVideoEncodeH265PictureInfoEXT::safe_VkVideoEncodeH265PictureInfoEXT(const VkVideoEncodeH265PictureInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), - naluSliceSegmentEntryCount(in_struct->naluSliceSegmentEntryCount), - pNaluSliceSegmentEntries(nullptr), - pStdPictureInfo(nullptr) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } - if (naluSliceSegmentEntryCount && in_struct->pNaluSliceSegmentEntries) { - pNaluSliceSegmentEntries = new safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT[naluSliceSegmentEntryCount]; - for (uint32_t i = 0; i < naluSliceSegmentEntryCount; ++i) { - pNaluSliceSegmentEntries[i].initialize(&in_struct->pNaluSliceSegmentEntries[i]); - } - } - - if (in_struct->pStdPictureInfo) { - pStdPictureInfo = new StdVideoEncodeH265PictureInfo(*in_struct->pStdPictureInfo); - } -} - -safe_VkVideoEncodeH265PictureInfoEXT::safe_VkVideoEncodeH265PictureInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT), - pNext(nullptr), - naluSliceSegmentEntryCount(), - pNaluSliceSegmentEntries(nullptr), - pStdPictureInfo(nullptr) {} - -safe_VkVideoEncodeH265PictureInfoEXT::safe_VkVideoEncodeH265PictureInfoEXT(const safe_VkVideoEncodeH265PictureInfoEXT& copy_src) { - sType = copy_src.sType; - naluSliceSegmentEntryCount = copy_src.naluSliceSegmentEntryCount; - pNaluSliceSegmentEntries = nullptr; - pStdPictureInfo = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (naluSliceSegmentEntryCount && copy_src.pNaluSliceSegmentEntries) { - pNaluSliceSegmentEntries = new safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT[naluSliceSegmentEntryCount]; - for (uint32_t i = 0; i < naluSliceSegmentEntryCount; ++i) { - pNaluSliceSegmentEntries[i].initialize(©_src.pNaluSliceSegmentEntries[i]); - } - } - - if (copy_src.pStdPictureInfo) { - pStdPictureInfo = new StdVideoEncodeH265PictureInfo(*copy_src.pStdPictureInfo); - } -} - -safe_VkVideoEncodeH265PictureInfoEXT& safe_VkVideoEncodeH265PictureInfoEXT::operator=( - const safe_VkVideoEncodeH265PictureInfoEXT& copy_src) { - if (©_src == this) return *this; - - if (pNaluSliceSegmentEntries) delete[] pNaluSliceSegmentEntries; - if (pStdPictureInfo) delete pStdPictureInfo; - FreePnextChain(pNext); - - sType = copy_src.sType; - naluSliceSegmentEntryCount = copy_src.naluSliceSegmentEntryCount; - pNaluSliceSegmentEntries = nullptr; - pStdPictureInfo = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - if (naluSliceSegmentEntryCount && copy_src.pNaluSliceSegmentEntries) { - pNaluSliceSegmentEntries = new safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT[naluSliceSegmentEntryCount]; - for (uint32_t i = 0; i < naluSliceSegmentEntryCount; ++i) { - pNaluSliceSegmentEntries[i].initialize(©_src.pNaluSliceSegmentEntries[i]); - } - } - - if (copy_src.pStdPictureInfo) { - pStdPictureInfo = new StdVideoEncodeH265PictureInfo(*copy_src.pStdPictureInfo); - } - - return *this; -} - -safe_VkVideoEncodeH265PictureInfoEXT::~safe_VkVideoEncodeH265PictureInfoEXT() { - if (pNaluSliceSegmentEntries) delete[] pNaluSliceSegmentEntries; - if (pStdPictureInfo) delete pStdPictureInfo; - FreePnextChain(pNext); -} - -void safe_VkVideoEncodeH265PictureInfoEXT::initialize(const VkVideoEncodeH265PictureInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pNaluSliceSegmentEntries) delete[] pNaluSliceSegmentEntries; - if (pStdPictureInfo) delete pStdPictureInfo; - FreePnextChain(pNext); - sType = in_struct->sType; - naluSliceSegmentEntryCount = in_struct->naluSliceSegmentEntryCount; - pNaluSliceSegmentEntries = nullptr; - pStdPictureInfo = nullptr; - pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (naluSliceSegmentEntryCount && in_struct->pNaluSliceSegmentEntries) { - pNaluSliceSegmentEntries = new safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT[naluSliceSegmentEntryCount]; - for (uint32_t i = 0; i < naluSliceSegmentEntryCount; ++i) { - pNaluSliceSegmentEntries[i].initialize(&in_struct->pNaluSliceSegmentEntries[i]); - } - } - - if (in_struct->pStdPictureInfo) { - pStdPictureInfo = new StdVideoEncodeH265PictureInfo(*in_struct->pStdPictureInfo); - } -} - -void safe_VkVideoEncodeH265PictureInfoEXT::initialize(const safe_VkVideoEncodeH265PictureInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - naluSliceSegmentEntryCount = copy_src->naluSliceSegmentEntryCount; - pNaluSliceSegmentEntries = nullptr; - pStdPictureInfo = nullptr; - pNext = SafePnextCopy(copy_src->pNext); - if (naluSliceSegmentEntryCount && copy_src->pNaluSliceSegmentEntries) { - pNaluSliceSegmentEntries = new safe_VkVideoEncodeH265NaluSliceSegmentInfoEXT[naluSliceSegmentEntryCount]; - for (uint32_t i = 0; i < naluSliceSegmentEntryCount; ++i) { - pNaluSliceSegmentEntries[i].initialize(©_src->pNaluSliceSegmentEntries[i]); - } - } - - if (copy_src->pStdPictureInfo) { - pStdPictureInfo = new StdVideoEncodeH265PictureInfo(*copy_src->pStdPictureInfo); - } -} - -safe_VkVideoEncodeH265DpbSlotInfoEXT::safe_VkVideoEncodeH265DpbSlotInfoEXT(const VkVideoEncodeH265DpbSlotInfoEXT* 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 StdVideoEncodeH265ReferenceInfo(*in_struct->pStdReferenceInfo); - } -} - -safe_VkVideoEncodeH265DpbSlotInfoEXT::safe_VkVideoEncodeH265DpbSlotInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT), pNext(nullptr), pStdReferenceInfo(nullptr) {} - -safe_VkVideoEncodeH265DpbSlotInfoEXT::safe_VkVideoEncodeH265DpbSlotInfoEXT(const safe_VkVideoEncodeH265DpbSlotInfoEXT& copy_src) { - sType = copy_src.sType; - pStdReferenceInfo = nullptr; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoEncodeH265ReferenceInfo(*copy_src.pStdReferenceInfo); - } -} - -safe_VkVideoEncodeH265DpbSlotInfoEXT& safe_VkVideoEncodeH265DpbSlotInfoEXT::operator=( - const safe_VkVideoEncodeH265DpbSlotInfoEXT& 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 StdVideoEncodeH265ReferenceInfo(*copy_src.pStdReferenceInfo); - } - - return *this; -} - -safe_VkVideoEncodeH265DpbSlotInfoEXT::~safe_VkVideoEncodeH265DpbSlotInfoEXT() { - if (pStdReferenceInfo) delete pStdReferenceInfo; - FreePnextChain(pNext); -} - -void safe_VkVideoEncodeH265DpbSlotInfoEXT::initialize(const VkVideoEncodeH265DpbSlotInfoEXT* 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 StdVideoEncodeH265ReferenceInfo(*in_struct->pStdReferenceInfo); - } -} - -void safe_VkVideoEncodeH265DpbSlotInfoEXT::initialize(const safe_VkVideoEncodeH265DpbSlotInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - pStdReferenceInfo = nullptr; - pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoEncodeH265ReferenceInfo(*copy_src->pStdReferenceInfo); - } -} - -safe_VkVideoEncodeH265ProfileInfoEXT::safe_VkVideoEncodeH265ProfileInfoEXT(const VkVideoEncodeH265ProfileInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), stdProfileIdc(in_struct->stdProfileIdc) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeH265ProfileInfoEXT::safe_VkVideoEncodeH265ProfileInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT), pNext(nullptr), stdProfileIdc() {} - -safe_VkVideoEncodeH265ProfileInfoEXT::safe_VkVideoEncodeH265ProfileInfoEXT(const safe_VkVideoEncodeH265ProfileInfoEXT& copy_src) { - sType = copy_src.sType; - stdProfileIdc = copy_src.stdProfileIdc; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeH265ProfileInfoEXT& safe_VkVideoEncodeH265ProfileInfoEXT::operator=( - const safe_VkVideoEncodeH265ProfileInfoEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - stdProfileIdc = copy_src.stdProfileIdc; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeH265ProfileInfoEXT::~safe_VkVideoEncodeH265ProfileInfoEXT() { FreePnextChain(pNext); } - -void safe_VkVideoEncodeH265ProfileInfoEXT::initialize(const VkVideoEncodeH265ProfileInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - stdProfileIdc = in_struct->stdProfileIdc; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeH265ProfileInfoEXT::initialize(const safe_VkVideoEncodeH265ProfileInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - stdProfileIdc = copy_src->stdProfileIdc; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeH265RateControlInfoEXT::safe_VkVideoEncodeH265RateControlInfoEXT( - const VkVideoEncodeH265RateControlInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - flags(in_struct->flags), - gopFrameCount(in_struct->gopFrameCount), - idrPeriod(in_struct->idrPeriod), - consecutiveBFrameCount(in_struct->consecutiveBFrameCount), - subLayerCount(in_struct->subLayerCount) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeH265RateControlInfoEXT::safe_VkVideoEncodeH265RateControlInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT), - pNext(nullptr), - flags(), - gopFrameCount(), - idrPeriod(), - consecutiveBFrameCount(), - subLayerCount() {} - -safe_VkVideoEncodeH265RateControlInfoEXT::safe_VkVideoEncodeH265RateControlInfoEXT( - const safe_VkVideoEncodeH265RateControlInfoEXT& copy_src) { - sType = copy_src.sType; - flags = copy_src.flags; - gopFrameCount = copy_src.gopFrameCount; - idrPeriod = copy_src.idrPeriod; - consecutiveBFrameCount = copy_src.consecutiveBFrameCount; - subLayerCount = copy_src.subLayerCount; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeH265RateControlInfoEXT& safe_VkVideoEncodeH265RateControlInfoEXT::operator=( - const safe_VkVideoEncodeH265RateControlInfoEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - flags = copy_src.flags; - gopFrameCount = copy_src.gopFrameCount; - idrPeriod = copy_src.idrPeriod; - consecutiveBFrameCount = copy_src.consecutiveBFrameCount; - subLayerCount = copy_src.subLayerCount; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeH265RateControlInfoEXT::~safe_VkVideoEncodeH265RateControlInfoEXT() { FreePnextChain(pNext); } - -void safe_VkVideoEncodeH265RateControlInfoEXT::initialize(const VkVideoEncodeH265RateControlInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - flags = in_struct->flags; - gopFrameCount = in_struct->gopFrameCount; - idrPeriod = in_struct->idrPeriod; - consecutiveBFrameCount = in_struct->consecutiveBFrameCount; - subLayerCount = in_struct->subLayerCount; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeH265RateControlInfoEXT::initialize(const safe_VkVideoEncodeH265RateControlInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - flags = copy_src->flags; - gopFrameCount = copy_src->gopFrameCount; - idrPeriod = copy_src->idrPeriod; - consecutiveBFrameCount = copy_src->consecutiveBFrameCount; - subLayerCount = copy_src->subLayerCount; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeH265RateControlLayerInfoEXT::safe_VkVideoEncodeH265RateControlLayerInfoEXT( - const VkVideoEncodeH265RateControlLayerInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - useMinQp(in_struct->useMinQp), - minQp(in_struct->minQp), - useMaxQp(in_struct->useMaxQp), - maxQp(in_struct->maxQp), - useMaxFrameSize(in_struct->useMaxFrameSize), - maxFrameSize(in_struct->maxFrameSize) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeH265RateControlLayerInfoEXT::safe_VkVideoEncodeH265RateControlLayerInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT), - pNext(nullptr), - useMinQp(), - minQp(), - useMaxQp(), - maxQp(), - useMaxFrameSize(), - maxFrameSize() {} - -safe_VkVideoEncodeH265RateControlLayerInfoEXT::safe_VkVideoEncodeH265RateControlLayerInfoEXT( - const safe_VkVideoEncodeH265RateControlLayerInfoEXT& copy_src) { - sType = copy_src.sType; - useMinQp = copy_src.useMinQp; - minQp = copy_src.minQp; - useMaxQp = copy_src.useMaxQp; - maxQp = copy_src.maxQp; - useMaxFrameSize = copy_src.useMaxFrameSize; - maxFrameSize = copy_src.maxFrameSize; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeH265RateControlLayerInfoEXT& safe_VkVideoEncodeH265RateControlLayerInfoEXT::operator=( - const safe_VkVideoEncodeH265RateControlLayerInfoEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - useMinQp = copy_src.useMinQp; - minQp = copy_src.minQp; - useMaxQp = copy_src.useMaxQp; - maxQp = copy_src.maxQp; - useMaxFrameSize = copy_src.useMaxFrameSize; - maxFrameSize = copy_src.maxFrameSize; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeH265RateControlLayerInfoEXT::~safe_VkVideoEncodeH265RateControlLayerInfoEXT() { FreePnextChain(pNext); } - -void safe_VkVideoEncodeH265RateControlLayerInfoEXT::initialize(const VkVideoEncodeH265RateControlLayerInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - useMinQp = in_struct->useMinQp; - minQp = in_struct->minQp; - useMaxQp = in_struct->useMaxQp; - maxQp = in_struct->maxQp; - useMaxFrameSize = in_struct->useMaxFrameSize; - maxFrameSize = in_struct->maxFrameSize; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeH265RateControlLayerInfoEXT::initialize(const safe_VkVideoEncodeH265RateControlLayerInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - useMinQp = copy_src->useMinQp; - minQp = copy_src->minQp; - useMaxQp = copy_src->useMaxQp; - maxQp = copy_src->maxQp; - useMaxFrameSize = copy_src->useMaxFrameSize; - maxFrameSize = copy_src->maxFrameSize; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkVideoEncodeH265GopRemainingFrameInfoEXT::safe_VkVideoEncodeH265GopRemainingFrameInfoEXT( - const VkVideoEncodeH265GopRemainingFrameInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - useGopRemainingFrames(in_struct->useGopRemainingFrames), - gopRemainingI(in_struct->gopRemainingI), - gopRemainingP(in_struct->gopRemainingP), - gopRemainingB(in_struct->gopRemainingB) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkVideoEncodeH265GopRemainingFrameInfoEXT::safe_VkVideoEncodeH265GopRemainingFrameInfoEXT() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT), - pNext(nullptr), - useGopRemainingFrames(), - gopRemainingI(), - gopRemainingP(), - gopRemainingB() {} - -safe_VkVideoEncodeH265GopRemainingFrameInfoEXT::safe_VkVideoEncodeH265GopRemainingFrameInfoEXT( - const safe_VkVideoEncodeH265GopRemainingFrameInfoEXT& copy_src) { - sType = copy_src.sType; - useGopRemainingFrames = copy_src.useGopRemainingFrames; - gopRemainingI = copy_src.gopRemainingI; - gopRemainingP = copy_src.gopRemainingP; - gopRemainingB = copy_src.gopRemainingB; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkVideoEncodeH265GopRemainingFrameInfoEXT& safe_VkVideoEncodeH265GopRemainingFrameInfoEXT::operator=( - const safe_VkVideoEncodeH265GopRemainingFrameInfoEXT& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - useGopRemainingFrames = copy_src.useGopRemainingFrames; - gopRemainingI = copy_src.gopRemainingI; - gopRemainingP = copy_src.gopRemainingP; - gopRemainingB = copy_src.gopRemainingB; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkVideoEncodeH265GopRemainingFrameInfoEXT::~safe_VkVideoEncodeH265GopRemainingFrameInfoEXT() { FreePnextChain(pNext); } - -void safe_VkVideoEncodeH265GopRemainingFrameInfoEXT::initialize(const VkVideoEncodeH265GopRemainingFrameInfoEXT* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - useGopRemainingFrames = in_struct->useGopRemainingFrames; - gopRemainingI = in_struct->gopRemainingI; - gopRemainingP = in_struct->gopRemainingP; - gopRemainingB = in_struct->gopRemainingB; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkVideoEncodeH265GopRemainingFrameInfoEXT::initialize(const safe_VkVideoEncodeH265GopRemainingFrameInfoEXT* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - useGopRemainingFrames = copy_src->useGopRemainingFrames; - gopRemainingI = copy_src->gopRemainingI; - gopRemainingP = copy_src->gopRemainingP; - gopRemainingB = copy_src->gopRemainingB; - pNext = SafePnextCopy(copy_src->pNext); -} -#endif // VK_ENABLE_BETA_EXTENSIONS safe_VkValidationFlagsEXT::safe_VkValidationFlagsEXT(const VkValidationFlagsEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) diff --git a/layers/vulkan/generated/vk_safe_struct_khr.cpp b/layers/vulkan/generated/vk_safe_struct_khr.cpp index 5ac2465c604..3cda7d99a9c 100644 --- a/layers/vulkan/generated/vk_safe_struct_khr.cpp +++ b/layers/vulkan/generated/vk_safe_struct_khr.cpp @@ -2439,113 +2439,283 @@ void safe_VkVideoDecodeInfoKHR::initialize(const safe_VkVideoDecodeInfoKHR* copy } } -safe_VkVideoDecodeH264ProfileInfoKHR::safe_VkVideoDecodeH264ProfileInfoKHR(const VkVideoDecodeH264ProfileInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), stdProfileIdc(in_struct->stdProfileIdc), pictureLayout(in_struct->pictureLayout) { +safe_VkVideoEncodeH264CapabilitiesKHR::safe_VkVideoEncodeH264CapabilitiesKHR(const VkVideoEncodeH264CapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + maxLevelIdc(in_struct->maxLevelIdc), + maxSliceCount(in_struct->maxSliceCount), + maxPPictureL0ReferenceCount(in_struct->maxPPictureL0ReferenceCount), + maxBPictureL0ReferenceCount(in_struct->maxBPictureL0ReferenceCount), + maxL1ReferenceCount(in_struct->maxL1ReferenceCount), + maxTemporalLayerCount(in_struct->maxTemporalLayerCount), + expectDyadicTemporalLayerPattern(in_struct->expectDyadicTemporalLayerPattern), + minQp(in_struct->minQp), + maxQp(in_struct->maxQp), + prefersGopRemainingFrames(in_struct->prefersGopRemainingFrames), + requiresGopRemainingFrames(in_struct->requiresGopRemainingFrames), + stdSyntaxFlags(in_struct->stdSyntaxFlags) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkVideoDecodeH264ProfileInfoKHR::safe_VkVideoDecodeH264ProfileInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR), pNext(nullptr), stdProfileIdc(), pictureLayout() {} +safe_VkVideoEncodeH264CapabilitiesKHR::safe_VkVideoEncodeH264CapabilitiesKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR), + pNext(nullptr), + flags(), + maxLevelIdc(), + maxSliceCount(), + maxPPictureL0ReferenceCount(), + maxBPictureL0ReferenceCount(), + maxL1ReferenceCount(), + maxTemporalLayerCount(), + expectDyadicTemporalLayerPattern(), + minQp(), + maxQp(), + prefersGopRemainingFrames(), + requiresGopRemainingFrames(), + stdSyntaxFlags() {} + +safe_VkVideoEncodeH264CapabilitiesKHR::safe_VkVideoEncodeH264CapabilitiesKHR( + const safe_VkVideoEncodeH264CapabilitiesKHR& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + maxLevelIdc = copy_src.maxLevelIdc; + maxSliceCount = copy_src.maxSliceCount; + maxPPictureL0ReferenceCount = copy_src.maxPPictureL0ReferenceCount; + maxBPictureL0ReferenceCount = copy_src.maxBPictureL0ReferenceCount; + maxL1ReferenceCount = copy_src.maxL1ReferenceCount; + maxTemporalLayerCount = copy_src.maxTemporalLayerCount; + expectDyadicTemporalLayerPattern = copy_src.expectDyadicTemporalLayerPattern; + minQp = copy_src.minQp; + maxQp = copy_src.maxQp; + prefersGopRemainingFrames = copy_src.prefersGopRemainingFrames; + requiresGopRemainingFrames = copy_src.requiresGopRemainingFrames; + stdSyntaxFlags = copy_src.stdSyntaxFlags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoEncodeH264CapabilitiesKHR& safe_VkVideoEncodeH264CapabilitiesKHR::operator=( + const safe_VkVideoEncodeH264CapabilitiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); -safe_VkVideoDecodeH264ProfileInfoKHR::safe_VkVideoDecodeH264ProfileInfoKHR(const safe_VkVideoDecodeH264ProfileInfoKHR& copy_src) { sType = copy_src.sType; - stdProfileIdc = copy_src.stdProfileIdc; - pictureLayout = copy_src.pictureLayout; + flags = copy_src.flags; + maxLevelIdc = copy_src.maxLevelIdc; + maxSliceCount = copy_src.maxSliceCount; + maxPPictureL0ReferenceCount = copy_src.maxPPictureL0ReferenceCount; + maxBPictureL0ReferenceCount = copy_src.maxBPictureL0ReferenceCount; + maxL1ReferenceCount = copy_src.maxL1ReferenceCount; + maxTemporalLayerCount = copy_src.maxTemporalLayerCount; + expectDyadicTemporalLayerPattern = copy_src.expectDyadicTemporalLayerPattern; + minQp = copy_src.minQp; + maxQp = copy_src.maxQp; + prefersGopRemainingFrames = copy_src.prefersGopRemainingFrames; + requiresGopRemainingFrames = copy_src.requiresGopRemainingFrames; + stdSyntaxFlags = copy_src.stdSyntaxFlags; pNext = SafePnextCopy(copy_src.pNext); + + return *this; } -safe_VkVideoDecodeH264ProfileInfoKHR& safe_VkVideoDecodeH264ProfileInfoKHR::operator=( - const safe_VkVideoDecodeH264ProfileInfoKHR& copy_src) { +safe_VkVideoEncodeH264CapabilitiesKHR::~safe_VkVideoEncodeH264CapabilitiesKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeH264CapabilitiesKHR::initialize(const VkVideoEncodeH264CapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + maxLevelIdc = in_struct->maxLevelIdc; + maxSliceCount = in_struct->maxSliceCount; + maxPPictureL0ReferenceCount = in_struct->maxPPictureL0ReferenceCount; + maxBPictureL0ReferenceCount = in_struct->maxBPictureL0ReferenceCount; + maxL1ReferenceCount = in_struct->maxL1ReferenceCount; + maxTemporalLayerCount = in_struct->maxTemporalLayerCount; + expectDyadicTemporalLayerPattern = in_struct->expectDyadicTemporalLayerPattern; + minQp = in_struct->minQp; + maxQp = in_struct->maxQp; + prefersGopRemainingFrames = in_struct->prefersGopRemainingFrames; + requiresGopRemainingFrames = in_struct->requiresGopRemainingFrames; + stdSyntaxFlags = in_struct->stdSyntaxFlags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoEncodeH264CapabilitiesKHR::initialize(const safe_VkVideoEncodeH264CapabilitiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + maxLevelIdc = copy_src->maxLevelIdc; + maxSliceCount = copy_src->maxSliceCount; + maxPPictureL0ReferenceCount = copy_src->maxPPictureL0ReferenceCount; + maxBPictureL0ReferenceCount = copy_src->maxBPictureL0ReferenceCount; + maxL1ReferenceCount = copy_src->maxL1ReferenceCount; + maxTemporalLayerCount = copy_src->maxTemporalLayerCount; + expectDyadicTemporalLayerPattern = copy_src->expectDyadicTemporalLayerPattern; + minQp = copy_src->minQp; + maxQp = copy_src->maxQp; + prefersGopRemainingFrames = copy_src->prefersGopRemainingFrames; + requiresGopRemainingFrames = copy_src->requiresGopRemainingFrames; + stdSyntaxFlags = copy_src->stdSyntaxFlags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoEncodeH264QualityLevelPropertiesKHR::safe_VkVideoEncodeH264QualityLevelPropertiesKHR( + const VkVideoEncodeH264QualityLevelPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + preferredRateControlFlags(in_struct->preferredRateControlFlags), + preferredGopFrameCount(in_struct->preferredGopFrameCount), + preferredIdrPeriod(in_struct->preferredIdrPeriod), + preferredConsecutiveBFrameCount(in_struct->preferredConsecutiveBFrameCount), + preferredTemporalLayerCount(in_struct->preferredTemporalLayerCount), + preferredConstantQp(in_struct->preferredConstantQp), + preferredMaxL0ReferenceCount(in_struct->preferredMaxL0ReferenceCount), + preferredMaxL1ReferenceCount(in_struct->preferredMaxL1ReferenceCount), + preferredStdEntropyCodingModeFlag(in_struct->preferredStdEntropyCodingModeFlag) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoEncodeH264QualityLevelPropertiesKHR::safe_VkVideoEncodeH264QualityLevelPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR), + pNext(nullptr), + preferredRateControlFlags(), + preferredGopFrameCount(), + preferredIdrPeriod(), + preferredConsecutiveBFrameCount(), + preferredTemporalLayerCount(), + preferredConstantQp(), + preferredMaxL0ReferenceCount(), + preferredMaxL1ReferenceCount(), + preferredStdEntropyCodingModeFlag() {} + +safe_VkVideoEncodeH264QualityLevelPropertiesKHR::safe_VkVideoEncodeH264QualityLevelPropertiesKHR( + const safe_VkVideoEncodeH264QualityLevelPropertiesKHR& copy_src) { + sType = copy_src.sType; + preferredRateControlFlags = copy_src.preferredRateControlFlags; + preferredGopFrameCount = copy_src.preferredGopFrameCount; + preferredIdrPeriod = copy_src.preferredIdrPeriod; + preferredConsecutiveBFrameCount = copy_src.preferredConsecutiveBFrameCount; + preferredTemporalLayerCount = copy_src.preferredTemporalLayerCount; + preferredConstantQp = copy_src.preferredConstantQp; + preferredMaxL0ReferenceCount = copy_src.preferredMaxL0ReferenceCount; + preferredMaxL1ReferenceCount = copy_src.preferredMaxL1ReferenceCount; + preferredStdEntropyCodingModeFlag = copy_src.preferredStdEntropyCodingModeFlag; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoEncodeH264QualityLevelPropertiesKHR& safe_VkVideoEncodeH264QualityLevelPropertiesKHR::operator=( + const safe_VkVideoEncodeH264QualityLevelPropertiesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - stdProfileIdc = copy_src.stdProfileIdc; - pictureLayout = copy_src.pictureLayout; + preferredRateControlFlags = copy_src.preferredRateControlFlags; + preferredGopFrameCount = copy_src.preferredGopFrameCount; + preferredIdrPeriod = copy_src.preferredIdrPeriod; + preferredConsecutiveBFrameCount = copy_src.preferredConsecutiveBFrameCount; + preferredTemporalLayerCount = copy_src.preferredTemporalLayerCount; + preferredConstantQp = copy_src.preferredConstantQp; + preferredMaxL0ReferenceCount = copy_src.preferredMaxL0ReferenceCount; + preferredMaxL1ReferenceCount = copy_src.preferredMaxL1ReferenceCount; + preferredStdEntropyCodingModeFlag = copy_src.preferredStdEntropyCodingModeFlag; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkVideoDecodeH264ProfileInfoKHR::~safe_VkVideoDecodeH264ProfileInfoKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeH264QualityLevelPropertiesKHR::~safe_VkVideoEncodeH264QualityLevelPropertiesKHR() { FreePnextChain(pNext); } -void safe_VkVideoDecodeH264ProfileInfoKHR::initialize(const VkVideoDecodeH264ProfileInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264QualityLevelPropertiesKHR::initialize(const VkVideoEncodeH264QualityLevelPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - stdProfileIdc = in_struct->stdProfileIdc; - pictureLayout = in_struct->pictureLayout; + preferredRateControlFlags = in_struct->preferredRateControlFlags; + preferredGopFrameCount = in_struct->preferredGopFrameCount; + preferredIdrPeriod = in_struct->preferredIdrPeriod; + preferredConsecutiveBFrameCount = in_struct->preferredConsecutiveBFrameCount; + preferredTemporalLayerCount = in_struct->preferredTemporalLayerCount; + preferredConstantQp = in_struct->preferredConstantQp; + preferredMaxL0ReferenceCount = in_struct->preferredMaxL0ReferenceCount; + preferredMaxL1ReferenceCount = in_struct->preferredMaxL1ReferenceCount; + preferredStdEntropyCodingModeFlag = in_struct->preferredStdEntropyCodingModeFlag; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkVideoDecodeH264ProfileInfoKHR::initialize(const safe_VkVideoDecodeH264ProfileInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264QualityLevelPropertiesKHR::initialize(const safe_VkVideoEncodeH264QualityLevelPropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - stdProfileIdc = copy_src->stdProfileIdc; - pictureLayout = copy_src->pictureLayout; + preferredRateControlFlags = copy_src->preferredRateControlFlags; + preferredGopFrameCount = copy_src->preferredGopFrameCount; + preferredIdrPeriod = copy_src->preferredIdrPeriod; + preferredConsecutiveBFrameCount = copy_src->preferredConsecutiveBFrameCount; + preferredTemporalLayerCount = copy_src->preferredTemporalLayerCount; + preferredConstantQp = copy_src->preferredConstantQp; + preferredMaxL0ReferenceCount = copy_src->preferredMaxL0ReferenceCount; + preferredMaxL1ReferenceCount = copy_src->preferredMaxL1ReferenceCount; + preferredStdEntropyCodingModeFlag = copy_src->preferredStdEntropyCodingModeFlag; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkVideoDecodeH264CapabilitiesKHR::safe_VkVideoDecodeH264CapabilitiesKHR(const VkVideoDecodeH264CapabilitiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), maxLevelIdc(in_struct->maxLevelIdc), fieldOffsetGranularity(in_struct->fieldOffsetGranularity) { +safe_VkVideoEncodeH264SessionCreateInfoKHR::safe_VkVideoEncodeH264SessionCreateInfoKHR( + const VkVideoEncodeH264SessionCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), useMaxLevelIdc(in_struct->useMaxLevelIdc), maxLevelIdc(in_struct->maxLevelIdc) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkVideoDecodeH264CapabilitiesKHR::safe_VkVideoDecodeH264CapabilitiesKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR), pNext(nullptr), maxLevelIdc(), fieldOffsetGranularity() {} +safe_VkVideoEncodeH264SessionCreateInfoKHR::safe_VkVideoEncodeH264SessionCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR), pNext(nullptr), useMaxLevelIdc(), maxLevelIdc() {} -safe_VkVideoDecodeH264CapabilitiesKHR::safe_VkVideoDecodeH264CapabilitiesKHR( - const safe_VkVideoDecodeH264CapabilitiesKHR& copy_src) { +safe_VkVideoEncodeH264SessionCreateInfoKHR::safe_VkVideoEncodeH264SessionCreateInfoKHR( + const safe_VkVideoEncodeH264SessionCreateInfoKHR& copy_src) { sType = copy_src.sType; + useMaxLevelIdc = copy_src.useMaxLevelIdc; maxLevelIdc = copy_src.maxLevelIdc; - fieldOffsetGranularity = copy_src.fieldOffsetGranularity; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkVideoDecodeH264CapabilitiesKHR& safe_VkVideoDecodeH264CapabilitiesKHR::operator=( - const safe_VkVideoDecodeH264CapabilitiesKHR& copy_src) { +safe_VkVideoEncodeH264SessionCreateInfoKHR& safe_VkVideoEncodeH264SessionCreateInfoKHR::operator=( + const safe_VkVideoEncodeH264SessionCreateInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; + useMaxLevelIdc = copy_src.useMaxLevelIdc; maxLevelIdc = copy_src.maxLevelIdc; - fieldOffsetGranularity = copy_src.fieldOffsetGranularity; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkVideoDecodeH264CapabilitiesKHR::~safe_VkVideoDecodeH264CapabilitiesKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeH264SessionCreateInfoKHR::~safe_VkVideoEncodeH264SessionCreateInfoKHR() { FreePnextChain(pNext); } -void safe_VkVideoDecodeH264CapabilitiesKHR::initialize(const VkVideoDecodeH264CapabilitiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264SessionCreateInfoKHR::initialize(const VkVideoEncodeH264SessionCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; + useMaxLevelIdc = in_struct->useMaxLevelIdc; maxLevelIdc = in_struct->maxLevelIdc; - fieldOffsetGranularity = in_struct->fieldOffsetGranularity; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkVideoDecodeH264CapabilitiesKHR::initialize(const safe_VkVideoDecodeH264CapabilitiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264SessionCreateInfoKHR::initialize(const safe_VkVideoEncodeH264SessionCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; + useMaxLevelIdc = copy_src->useMaxLevelIdc; maxLevelIdc = copy_src->maxLevelIdc; - fieldOffsetGranularity = copy_src->fieldOffsetGranularity; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkVideoDecodeH264SessionParametersAddInfoKHR::safe_VkVideoDecodeH264SessionParametersAddInfoKHR( - const VkVideoDecodeH264SessionParametersAddInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkVideoEncodeH264SessionParametersAddInfoKHR::safe_VkVideoEncodeH264SessionParametersAddInfoKHR( + const VkVideoEncodeH264SessionParametersAddInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), stdSPSCount(in_struct->stdSPSCount), pStdSPSs(nullptr), @@ -2565,16 +2735,16 @@ safe_VkVideoDecodeH264SessionParametersAddInfoKHR::safe_VkVideoDecodeH264Session } } -safe_VkVideoDecodeH264SessionParametersAddInfoKHR::safe_VkVideoDecodeH264SessionParametersAddInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR), +safe_VkVideoEncodeH264SessionParametersAddInfoKHR::safe_VkVideoEncodeH264SessionParametersAddInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR), pNext(nullptr), stdSPSCount(), pStdSPSs(nullptr), stdPPSCount(), pStdPPSs(nullptr) {} -safe_VkVideoDecodeH264SessionParametersAddInfoKHR::safe_VkVideoDecodeH264SessionParametersAddInfoKHR( - const safe_VkVideoDecodeH264SessionParametersAddInfoKHR& copy_src) { +safe_VkVideoEncodeH264SessionParametersAddInfoKHR::safe_VkVideoEncodeH264SessionParametersAddInfoKHR( + const safe_VkVideoEncodeH264SessionParametersAddInfoKHR& copy_src) { sType = copy_src.sType; stdSPSCount = copy_src.stdSPSCount; pStdSPSs = nullptr; @@ -2593,8 +2763,8 @@ safe_VkVideoDecodeH264SessionParametersAddInfoKHR::safe_VkVideoDecodeH264Session } } -safe_VkVideoDecodeH264SessionParametersAddInfoKHR& safe_VkVideoDecodeH264SessionParametersAddInfoKHR::operator=( - const safe_VkVideoDecodeH264SessionParametersAddInfoKHR& copy_src) { +safe_VkVideoEncodeH264SessionParametersAddInfoKHR& safe_VkVideoEncodeH264SessionParametersAddInfoKHR::operator=( + const safe_VkVideoEncodeH264SessionParametersAddInfoKHR& copy_src) { if (©_src == this) return *this; if (pStdSPSs) delete[] pStdSPSs; @@ -2621,13 +2791,13 @@ safe_VkVideoDecodeH264SessionParametersAddInfoKHR& safe_VkVideoDecodeH264Session return *this; } -safe_VkVideoDecodeH264SessionParametersAddInfoKHR::~safe_VkVideoDecodeH264SessionParametersAddInfoKHR() { +safe_VkVideoEncodeH264SessionParametersAddInfoKHR::~safe_VkVideoEncodeH264SessionParametersAddInfoKHR() { if (pStdSPSs) delete[] pStdSPSs; if (pStdPPSs) delete[] pStdPPSs; FreePnextChain(pNext); } -void safe_VkVideoDecodeH264SessionParametersAddInfoKHR::initialize(const VkVideoDecodeH264SessionParametersAddInfoKHR* in_struct, +void safe_VkVideoEncodeH264SessionParametersAddInfoKHR::initialize(const VkVideoEncodeH264SessionParametersAddInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { if (pStdSPSs) delete[] pStdSPSs; if (pStdPPSs) delete[] pStdPPSs; @@ -2650,8 +2820,8 @@ void safe_VkVideoDecodeH264SessionParametersAddInfoKHR::initialize(const VkVideo } } -void safe_VkVideoDecodeH264SessionParametersAddInfoKHR::initialize( - const safe_VkVideoDecodeH264SessionParametersAddInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264SessionParametersAddInfoKHR::initialize( + const safe_VkVideoEncodeH264SessionParametersAddInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; stdSPSCount = copy_src->stdSPSCount; pStdSPSs = nullptr; @@ -2670,8 +2840,8 @@ void safe_VkVideoDecodeH264SessionParametersAddInfoKHR::initialize( } } -safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::safe_VkVideoDecodeH264SessionParametersCreateInfoKHR( - const VkVideoDecodeH264SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::safe_VkVideoEncodeH264SessionParametersCreateInfoKHR( + const VkVideoEncodeH264SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), maxStdSPSCount(in_struct->maxStdSPSCount), maxStdPPSCount(in_struct->maxStdPPSCount), @@ -2680,29 +2850,29 @@ safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::safe_VkVideoDecodeH264Sess pNext = SafePnextCopy(in_struct->pNext, copy_state); } if (in_struct->pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoKHR(in_struct->pParametersAddInfo); + pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoKHR(in_struct->pParametersAddInfo); } -safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::safe_VkVideoDecodeH264SessionParametersCreateInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR), +safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::safe_VkVideoEncodeH264SessionParametersCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR), pNext(nullptr), maxStdSPSCount(), maxStdPPSCount(), pParametersAddInfo(nullptr) {} -safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::safe_VkVideoDecodeH264SessionParametersCreateInfoKHR( - const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& copy_src) { +safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::safe_VkVideoEncodeH264SessionParametersCreateInfoKHR( + const safe_VkVideoEncodeH264SessionParametersCreateInfoKHR& copy_src) { sType = copy_src.sType; maxStdSPSCount = copy_src.maxStdSPSCount; maxStdPPSCount = copy_src.maxStdPPSCount; pParametersAddInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); if (copy_src.pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo); + pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo); } -safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::operator=( - const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& copy_src) { +safe_VkVideoEncodeH264SessionParametersCreateInfoKHR& safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::operator=( + const safe_VkVideoEncodeH264SessionParametersCreateInfoKHR& copy_src) { if (©_src == this) return *this; if (pParametersAddInfo) delete pParametersAddInfo; @@ -2714,18 +2884,18 @@ safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& safe_VkVideoDecodeH264Sess pParametersAddInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); if (copy_src.pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo); + pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo); return *this; } -safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::~safe_VkVideoDecodeH264SessionParametersCreateInfoKHR() { +safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::~safe_VkVideoEncodeH264SessionParametersCreateInfoKHR() { if (pParametersAddInfo) delete pParametersAddInfo; FreePnextChain(pNext); } -void safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::initialize( - const VkVideoDecodeH264SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::initialize( + const VkVideoEncodeH264SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { if (pParametersAddInfo) delete pParametersAddInfo; FreePnextChain(pNext); sType = in_struct->sType; @@ -2734,7074 +2904,9980 @@ void safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::initialize( pParametersAddInfo = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); if (in_struct->pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoKHR(in_struct->pParametersAddInfo); + pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoKHR(in_struct->pParametersAddInfo); } -void safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::initialize( - const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::initialize( + const safe_VkVideoEncodeH264SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; maxStdSPSCount = copy_src->maxStdSPSCount; maxStdPPSCount = copy_src->maxStdPPSCount; pParametersAddInfo = nullptr; pNext = SafePnextCopy(copy_src->pNext); if (copy_src->pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoKHR(*copy_src->pParametersAddInfo); + pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoKHR(*copy_src->pParametersAddInfo); } -safe_VkVideoDecodeH264PictureInfoKHR::safe_VkVideoDecodeH264PictureInfoKHR(const VkVideoDecodeH264PictureInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), pStdPictureInfo(nullptr), sliceCount(in_struct->sliceCount), pSliceOffsets(nullptr) { +safe_VkVideoEncodeH264SessionParametersGetInfoKHR::safe_VkVideoEncodeH264SessionParametersGetInfoKHR( + const VkVideoEncodeH264SessionParametersGetInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + writeStdSPS(in_struct->writeStdSPS), + writeStdPPS(in_struct->writeStdPPS), + stdSPSId(in_struct->stdSPSId), + stdPPSId(in_struct->stdPPSId) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pStdPictureInfo) { - pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*in_struct->pStdPictureInfo); - } - - if (in_struct->pSliceOffsets) { - pSliceOffsets = new uint32_t[in_struct->sliceCount]; - memcpy((void*)pSliceOffsets, (void*)in_struct->pSliceOffsets, sizeof(uint32_t) * in_struct->sliceCount); - } } -safe_VkVideoDecodeH264PictureInfoKHR::safe_VkVideoDecodeH264PictureInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR), +safe_VkVideoEncodeH264SessionParametersGetInfoKHR::safe_VkVideoEncodeH264SessionParametersGetInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR), pNext(nullptr), - pStdPictureInfo(nullptr), - sliceCount(), - pSliceOffsets(nullptr) {} + writeStdSPS(), + writeStdPPS(), + stdSPSId(), + stdPPSId() {} -safe_VkVideoDecodeH264PictureInfoKHR::safe_VkVideoDecodeH264PictureInfoKHR(const safe_VkVideoDecodeH264PictureInfoKHR& copy_src) { +safe_VkVideoEncodeH264SessionParametersGetInfoKHR::safe_VkVideoEncodeH264SessionParametersGetInfoKHR( + const safe_VkVideoEncodeH264SessionParametersGetInfoKHR& copy_src) { sType = copy_src.sType; - pStdPictureInfo = nullptr; - sliceCount = copy_src.sliceCount; - pSliceOffsets = nullptr; + writeStdSPS = copy_src.writeStdSPS; + writeStdPPS = copy_src.writeStdPPS; + stdSPSId = copy_src.stdSPSId; + stdPPSId = copy_src.stdPPSId; pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdPictureInfo) { - pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*copy_src.pStdPictureInfo); - } - - if (copy_src.pSliceOffsets) { - pSliceOffsets = new uint32_t[copy_src.sliceCount]; - memcpy((void*)pSliceOffsets, (void*)copy_src.pSliceOffsets, sizeof(uint32_t) * copy_src.sliceCount); - } } -safe_VkVideoDecodeH264PictureInfoKHR& safe_VkVideoDecodeH264PictureInfoKHR::operator=( - const safe_VkVideoDecodeH264PictureInfoKHR& copy_src) { +safe_VkVideoEncodeH264SessionParametersGetInfoKHR& safe_VkVideoEncodeH264SessionParametersGetInfoKHR::operator=( + const safe_VkVideoEncodeH264SessionParametersGetInfoKHR& copy_src) { if (©_src == this) return *this; - if (pStdPictureInfo) delete pStdPictureInfo; - if (pSliceOffsets) delete[] pSliceOffsets; FreePnextChain(pNext); sType = copy_src.sType; - pStdPictureInfo = nullptr; - sliceCount = copy_src.sliceCount; - pSliceOffsets = nullptr; + writeStdSPS = copy_src.writeStdSPS; + writeStdPPS = copy_src.writeStdPPS; + stdSPSId = copy_src.stdSPSId; + stdPPSId = copy_src.stdPPSId; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pStdPictureInfo) { - pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*copy_src.pStdPictureInfo); - } + return *this; +} - if (copy_src.pSliceOffsets) { - pSliceOffsets = new uint32_t[copy_src.sliceCount]; - memcpy((void*)pSliceOffsets, (void*)copy_src.pSliceOffsets, sizeof(uint32_t) * copy_src.sliceCount); +safe_VkVideoEncodeH264SessionParametersGetInfoKHR::~safe_VkVideoEncodeH264SessionParametersGetInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeH264SessionParametersGetInfoKHR::initialize(const VkVideoEncodeH264SessionParametersGetInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + writeStdSPS = in_struct->writeStdSPS; + writeStdPPS = in_struct->writeStdPPS; + stdSPSId = in_struct->stdSPSId; + stdPPSId = in_struct->stdPPSId; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoEncodeH264SessionParametersGetInfoKHR::initialize( + const safe_VkVideoEncodeH264SessionParametersGetInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + writeStdSPS = copy_src->writeStdSPS; + writeStdPPS = copy_src->writeStdPPS; + stdSPSId = copy_src->stdSPSId; + stdPPSId = copy_src->stdPPSId; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR( + const VkVideoEncodeH264SessionParametersFeedbackInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + hasStdSPSOverrides(in_struct->hasStdSPSOverrides), + hasStdPPSOverrides(in_struct->hasStdPPSOverrides) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); } +} + +safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR), + pNext(nullptr), + hasStdSPSOverrides(), + hasStdPPSOverrides() {} + +safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR( + const safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR& copy_src) { + sType = copy_src.sType; + hasStdSPSOverrides = copy_src.hasStdSPSOverrides; + hasStdPPSOverrides = copy_src.hasStdPPSOverrides; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR& safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::operator=( + const safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + hasStdSPSOverrides = copy_src.hasStdSPSOverrides; + hasStdPPSOverrides = copy_src.hasStdPPSOverrides; + pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkVideoDecodeH264PictureInfoKHR::~safe_VkVideoDecodeH264PictureInfoKHR() { - if (pStdPictureInfo) delete pStdPictureInfo; - if (pSliceOffsets) delete[] pSliceOffsets; +safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::~safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR() { FreePnextChain(pNext); } -void safe_VkVideoDecodeH264PictureInfoKHR::initialize(const VkVideoDecodeH264PictureInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pStdPictureInfo) delete pStdPictureInfo; - if (pSliceOffsets) delete[] pSliceOffsets; +void safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::initialize( + const VkVideoEncodeH264SessionParametersFeedbackInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - pStdPictureInfo = nullptr; - sliceCount = in_struct->sliceCount; - pSliceOffsets = nullptr; + hasStdSPSOverrides = in_struct->hasStdSPSOverrides; + hasStdPPSOverrides = in_struct->hasStdPPSOverrides; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pStdPictureInfo) { - pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*in_struct->pStdPictureInfo); - } - - if (in_struct->pSliceOffsets) { - pSliceOffsets = new uint32_t[in_struct->sliceCount]; - memcpy((void*)pSliceOffsets, (void*)in_struct->pSliceOffsets, sizeof(uint32_t) * in_struct->sliceCount); - } } -void safe_VkVideoDecodeH264PictureInfoKHR::initialize(const safe_VkVideoDecodeH264PictureInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::initialize( + const safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - pStdPictureInfo = nullptr; - sliceCount = copy_src->sliceCount; - pSliceOffsets = nullptr; + hasStdSPSOverrides = copy_src->hasStdSPSOverrides; + hasStdPPSOverrides = copy_src->hasStdPPSOverrides; pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pStdPictureInfo) { - pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*copy_src->pStdPictureInfo); - } - - if (copy_src->pSliceOffsets) { - pSliceOffsets = new uint32_t[copy_src->sliceCount]; - memcpy((void*)pSliceOffsets, (void*)copy_src->pSliceOffsets, sizeof(uint32_t) * copy_src->sliceCount); - } } -safe_VkVideoDecodeH264DpbSlotInfoKHR::safe_VkVideoDecodeH264DpbSlotInfoKHR(const VkVideoDecodeH264DpbSlotInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), pStdReferenceInfo(nullptr) { +safe_VkVideoEncodeH264NaluSliceInfoKHR::safe_VkVideoEncodeH264NaluSliceInfoKHR(const VkVideoEncodeH264NaluSliceInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), constantQp(in_struct->constantQp), pStdSliceHeader(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*in_struct->pStdReferenceInfo); + if (in_struct->pStdSliceHeader) { + pStdSliceHeader = new StdVideoEncodeH264SliceHeader(*in_struct->pStdSliceHeader); } } -safe_VkVideoDecodeH264DpbSlotInfoKHR::safe_VkVideoDecodeH264DpbSlotInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {} +safe_VkVideoEncodeH264NaluSliceInfoKHR::safe_VkVideoEncodeH264NaluSliceInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR), pNext(nullptr), constantQp(), pStdSliceHeader(nullptr) {} -safe_VkVideoDecodeH264DpbSlotInfoKHR::safe_VkVideoDecodeH264DpbSlotInfoKHR(const safe_VkVideoDecodeH264DpbSlotInfoKHR& copy_src) { +safe_VkVideoEncodeH264NaluSliceInfoKHR::safe_VkVideoEncodeH264NaluSliceInfoKHR( + const safe_VkVideoEncodeH264NaluSliceInfoKHR& copy_src) { sType = copy_src.sType; - pStdReferenceInfo = nullptr; + constantQp = copy_src.constantQp; + pStdSliceHeader = nullptr; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*copy_src.pStdReferenceInfo); + if (copy_src.pStdSliceHeader) { + pStdSliceHeader = new StdVideoEncodeH264SliceHeader(*copy_src.pStdSliceHeader); } } -safe_VkVideoDecodeH264DpbSlotInfoKHR& safe_VkVideoDecodeH264DpbSlotInfoKHR::operator=( - const safe_VkVideoDecodeH264DpbSlotInfoKHR& copy_src) { +safe_VkVideoEncodeH264NaluSliceInfoKHR& safe_VkVideoEncodeH264NaluSliceInfoKHR::operator=( + const safe_VkVideoEncodeH264NaluSliceInfoKHR& copy_src) { if (©_src == this) return *this; - if (pStdReferenceInfo) delete pStdReferenceInfo; + if (pStdSliceHeader) delete pStdSliceHeader; FreePnextChain(pNext); sType = copy_src.sType; - pStdReferenceInfo = nullptr; + constantQp = copy_src.constantQp; + pStdSliceHeader = nullptr; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*copy_src.pStdReferenceInfo); + if (copy_src.pStdSliceHeader) { + pStdSliceHeader = new StdVideoEncodeH264SliceHeader(*copy_src.pStdSliceHeader); } return *this; } -safe_VkVideoDecodeH264DpbSlotInfoKHR::~safe_VkVideoDecodeH264DpbSlotInfoKHR() { - if (pStdReferenceInfo) delete pStdReferenceInfo; +safe_VkVideoEncodeH264NaluSliceInfoKHR::~safe_VkVideoEncodeH264NaluSliceInfoKHR() { + if (pStdSliceHeader) delete pStdSliceHeader; FreePnextChain(pNext); } -void safe_VkVideoDecodeH264DpbSlotInfoKHR::initialize(const VkVideoDecodeH264DpbSlotInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pStdReferenceInfo) delete pStdReferenceInfo; +void safe_VkVideoEncodeH264NaluSliceInfoKHR::initialize(const VkVideoEncodeH264NaluSliceInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdSliceHeader) delete pStdSliceHeader; FreePnextChain(pNext); sType = in_struct->sType; - pStdReferenceInfo = nullptr; + constantQp = in_struct->constantQp; + pStdSliceHeader = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (in_struct->pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*in_struct->pStdReferenceInfo); + if (in_struct->pStdSliceHeader) { + pStdSliceHeader = new StdVideoEncodeH264SliceHeader(*in_struct->pStdSliceHeader); } } -void safe_VkVideoDecodeH264DpbSlotInfoKHR::initialize(const safe_VkVideoDecodeH264DpbSlotInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264NaluSliceInfoKHR::initialize(const safe_VkVideoEncodeH264NaluSliceInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - pStdReferenceInfo = nullptr; + constantQp = copy_src->constantQp; + pStdSliceHeader = nullptr; pNext = SafePnextCopy(copy_src->pNext); - if (copy_src->pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*copy_src->pStdReferenceInfo); + if (copy_src->pStdSliceHeader) { + pStdSliceHeader = new StdVideoEncodeH264SliceHeader(*copy_src->pStdSliceHeader); } } -safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR( - const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkVideoEncodeH264PictureInfoKHR::safe_VkVideoEncodeH264PictureInfoKHR(const VkVideoEncodeH264PictureInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) : sType(in_struct->sType), - imageView(in_struct->imageView), - imageLayout(in_struct->imageLayout), - shadingRateAttachmentTexelSize(in_struct->shadingRateAttachmentTexelSize) { + naluSliceEntryCount(in_struct->naluSliceEntryCount), + pNaluSliceEntries(nullptr), + pStdPictureInfo(nullptr), + generatePrefixNalu(in_struct->generatePrefixNalu) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + if (naluSliceEntryCount && in_struct->pNaluSliceEntries) { + pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceInfoKHR[naluSliceEntryCount]; + for (uint32_t i = 0; i < naluSliceEntryCount; ++i) { + pNaluSliceEntries[i].initialize(&in_struct->pNaluSliceEntries[i]); + } + } + + if (in_struct->pStdPictureInfo) { + pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*in_struct->pStdPictureInfo); + } } -safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR() - : sType(VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR), +safe_VkVideoEncodeH264PictureInfoKHR::safe_VkVideoEncodeH264PictureInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR), pNext(nullptr), - imageView(), - imageLayout(), - shadingRateAttachmentTexelSize() {} + naluSliceEntryCount(), + pNaluSliceEntries(nullptr), + pStdPictureInfo(nullptr), + generatePrefixNalu() {} -safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR( - const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src) { +safe_VkVideoEncodeH264PictureInfoKHR::safe_VkVideoEncodeH264PictureInfoKHR(const safe_VkVideoEncodeH264PictureInfoKHR& copy_src) { sType = copy_src.sType; - imageView = copy_src.imageView; - imageLayout = copy_src.imageLayout; - shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize; + naluSliceEntryCount = copy_src.naluSliceEntryCount; + pNaluSliceEntries = nullptr; + pStdPictureInfo = nullptr; + generatePrefixNalu = copy_src.generatePrefixNalu; pNext = SafePnextCopy(copy_src.pNext); + if (naluSliceEntryCount && copy_src.pNaluSliceEntries) { + pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceInfoKHR[naluSliceEntryCount]; + for (uint32_t i = 0; i < naluSliceEntryCount; ++i) { + pNaluSliceEntries[i].initialize(©_src.pNaluSliceEntries[i]); + } + } + + if (copy_src.pStdPictureInfo) { + pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*copy_src.pStdPictureInfo); + } } -safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::operator=( - const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src) { +safe_VkVideoEncodeH264PictureInfoKHR& safe_VkVideoEncodeH264PictureInfoKHR::operator=( + const safe_VkVideoEncodeH264PictureInfoKHR& copy_src) { if (©_src == this) return *this; + if (pNaluSliceEntries) delete[] pNaluSliceEntries; + if (pStdPictureInfo) delete pStdPictureInfo; FreePnextChain(pNext); sType = copy_src.sType; - imageView = copy_src.imageView; - imageLayout = copy_src.imageLayout; - shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize; + naluSliceEntryCount = copy_src.naluSliceEntryCount; + pNaluSliceEntries = nullptr; + pStdPictureInfo = nullptr; + generatePrefixNalu = copy_src.generatePrefixNalu; pNext = SafePnextCopy(copy_src.pNext); + if (naluSliceEntryCount && copy_src.pNaluSliceEntries) { + pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceInfoKHR[naluSliceEntryCount]; + for (uint32_t i = 0; i < naluSliceEntryCount; ++i) { + pNaluSliceEntries[i].initialize(©_src.pNaluSliceEntries[i]); + } + } + + if (copy_src.pStdPictureInfo) { + pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*copy_src.pStdPictureInfo); + } return *this; } -safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::~safe_VkRenderingFragmentShadingRateAttachmentInfoKHR() { +safe_VkVideoEncodeH264PictureInfoKHR::~safe_VkVideoEncodeH264PictureInfoKHR() { + if (pNaluSliceEntries) delete[] pNaluSliceEntries; + if (pStdPictureInfo) delete pStdPictureInfo; FreePnextChain(pNext); } -void safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::initialize( - const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264PictureInfoKHR::initialize(const VkVideoEncodeH264PictureInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pNaluSliceEntries) delete[] pNaluSliceEntries; + if (pStdPictureInfo) delete pStdPictureInfo; FreePnextChain(pNext); sType = in_struct->sType; - imageView = in_struct->imageView; - imageLayout = in_struct->imageLayout; - shadingRateAttachmentTexelSize = in_struct->shadingRateAttachmentTexelSize; + naluSliceEntryCount = in_struct->naluSliceEntryCount; + pNaluSliceEntries = nullptr; + pStdPictureInfo = nullptr; + generatePrefixNalu = in_struct->generatePrefixNalu; pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (naluSliceEntryCount && in_struct->pNaluSliceEntries) { + pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceInfoKHR[naluSliceEntryCount]; + for (uint32_t i = 0; i < naluSliceEntryCount; ++i) { + pNaluSliceEntries[i].initialize(&in_struct->pNaluSliceEntries[i]); + } + } + + if (in_struct->pStdPictureInfo) { + pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*in_struct->pStdPictureInfo); + } } -void safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::initialize( - const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264PictureInfoKHR::initialize(const safe_VkVideoEncodeH264PictureInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - imageView = copy_src->imageView; - imageLayout = copy_src->imageLayout; - shadingRateAttachmentTexelSize = copy_src->shadingRateAttachmentTexelSize; + naluSliceEntryCount = copy_src->naluSliceEntryCount; + pNaluSliceEntries = nullptr; + pStdPictureInfo = nullptr; + generatePrefixNalu = copy_src->generatePrefixNalu; pNext = SafePnextCopy(copy_src->pNext); + if (naluSliceEntryCount && copy_src->pNaluSliceEntries) { + pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceInfoKHR[naluSliceEntryCount]; + for (uint32_t i = 0; i < naluSliceEntryCount; ++i) { + pNaluSliceEntries[i].initialize(©_src->pNaluSliceEntries[i]); + } + } + + if (copy_src->pStdPictureInfo) { + pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*copy_src->pStdPictureInfo); + } } -#ifdef VK_USE_PLATFORM_WIN32_KHR -safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), handleType(in_struct->handleType), handle(in_struct->handle), name(in_struct->name) { +safe_VkVideoEncodeH264DpbSlotInfoKHR::safe_VkVideoEncodeH264DpbSlotInfoKHR(const VkVideoEncodeH264DpbSlotInfoKHR* 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 StdVideoEncodeH264ReferenceInfo(*in_struct->pStdReferenceInfo); + } } -safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR() - : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR), pNext(nullptr), handleType(), handle(), name() {} +safe_VkVideoEncodeH264DpbSlotInfoKHR::safe_VkVideoEncodeH264DpbSlotInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {} -safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR( - const safe_VkImportMemoryWin32HandleInfoKHR& copy_src) { +safe_VkVideoEncodeH264DpbSlotInfoKHR::safe_VkVideoEncodeH264DpbSlotInfoKHR(const safe_VkVideoEncodeH264DpbSlotInfoKHR& copy_src) { sType = copy_src.sType; - handleType = copy_src.handleType; - handle = copy_src.handle; - name = copy_src.name; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoEncodeH264ReferenceInfo(*copy_src.pStdReferenceInfo); + } } -safe_VkImportMemoryWin32HandleInfoKHR& safe_VkImportMemoryWin32HandleInfoKHR::operator=( - const safe_VkImportMemoryWin32HandleInfoKHR& copy_src) { +safe_VkVideoEncodeH264DpbSlotInfoKHR& safe_VkVideoEncodeH264DpbSlotInfoKHR::operator=( + const safe_VkVideoEncodeH264DpbSlotInfoKHR& copy_src) { if (©_src == this) return *this; + if (pStdReferenceInfo) delete pStdReferenceInfo; FreePnextChain(pNext); sType = copy_src.sType; - handleType = copy_src.handleType; - handle = copy_src.handle; - name = copy_src.name; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoEncodeH264ReferenceInfo(*copy_src.pStdReferenceInfo); + } + return *this; } -safe_VkImportMemoryWin32HandleInfoKHR::~safe_VkImportMemoryWin32HandleInfoKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeH264DpbSlotInfoKHR::~safe_VkVideoEncodeH264DpbSlotInfoKHR() { + if (pStdReferenceInfo) delete pStdReferenceInfo; + FreePnextChain(pNext); +} -void safe_VkImportMemoryWin32HandleInfoKHR::initialize(const VkImportMemoryWin32HandleInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264DpbSlotInfoKHR::initialize(const VkVideoEncodeH264DpbSlotInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdReferenceInfo) delete pStdReferenceInfo; FreePnextChain(pNext); sType = in_struct->sType; - handleType = in_struct->handleType; - handle = in_struct->handle; - name = in_struct->name; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoEncodeH264ReferenceInfo(*in_struct->pStdReferenceInfo); + } } -void safe_VkImportMemoryWin32HandleInfoKHR::initialize(const safe_VkImportMemoryWin32HandleInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264DpbSlotInfoKHR::initialize(const safe_VkVideoEncodeH264DpbSlotInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - handleType = copy_src->handleType; - handle = copy_src->handle; - name = copy_src->name; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoEncodeH264ReferenceInfo(*copy_src->pStdReferenceInfo); + } } -safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), pAttributes(nullptr), dwAccess(in_struct->dwAccess), name(in_struct->name) { +safe_VkVideoEncodeH264ProfileInfoKHR::safe_VkVideoEncodeH264ProfileInfoKHR(const VkVideoEncodeH264ProfileInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), stdProfileIdc(in_struct->stdProfileIdc) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pAttributes) { - pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes); - } } -safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR() - : sType(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR), pNext(nullptr), pAttributes(nullptr), dwAccess(), name() {} +safe_VkVideoEncodeH264ProfileInfoKHR::safe_VkVideoEncodeH264ProfileInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR), pNext(nullptr), stdProfileIdc() {} -safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR( - const safe_VkExportMemoryWin32HandleInfoKHR& copy_src) { +safe_VkVideoEncodeH264ProfileInfoKHR::safe_VkVideoEncodeH264ProfileInfoKHR(const safe_VkVideoEncodeH264ProfileInfoKHR& copy_src) { sType = copy_src.sType; - pAttributes = nullptr; - dwAccess = copy_src.dwAccess; - name = copy_src.name; + stdProfileIdc = copy_src.stdProfileIdc; pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pAttributes) { - pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes); - } } -safe_VkExportMemoryWin32HandleInfoKHR& safe_VkExportMemoryWin32HandleInfoKHR::operator=( - const safe_VkExportMemoryWin32HandleInfoKHR& copy_src) { +safe_VkVideoEncodeH264ProfileInfoKHR& safe_VkVideoEncodeH264ProfileInfoKHR::operator=( + const safe_VkVideoEncodeH264ProfileInfoKHR& copy_src) { if (©_src == this) return *this; - if (pAttributes) delete pAttributes; FreePnextChain(pNext); sType = copy_src.sType; - pAttributes = nullptr; - dwAccess = copy_src.dwAccess; - name = copy_src.name; + stdProfileIdc = copy_src.stdProfileIdc; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pAttributes) { - pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes); - } - return *this; } -safe_VkExportMemoryWin32HandleInfoKHR::~safe_VkExportMemoryWin32HandleInfoKHR() { - if (pAttributes) delete pAttributes; - FreePnextChain(pNext); -} +safe_VkVideoEncodeH264ProfileInfoKHR::~safe_VkVideoEncodeH264ProfileInfoKHR() { FreePnextChain(pNext); } -void safe_VkExportMemoryWin32HandleInfoKHR::initialize(const VkExportMemoryWin32HandleInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pAttributes) delete pAttributes; +void safe_VkVideoEncodeH264ProfileInfoKHR::initialize(const VkVideoEncodeH264ProfileInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - pAttributes = nullptr; - dwAccess = in_struct->dwAccess; - name = in_struct->name; + stdProfileIdc = in_struct->stdProfileIdc; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pAttributes) { - pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes); - } } -void safe_VkExportMemoryWin32HandleInfoKHR::initialize(const safe_VkExportMemoryWin32HandleInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264ProfileInfoKHR::initialize(const safe_VkVideoEncodeH264ProfileInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - pAttributes = nullptr; - dwAccess = copy_src->dwAccess; - name = copy_src->name; + stdProfileIdc = copy_src->stdProfileIdc; pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pAttributes) { - pAttributes = new SECURITY_ATTRIBUTES(*copy_src->pAttributes); - } } -safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), memoryTypeBits(in_struct->memoryTypeBits) { +safe_VkVideoEncodeH264RateControlInfoKHR::safe_VkVideoEncodeH264RateControlInfoKHR( + const VkVideoEncodeH264RateControlInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + gopFrameCount(in_struct->gopFrameCount), + idrPeriod(in_struct->idrPeriod), + consecutiveBFrameCount(in_struct->consecutiveBFrameCount), + temporalLayerCount(in_struct->temporalLayerCount) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR() - : sType(VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR), pNext(nullptr), memoryTypeBits() {} +safe_VkVideoEncodeH264RateControlInfoKHR::safe_VkVideoEncodeH264RateControlInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR), + pNext(nullptr), + flags(), + gopFrameCount(), + idrPeriod(), + consecutiveBFrameCount(), + temporalLayerCount() {} -safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR( - const safe_VkMemoryWin32HandlePropertiesKHR& copy_src) { +safe_VkVideoEncodeH264RateControlInfoKHR::safe_VkVideoEncodeH264RateControlInfoKHR( + const safe_VkVideoEncodeH264RateControlInfoKHR& copy_src) { sType = copy_src.sType; - memoryTypeBits = copy_src.memoryTypeBits; + flags = copy_src.flags; + gopFrameCount = copy_src.gopFrameCount; + idrPeriod = copy_src.idrPeriod; + consecutiveBFrameCount = copy_src.consecutiveBFrameCount; + temporalLayerCount = copy_src.temporalLayerCount; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkMemoryWin32HandlePropertiesKHR& safe_VkMemoryWin32HandlePropertiesKHR::operator=( - const safe_VkMemoryWin32HandlePropertiesKHR& copy_src) { +safe_VkVideoEncodeH264RateControlInfoKHR& safe_VkVideoEncodeH264RateControlInfoKHR::operator=( + const safe_VkVideoEncodeH264RateControlInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - memoryTypeBits = copy_src.memoryTypeBits; + flags = copy_src.flags; + gopFrameCount = copy_src.gopFrameCount; + idrPeriod = copy_src.idrPeriod; + consecutiveBFrameCount = copy_src.consecutiveBFrameCount; + temporalLayerCount = copy_src.temporalLayerCount; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkMemoryWin32HandlePropertiesKHR::~safe_VkMemoryWin32HandlePropertiesKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeH264RateControlInfoKHR::~safe_VkVideoEncodeH264RateControlInfoKHR() { FreePnextChain(pNext); } -void safe_VkMemoryWin32HandlePropertiesKHR::initialize(const VkMemoryWin32HandlePropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264RateControlInfoKHR::initialize(const VkVideoEncodeH264RateControlInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - memoryTypeBits = in_struct->memoryTypeBits; + flags = in_struct->flags; + gopFrameCount = in_struct->gopFrameCount; + idrPeriod = in_struct->idrPeriod; + consecutiveBFrameCount = in_struct->consecutiveBFrameCount; + temporalLayerCount = in_struct->temporalLayerCount; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkMemoryWin32HandlePropertiesKHR::initialize(const safe_VkMemoryWin32HandlePropertiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264RateControlInfoKHR::initialize(const safe_VkVideoEncodeH264RateControlInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - memoryTypeBits = copy_src->memoryTypeBits; + flags = copy_src->flags; + gopFrameCount = copy_src->gopFrameCount; + idrPeriod = copy_src->idrPeriod; + consecutiveBFrameCount = copy_src->consecutiveBFrameCount; + temporalLayerCount = copy_src->temporalLayerCount; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), memory(in_struct->memory), handleType(in_struct->handleType) { +safe_VkVideoEncodeH264RateControlLayerInfoKHR::safe_VkVideoEncodeH264RateControlLayerInfoKHR( + const VkVideoEncodeH264RateControlLayerInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + useMinQp(in_struct->useMinQp), + minQp(in_struct->minQp), + useMaxQp(in_struct->useMaxQp), + maxQp(in_struct->maxQp), + useMaxFrameSize(in_struct->useMaxFrameSize), + maxFrameSize(in_struct->maxFrameSize) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR() - : sType(VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR), pNext(nullptr), memory(), handleType() {} +safe_VkVideoEncodeH264RateControlLayerInfoKHR::safe_VkVideoEncodeH264RateControlLayerInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR), + pNext(nullptr), + useMinQp(), + minQp(), + useMaxQp(), + maxQp(), + useMaxFrameSize(), + maxFrameSize() {} -safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR(const safe_VkMemoryGetWin32HandleInfoKHR& copy_src) { +safe_VkVideoEncodeH264RateControlLayerInfoKHR::safe_VkVideoEncodeH264RateControlLayerInfoKHR( + const safe_VkVideoEncodeH264RateControlLayerInfoKHR& copy_src) { sType = copy_src.sType; - memory = copy_src.memory; - handleType = copy_src.handleType; + useMinQp = copy_src.useMinQp; + minQp = copy_src.minQp; + useMaxQp = copy_src.useMaxQp; + maxQp = copy_src.maxQp; + useMaxFrameSize = copy_src.useMaxFrameSize; + maxFrameSize = copy_src.maxFrameSize; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkMemoryGetWin32HandleInfoKHR& safe_VkMemoryGetWin32HandleInfoKHR::operator=( - const safe_VkMemoryGetWin32HandleInfoKHR& copy_src) { +safe_VkVideoEncodeH264RateControlLayerInfoKHR& safe_VkVideoEncodeH264RateControlLayerInfoKHR::operator=( + const safe_VkVideoEncodeH264RateControlLayerInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - memory = copy_src.memory; - handleType = copy_src.handleType; + useMinQp = copy_src.useMinQp; + minQp = copy_src.minQp; + useMaxQp = copy_src.useMaxQp; + maxQp = copy_src.maxQp; + useMaxFrameSize = copy_src.useMaxFrameSize; + maxFrameSize = copy_src.maxFrameSize; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkMemoryGetWin32HandleInfoKHR::~safe_VkMemoryGetWin32HandleInfoKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeH264RateControlLayerInfoKHR::~safe_VkVideoEncodeH264RateControlLayerInfoKHR() { FreePnextChain(pNext); } -void safe_VkMemoryGetWin32HandleInfoKHR::initialize(const VkMemoryGetWin32HandleInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264RateControlLayerInfoKHR::initialize(const VkVideoEncodeH264RateControlLayerInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - memory = in_struct->memory; - handleType = in_struct->handleType; + useMinQp = in_struct->useMinQp; + minQp = in_struct->minQp; + useMaxQp = in_struct->useMaxQp; + maxQp = in_struct->maxQp; + useMaxFrameSize = in_struct->useMaxFrameSize; + maxFrameSize = in_struct->maxFrameSize; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkMemoryGetWin32HandleInfoKHR::initialize(const safe_VkMemoryGetWin32HandleInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264RateControlLayerInfoKHR::initialize(const safe_VkVideoEncodeH264RateControlLayerInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - memory = copy_src->memory; - handleType = copy_src->handleType; + useMinQp = copy_src->useMinQp; + minQp = copy_src->minQp; + useMaxQp = copy_src->useMaxQp; + maxQp = copy_src->maxQp; + useMaxFrameSize = copy_src->useMaxFrameSize; + maxFrameSize = copy_src->maxFrameSize; pNext = SafePnextCopy(copy_src->pNext); } -#endif // VK_USE_PLATFORM_WIN32_KHR -safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), handleType(in_struct->handleType), fd(in_struct->fd) { +safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::safe_VkVideoEncodeH264GopRemainingFrameInfoKHR( + const VkVideoEncodeH264GopRemainingFrameInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + useGopRemainingFrames(in_struct->useGopRemainingFrames), + gopRemainingI(in_struct->gopRemainingI), + gopRemainingP(in_struct->gopRemainingP), + gopRemainingB(in_struct->gopRemainingB) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR() - : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR), pNext(nullptr), handleType(), fd() {} +safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::safe_VkVideoEncodeH264GopRemainingFrameInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR), + pNext(nullptr), + useGopRemainingFrames(), + gopRemainingI(), + gopRemainingP(), + gopRemainingB() {} -safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR(const safe_VkImportMemoryFdInfoKHR& copy_src) { +safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::safe_VkVideoEncodeH264GopRemainingFrameInfoKHR( + const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR& copy_src) { sType = copy_src.sType; - handleType = copy_src.handleType; - fd = copy_src.fd; + useGopRemainingFrames = copy_src.useGopRemainingFrames; + gopRemainingI = copy_src.gopRemainingI; + gopRemainingP = copy_src.gopRemainingP; + gopRemainingB = copy_src.gopRemainingB; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkImportMemoryFdInfoKHR& safe_VkImportMemoryFdInfoKHR::operator=(const safe_VkImportMemoryFdInfoKHR& copy_src) { +safe_VkVideoEncodeH264GopRemainingFrameInfoKHR& safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::operator=( + const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - handleType = copy_src.handleType; - fd = copy_src.fd; + useGopRemainingFrames = copy_src.useGopRemainingFrames; + gopRemainingI = copy_src.gopRemainingI; + gopRemainingP = copy_src.gopRemainingP; + gopRemainingB = copy_src.gopRemainingB; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkImportMemoryFdInfoKHR::~safe_VkImportMemoryFdInfoKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::~safe_VkVideoEncodeH264GopRemainingFrameInfoKHR() { FreePnextChain(pNext); } -void safe_VkImportMemoryFdInfoKHR::initialize(const VkImportMemoryFdInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::initialize(const VkVideoEncodeH264GopRemainingFrameInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - handleType = in_struct->handleType; - fd = in_struct->fd; + useGopRemainingFrames = in_struct->useGopRemainingFrames; + gopRemainingI = in_struct->gopRemainingI; + gopRemainingP = in_struct->gopRemainingP; + gopRemainingB = in_struct->gopRemainingB; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkImportMemoryFdInfoKHR::initialize(const safe_VkImportMemoryFdInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::initialize(const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - handleType = copy_src->handleType; - fd = copy_src->fd; + useGopRemainingFrames = copy_src->useGopRemainingFrames; + gopRemainingI = copy_src->gopRemainingI; + gopRemainingP = copy_src->gopRemainingP; + gopRemainingB = copy_src->gopRemainingB; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), memoryTypeBits(in_struct->memoryTypeBits) { +safe_VkVideoEncodeH265CapabilitiesKHR::safe_VkVideoEncodeH265CapabilitiesKHR(const VkVideoEncodeH265CapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + maxLevelIdc(in_struct->maxLevelIdc), + maxSliceSegmentCount(in_struct->maxSliceSegmentCount), + maxTiles(in_struct->maxTiles), + ctbSizes(in_struct->ctbSizes), + transformBlockSizes(in_struct->transformBlockSizes), + maxPPictureL0ReferenceCount(in_struct->maxPPictureL0ReferenceCount), + maxBPictureL0ReferenceCount(in_struct->maxBPictureL0ReferenceCount), + maxL1ReferenceCount(in_struct->maxL1ReferenceCount), + maxSubLayerCount(in_struct->maxSubLayerCount), + expectDyadicTemporalSubLayerPattern(in_struct->expectDyadicTemporalSubLayerPattern), + minQp(in_struct->minQp), + maxQp(in_struct->maxQp), + prefersGopRemainingFrames(in_struct->prefersGopRemainingFrames), + requiresGopRemainingFrames(in_struct->requiresGopRemainingFrames), + stdSyntaxFlags(in_struct->stdSyntaxFlags) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR() - : sType(VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR), pNext(nullptr), memoryTypeBits() {} +safe_VkVideoEncodeH265CapabilitiesKHR::safe_VkVideoEncodeH265CapabilitiesKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR), + pNext(nullptr), + flags(), + maxLevelIdc(), + maxSliceSegmentCount(), + maxTiles(), + ctbSizes(), + transformBlockSizes(), + maxPPictureL0ReferenceCount(), + maxBPictureL0ReferenceCount(), + maxL1ReferenceCount(), + maxSubLayerCount(), + expectDyadicTemporalSubLayerPattern(), + minQp(), + maxQp(), + prefersGopRemainingFrames(), + requiresGopRemainingFrames(), + stdSyntaxFlags() {} + +safe_VkVideoEncodeH265CapabilitiesKHR::safe_VkVideoEncodeH265CapabilitiesKHR( + const safe_VkVideoEncodeH265CapabilitiesKHR& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + maxLevelIdc = copy_src.maxLevelIdc; + maxSliceSegmentCount = copy_src.maxSliceSegmentCount; + maxTiles = copy_src.maxTiles; + ctbSizes = copy_src.ctbSizes; + transformBlockSizes = copy_src.transformBlockSizes; + maxPPictureL0ReferenceCount = copy_src.maxPPictureL0ReferenceCount; + maxBPictureL0ReferenceCount = copy_src.maxBPictureL0ReferenceCount; + maxL1ReferenceCount = copy_src.maxL1ReferenceCount; + maxSubLayerCount = copy_src.maxSubLayerCount; + expectDyadicTemporalSubLayerPattern = copy_src.expectDyadicTemporalSubLayerPattern; + minQp = copy_src.minQp; + maxQp = copy_src.maxQp; + prefersGopRemainingFrames = copy_src.prefersGopRemainingFrames; + requiresGopRemainingFrames = copy_src.requiresGopRemainingFrames; + stdSyntaxFlags = copy_src.stdSyntaxFlags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoEncodeH265CapabilitiesKHR& safe_VkVideoEncodeH265CapabilitiesKHR::operator=( + const safe_VkVideoEncodeH265CapabilitiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); -safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR(const safe_VkMemoryFdPropertiesKHR& copy_src) { sType = copy_src.sType; - memoryTypeBits = copy_src.memoryTypeBits; + flags = copy_src.flags; + maxLevelIdc = copy_src.maxLevelIdc; + maxSliceSegmentCount = copy_src.maxSliceSegmentCount; + maxTiles = copy_src.maxTiles; + ctbSizes = copy_src.ctbSizes; + transformBlockSizes = copy_src.transformBlockSizes; + maxPPictureL0ReferenceCount = copy_src.maxPPictureL0ReferenceCount; + maxBPictureL0ReferenceCount = copy_src.maxBPictureL0ReferenceCount; + maxL1ReferenceCount = copy_src.maxL1ReferenceCount; + maxSubLayerCount = copy_src.maxSubLayerCount; + expectDyadicTemporalSubLayerPattern = copy_src.expectDyadicTemporalSubLayerPattern; + minQp = copy_src.minQp; + maxQp = copy_src.maxQp; + prefersGopRemainingFrames = copy_src.prefersGopRemainingFrames; + requiresGopRemainingFrames = copy_src.requiresGopRemainingFrames; + stdSyntaxFlags = copy_src.stdSyntaxFlags; pNext = SafePnextCopy(copy_src.pNext); + + return *this; } -safe_VkMemoryFdPropertiesKHR& safe_VkMemoryFdPropertiesKHR::operator=(const safe_VkMemoryFdPropertiesKHR& copy_src) { +safe_VkVideoEncodeH265CapabilitiesKHR::~safe_VkVideoEncodeH265CapabilitiesKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeH265CapabilitiesKHR::initialize(const VkVideoEncodeH265CapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + maxLevelIdc = in_struct->maxLevelIdc; + maxSliceSegmentCount = in_struct->maxSliceSegmentCount; + maxTiles = in_struct->maxTiles; + ctbSizes = in_struct->ctbSizes; + transformBlockSizes = in_struct->transformBlockSizes; + maxPPictureL0ReferenceCount = in_struct->maxPPictureL0ReferenceCount; + maxBPictureL0ReferenceCount = in_struct->maxBPictureL0ReferenceCount; + maxL1ReferenceCount = in_struct->maxL1ReferenceCount; + maxSubLayerCount = in_struct->maxSubLayerCount; + expectDyadicTemporalSubLayerPattern = in_struct->expectDyadicTemporalSubLayerPattern; + minQp = in_struct->minQp; + maxQp = in_struct->maxQp; + prefersGopRemainingFrames = in_struct->prefersGopRemainingFrames; + requiresGopRemainingFrames = in_struct->requiresGopRemainingFrames; + stdSyntaxFlags = in_struct->stdSyntaxFlags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoEncodeH265CapabilitiesKHR::initialize(const safe_VkVideoEncodeH265CapabilitiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + maxLevelIdc = copy_src->maxLevelIdc; + maxSliceSegmentCount = copy_src->maxSliceSegmentCount; + maxTiles = copy_src->maxTiles; + ctbSizes = copy_src->ctbSizes; + transformBlockSizes = copy_src->transformBlockSizes; + maxPPictureL0ReferenceCount = copy_src->maxPPictureL0ReferenceCount; + maxBPictureL0ReferenceCount = copy_src->maxBPictureL0ReferenceCount; + maxL1ReferenceCount = copy_src->maxL1ReferenceCount; + maxSubLayerCount = copy_src->maxSubLayerCount; + expectDyadicTemporalSubLayerPattern = copy_src->expectDyadicTemporalSubLayerPattern; + minQp = copy_src->minQp; + maxQp = copy_src->maxQp; + prefersGopRemainingFrames = copy_src->prefersGopRemainingFrames; + requiresGopRemainingFrames = copy_src->requiresGopRemainingFrames; + stdSyntaxFlags = copy_src->stdSyntaxFlags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoEncodeH265SessionCreateInfoKHR::safe_VkVideoEncodeH265SessionCreateInfoKHR( + const VkVideoEncodeH265SessionCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), useMaxLevelIdc(in_struct->useMaxLevelIdc), maxLevelIdc(in_struct->maxLevelIdc) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoEncodeH265SessionCreateInfoKHR::safe_VkVideoEncodeH265SessionCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR), pNext(nullptr), useMaxLevelIdc(), maxLevelIdc() {} + +safe_VkVideoEncodeH265SessionCreateInfoKHR::safe_VkVideoEncodeH265SessionCreateInfoKHR( + const safe_VkVideoEncodeH265SessionCreateInfoKHR& copy_src) { + sType = copy_src.sType; + useMaxLevelIdc = copy_src.useMaxLevelIdc; + maxLevelIdc = copy_src.maxLevelIdc; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoEncodeH265SessionCreateInfoKHR& safe_VkVideoEncodeH265SessionCreateInfoKHR::operator=( + const safe_VkVideoEncodeH265SessionCreateInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - memoryTypeBits = copy_src.memoryTypeBits; + useMaxLevelIdc = copy_src.useMaxLevelIdc; + maxLevelIdc = copy_src.maxLevelIdc; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkMemoryFdPropertiesKHR::~safe_VkMemoryFdPropertiesKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeH265SessionCreateInfoKHR::~safe_VkVideoEncodeH265SessionCreateInfoKHR() { FreePnextChain(pNext); } -void safe_VkMemoryFdPropertiesKHR::initialize(const VkMemoryFdPropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265SessionCreateInfoKHR::initialize(const VkVideoEncodeH265SessionCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - memoryTypeBits = in_struct->memoryTypeBits; + useMaxLevelIdc = in_struct->useMaxLevelIdc; + maxLevelIdc = in_struct->maxLevelIdc; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkMemoryFdPropertiesKHR::initialize(const safe_VkMemoryFdPropertiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265SessionCreateInfoKHR::initialize(const safe_VkVideoEncodeH265SessionCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - memoryTypeBits = copy_src->memoryTypeBits; + useMaxLevelIdc = copy_src->useMaxLevelIdc; + maxLevelIdc = copy_src->maxLevelIdc; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), memory(in_struct->memory), handleType(in_struct->handleType) { +safe_VkVideoEncodeH265QualityLevelPropertiesKHR::safe_VkVideoEncodeH265QualityLevelPropertiesKHR( + const VkVideoEncodeH265QualityLevelPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + preferredRateControlFlags(in_struct->preferredRateControlFlags), + preferredGopFrameCount(in_struct->preferredGopFrameCount), + preferredIdrPeriod(in_struct->preferredIdrPeriod), + preferredConsecutiveBFrameCount(in_struct->preferredConsecutiveBFrameCount), + preferredSubLayerCount(in_struct->preferredSubLayerCount), + preferredConstantQp(in_struct->preferredConstantQp), + preferredMaxL0ReferenceCount(in_struct->preferredMaxL0ReferenceCount), + preferredMaxL1ReferenceCount(in_struct->preferredMaxL1ReferenceCount) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR() - : sType(VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR), pNext(nullptr), memory(), handleType() {} +safe_VkVideoEncodeH265QualityLevelPropertiesKHR::safe_VkVideoEncodeH265QualityLevelPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR), + pNext(nullptr), + preferredRateControlFlags(), + preferredGopFrameCount(), + preferredIdrPeriod(), + preferredConsecutiveBFrameCount(), + preferredSubLayerCount(), + preferredConstantQp(), + preferredMaxL0ReferenceCount(), + preferredMaxL1ReferenceCount() {} -safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR(const safe_VkMemoryGetFdInfoKHR& copy_src) { +safe_VkVideoEncodeH265QualityLevelPropertiesKHR::safe_VkVideoEncodeH265QualityLevelPropertiesKHR( + const safe_VkVideoEncodeH265QualityLevelPropertiesKHR& copy_src) { sType = copy_src.sType; - memory = copy_src.memory; - handleType = copy_src.handleType; + preferredRateControlFlags = copy_src.preferredRateControlFlags; + preferredGopFrameCount = copy_src.preferredGopFrameCount; + preferredIdrPeriod = copy_src.preferredIdrPeriod; + preferredConsecutiveBFrameCount = copy_src.preferredConsecutiveBFrameCount; + preferredSubLayerCount = copy_src.preferredSubLayerCount; + preferredConstantQp = copy_src.preferredConstantQp; + preferredMaxL0ReferenceCount = copy_src.preferredMaxL0ReferenceCount; + preferredMaxL1ReferenceCount = copy_src.preferredMaxL1ReferenceCount; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkMemoryGetFdInfoKHR& safe_VkMemoryGetFdInfoKHR::operator=(const safe_VkMemoryGetFdInfoKHR& copy_src) { +safe_VkVideoEncodeH265QualityLevelPropertiesKHR& safe_VkVideoEncodeH265QualityLevelPropertiesKHR::operator=( + const safe_VkVideoEncodeH265QualityLevelPropertiesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - memory = copy_src.memory; - handleType = copy_src.handleType; + preferredRateControlFlags = copy_src.preferredRateControlFlags; + preferredGopFrameCount = copy_src.preferredGopFrameCount; + preferredIdrPeriod = copy_src.preferredIdrPeriod; + preferredConsecutiveBFrameCount = copy_src.preferredConsecutiveBFrameCount; + preferredSubLayerCount = copy_src.preferredSubLayerCount; + preferredConstantQp = copy_src.preferredConstantQp; + preferredMaxL0ReferenceCount = copy_src.preferredMaxL0ReferenceCount; + preferredMaxL1ReferenceCount = copy_src.preferredMaxL1ReferenceCount; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkMemoryGetFdInfoKHR::~safe_VkMemoryGetFdInfoKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeH265QualityLevelPropertiesKHR::~safe_VkVideoEncodeH265QualityLevelPropertiesKHR() { FreePnextChain(pNext); } -void safe_VkMemoryGetFdInfoKHR::initialize(const VkMemoryGetFdInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265QualityLevelPropertiesKHR::initialize(const VkVideoEncodeH265QualityLevelPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - memory = in_struct->memory; - handleType = in_struct->handleType; + preferredRateControlFlags = in_struct->preferredRateControlFlags; + preferredGopFrameCount = in_struct->preferredGopFrameCount; + preferredIdrPeriod = in_struct->preferredIdrPeriod; + preferredConsecutiveBFrameCount = in_struct->preferredConsecutiveBFrameCount; + preferredSubLayerCount = in_struct->preferredSubLayerCount; + preferredConstantQp = in_struct->preferredConstantQp; + preferredMaxL0ReferenceCount = in_struct->preferredMaxL0ReferenceCount; + preferredMaxL1ReferenceCount = in_struct->preferredMaxL1ReferenceCount; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkMemoryGetFdInfoKHR::initialize(const safe_VkMemoryGetFdInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265QualityLevelPropertiesKHR::initialize(const safe_VkVideoEncodeH265QualityLevelPropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - memory = copy_src->memory; - handleType = copy_src->handleType; + preferredRateControlFlags = copy_src->preferredRateControlFlags; + preferredGopFrameCount = copy_src->preferredGopFrameCount; + preferredIdrPeriod = copy_src->preferredIdrPeriod; + preferredConsecutiveBFrameCount = copy_src->preferredConsecutiveBFrameCount; + preferredSubLayerCount = copy_src->preferredSubLayerCount; + preferredConstantQp = copy_src->preferredConstantQp; + preferredMaxL0ReferenceCount = copy_src->preferredMaxL0ReferenceCount; + preferredMaxL1ReferenceCount = copy_src->preferredMaxL1ReferenceCount; pNext = SafePnextCopy(copy_src->pNext); } -#ifdef VK_USE_PLATFORM_WIN32_KHR -safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR( - const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkVideoEncodeH265SessionParametersAddInfoKHR::safe_VkVideoEncodeH265SessionParametersAddInfoKHR( + const VkVideoEncodeH265SessionParametersAddInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), - acquireCount(in_struct->acquireCount), - pAcquireSyncs(nullptr), - pAcquireKeys(nullptr), - pAcquireTimeouts(nullptr), - releaseCount(in_struct->releaseCount), - pReleaseSyncs(nullptr), - pReleaseKeys(nullptr) { + stdVPSCount(in_struct->stdVPSCount), + pStdVPSs(nullptr), + stdSPSCount(in_struct->stdSPSCount), + pStdSPSs(nullptr), + stdPPSCount(in_struct->stdPPSCount), + pStdPPSs(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (acquireCount && in_struct->pAcquireSyncs) { - pAcquireSyncs = new VkDeviceMemory[acquireCount]; - for (uint32_t i = 0; i < acquireCount; ++i) { - pAcquireSyncs[i] = in_struct->pAcquireSyncs[i]; - } - } - - if (in_struct->pAcquireKeys) { - pAcquireKeys = new uint64_t[in_struct->acquireCount]; - memcpy((void*)pAcquireKeys, (void*)in_struct->pAcquireKeys, sizeof(uint64_t) * in_struct->acquireCount); + if (in_struct->pStdVPSs) { + pStdVPSs = new StdVideoH265VideoParameterSet[in_struct->stdVPSCount]; + memcpy((void*)pStdVPSs, (void*)in_struct->pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * in_struct->stdVPSCount); } - if (in_struct->pAcquireTimeouts) { - pAcquireTimeouts = new uint32_t[in_struct->acquireCount]; - memcpy((void*)pAcquireTimeouts, (void*)in_struct->pAcquireTimeouts, sizeof(uint32_t) * in_struct->acquireCount); - } - if (releaseCount && in_struct->pReleaseSyncs) { - pReleaseSyncs = new VkDeviceMemory[releaseCount]; - for (uint32_t i = 0; i < releaseCount; ++i) { - pReleaseSyncs[i] = in_struct->pReleaseSyncs[i]; - } + if (in_struct->pStdSPSs) { + pStdSPSs = new StdVideoH265SequenceParameterSet[in_struct->stdSPSCount]; + memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * in_struct->stdSPSCount); } - if (in_struct->pReleaseKeys) { - pReleaseKeys = new uint64_t[in_struct->releaseCount]; - memcpy((void*)pReleaseKeys, (void*)in_struct->pReleaseKeys, sizeof(uint64_t) * in_struct->releaseCount); + if (in_struct->pStdPPSs) { + pStdPPSs = new StdVideoH265PictureParameterSet[in_struct->stdPPSCount]; + memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * in_struct->stdPPSCount); } } -safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR() - : sType(VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR), +safe_VkVideoEncodeH265SessionParametersAddInfoKHR::safe_VkVideoEncodeH265SessionParametersAddInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR), pNext(nullptr), - acquireCount(), - pAcquireSyncs(nullptr), - pAcquireKeys(nullptr), - pAcquireTimeouts(nullptr), - releaseCount(), - pReleaseSyncs(nullptr), - pReleaseKeys(nullptr) {} + stdVPSCount(), + pStdVPSs(nullptr), + stdSPSCount(), + pStdSPSs(nullptr), + stdPPSCount(), + pStdPPSs(nullptr) {} -safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR( - const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src) { +safe_VkVideoEncodeH265SessionParametersAddInfoKHR::safe_VkVideoEncodeH265SessionParametersAddInfoKHR( + const safe_VkVideoEncodeH265SessionParametersAddInfoKHR& copy_src) { sType = copy_src.sType; - acquireCount = copy_src.acquireCount; - pAcquireSyncs = nullptr; - pAcquireKeys = nullptr; - pAcquireTimeouts = nullptr; - releaseCount = copy_src.releaseCount; - pReleaseSyncs = nullptr; - pReleaseKeys = nullptr; + stdVPSCount = copy_src.stdVPSCount; + pStdVPSs = nullptr; + stdSPSCount = copy_src.stdSPSCount; + pStdSPSs = nullptr; + stdPPSCount = copy_src.stdPPSCount; + pStdPPSs = nullptr; pNext = SafePnextCopy(copy_src.pNext); - if (acquireCount && copy_src.pAcquireSyncs) { - pAcquireSyncs = new VkDeviceMemory[acquireCount]; - for (uint32_t i = 0; i < acquireCount; ++i) { - pAcquireSyncs[i] = copy_src.pAcquireSyncs[i]; - } - } - if (copy_src.pAcquireKeys) { - pAcquireKeys = new uint64_t[copy_src.acquireCount]; - memcpy((void*)pAcquireKeys, (void*)copy_src.pAcquireKeys, sizeof(uint64_t) * copy_src.acquireCount); + if (copy_src.pStdVPSs) { + pStdVPSs = new StdVideoH265VideoParameterSet[copy_src.stdVPSCount]; + memcpy((void*)pStdVPSs, (void*)copy_src.pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * copy_src.stdVPSCount); } - if (copy_src.pAcquireTimeouts) { - pAcquireTimeouts = new uint32_t[copy_src.acquireCount]; - memcpy((void*)pAcquireTimeouts, (void*)copy_src.pAcquireTimeouts, sizeof(uint32_t) * copy_src.acquireCount); - } - if (releaseCount && copy_src.pReleaseSyncs) { - pReleaseSyncs = new VkDeviceMemory[releaseCount]; - for (uint32_t i = 0; i < releaseCount; ++i) { - pReleaseSyncs[i] = copy_src.pReleaseSyncs[i]; - } + if (copy_src.pStdSPSs) { + pStdSPSs = new StdVideoH265SequenceParameterSet[copy_src.stdSPSCount]; + memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * copy_src.stdSPSCount); } - if (copy_src.pReleaseKeys) { - pReleaseKeys = new uint64_t[copy_src.releaseCount]; - memcpy((void*)pReleaseKeys, (void*)copy_src.pReleaseKeys, sizeof(uint64_t) * copy_src.releaseCount); + if (copy_src.pStdPPSs) { + pStdPPSs = new StdVideoH265PictureParameterSet[copy_src.stdPPSCount]; + memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * copy_src.stdPPSCount); } } -safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::operator=( - const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src) { +safe_VkVideoEncodeH265SessionParametersAddInfoKHR& safe_VkVideoEncodeH265SessionParametersAddInfoKHR::operator=( + const safe_VkVideoEncodeH265SessionParametersAddInfoKHR& copy_src) { if (©_src == this) return *this; - if (pAcquireSyncs) delete[] pAcquireSyncs; - if (pAcquireKeys) delete[] pAcquireKeys; - if (pAcquireTimeouts) delete[] pAcquireTimeouts; - if (pReleaseSyncs) delete[] pReleaseSyncs; - if (pReleaseKeys) delete[] pReleaseKeys; + if (pStdVPSs) delete[] pStdVPSs; + if (pStdSPSs) delete[] pStdSPSs; + if (pStdPPSs) delete[] pStdPPSs; FreePnextChain(pNext); sType = copy_src.sType; - acquireCount = copy_src.acquireCount; - pAcquireSyncs = nullptr; - pAcquireKeys = nullptr; - pAcquireTimeouts = nullptr; - releaseCount = copy_src.releaseCount; - pReleaseSyncs = nullptr; - pReleaseKeys = nullptr; + stdVPSCount = copy_src.stdVPSCount; + pStdVPSs = nullptr; + stdSPSCount = copy_src.stdSPSCount; + pStdSPSs = nullptr; + stdPPSCount = copy_src.stdPPSCount; + pStdPPSs = nullptr; pNext = SafePnextCopy(copy_src.pNext); - if (acquireCount && copy_src.pAcquireSyncs) { - pAcquireSyncs = new VkDeviceMemory[acquireCount]; - for (uint32_t i = 0; i < acquireCount; ++i) { - pAcquireSyncs[i] = copy_src.pAcquireSyncs[i]; - } - } - if (copy_src.pAcquireKeys) { - pAcquireKeys = new uint64_t[copy_src.acquireCount]; - memcpy((void*)pAcquireKeys, (void*)copy_src.pAcquireKeys, sizeof(uint64_t) * copy_src.acquireCount); + if (copy_src.pStdVPSs) { + pStdVPSs = new StdVideoH265VideoParameterSet[copy_src.stdVPSCount]; + memcpy((void*)pStdVPSs, (void*)copy_src.pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * copy_src.stdVPSCount); } - if (copy_src.pAcquireTimeouts) { - pAcquireTimeouts = new uint32_t[copy_src.acquireCount]; - memcpy((void*)pAcquireTimeouts, (void*)copy_src.pAcquireTimeouts, sizeof(uint32_t) * copy_src.acquireCount); - } - if (releaseCount && copy_src.pReleaseSyncs) { - pReleaseSyncs = new VkDeviceMemory[releaseCount]; - for (uint32_t i = 0; i < releaseCount; ++i) { - pReleaseSyncs[i] = copy_src.pReleaseSyncs[i]; - } + if (copy_src.pStdSPSs) { + pStdSPSs = new StdVideoH265SequenceParameterSet[copy_src.stdSPSCount]; + memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * copy_src.stdSPSCount); } - if (copy_src.pReleaseKeys) { - pReleaseKeys = new uint64_t[copy_src.releaseCount]; - memcpy((void*)pReleaseKeys, (void*)copy_src.pReleaseKeys, sizeof(uint64_t) * copy_src.releaseCount); + if (copy_src.pStdPPSs) { + pStdPPSs = new StdVideoH265PictureParameterSet[copy_src.stdPPSCount]; + memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * copy_src.stdPPSCount); } return *this; } -safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::~safe_VkWin32KeyedMutexAcquireReleaseInfoKHR() { - if (pAcquireSyncs) delete[] pAcquireSyncs; - if (pAcquireKeys) delete[] pAcquireKeys; - if (pAcquireTimeouts) delete[] pAcquireTimeouts; - if (pReleaseSyncs) delete[] pReleaseSyncs; - if (pReleaseKeys) delete[] pReleaseKeys; +safe_VkVideoEncodeH265SessionParametersAddInfoKHR::~safe_VkVideoEncodeH265SessionParametersAddInfoKHR() { + if (pStdVPSs) delete[] pStdVPSs; + if (pStdSPSs) delete[] pStdSPSs; + if (pStdPPSs) delete[] pStdPPSs; FreePnextChain(pNext); } -void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pAcquireSyncs) delete[] pAcquireSyncs; - if (pAcquireKeys) delete[] pAcquireKeys; - if (pAcquireTimeouts) delete[] pAcquireTimeouts; - if (pReleaseSyncs) delete[] pReleaseSyncs; - if (pReleaseKeys) delete[] pReleaseKeys; +void safe_VkVideoEncodeH265SessionParametersAddInfoKHR::initialize(const VkVideoEncodeH265SessionParametersAddInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdVPSs) delete[] pStdVPSs; + if (pStdSPSs) delete[] pStdSPSs; + if (pStdPPSs) delete[] pStdPPSs; FreePnextChain(pNext); sType = in_struct->sType; - acquireCount = in_struct->acquireCount; - pAcquireSyncs = nullptr; - pAcquireKeys = nullptr; - pAcquireTimeouts = nullptr; - releaseCount = in_struct->releaseCount; - pReleaseSyncs = nullptr; - pReleaseKeys = nullptr; + stdVPSCount = in_struct->stdVPSCount; + pStdVPSs = nullptr; + stdSPSCount = in_struct->stdSPSCount; + pStdSPSs = nullptr; + stdPPSCount = in_struct->stdPPSCount; + pStdPPSs = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (acquireCount && in_struct->pAcquireSyncs) { - pAcquireSyncs = new VkDeviceMemory[acquireCount]; - for (uint32_t i = 0; i < acquireCount; ++i) { - pAcquireSyncs[i] = in_struct->pAcquireSyncs[i]; - } - } - if (in_struct->pAcquireKeys) { - pAcquireKeys = new uint64_t[in_struct->acquireCount]; - memcpy((void*)pAcquireKeys, (void*)in_struct->pAcquireKeys, sizeof(uint64_t) * in_struct->acquireCount); + if (in_struct->pStdVPSs) { + pStdVPSs = new StdVideoH265VideoParameterSet[in_struct->stdVPSCount]; + memcpy((void*)pStdVPSs, (void*)in_struct->pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * in_struct->stdVPSCount); } - if (in_struct->pAcquireTimeouts) { - pAcquireTimeouts = new uint32_t[in_struct->acquireCount]; - memcpy((void*)pAcquireTimeouts, (void*)in_struct->pAcquireTimeouts, sizeof(uint32_t) * in_struct->acquireCount); - } - if (releaseCount && in_struct->pReleaseSyncs) { - pReleaseSyncs = new VkDeviceMemory[releaseCount]; - for (uint32_t i = 0; i < releaseCount; ++i) { - pReleaseSyncs[i] = in_struct->pReleaseSyncs[i]; - } + if (in_struct->pStdSPSs) { + pStdSPSs = new StdVideoH265SequenceParameterSet[in_struct->stdSPSCount]; + memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * in_struct->stdSPSCount); } - if (in_struct->pReleaseKeys) { - pReleaseKeys = new uint64_t[in_struct->releaseCount]; - memcpy((void*)pReleaseKeys, (void*)in_struct->pReleaseKeys, sizeof(uint64_t) * in_struct->releaseCount); + if (in_struct->pStdPPSs) { + pStdPPSs = new StdVideoH265PictureParameterSet[in_struct->stdPPSCount]; + memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * in_struct->stdPPSCount); } } -void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265SessionParametersAddInfoKHR::initialize( + const safe_VkVideoEncodeH265SessionParametersAddInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - acquireCount = copy_src->acquireCount; - pAcquireSyncs = nullptr; - pAcquireKeys = nullptr; - pAcquireTimeouts = nullptr; - releaseCount = copy_src->releaseCount; - pReleaseSyncs = nullptr; - pReleaseKeys = nullptr; + stdVPSCount = copy_src->stdVPSCount; + pStdVPSs = nullptr; + stdSPSCount = copy_src->stdSPSCount; + pStdSPSs = nullptr; + stdPPSCount = copy_src->stdPPSCount; + pStdPPSs = nullptr; pNext = SafePnextCopy(copy_src->pNext); - if (acquireCount && copy_src->pAcquireSyncs) { - pAcquireSyncs = new VkDeviceMemory[acquireCount]; - for (uint32_t i = 0; i < acquireCount; ++i) { - pAcquireSyncs[i] = copy_src->pAcquireSyncs[i]; - } - } - if (copy_src->pAcquireKeys) { - pAcquireKeys = new uint64_t[copy_src->acquireCount]; - memcpy((void*)pAcquireKeys, (void*)copy_src->pAcquireKeys, sizeof(uint64_t) * copy_src->acquireCount); + if (copy_src->pStdVPSs) { + pStdVPSs = new StdVideoH265VideoParameterSet[copy_src->stdVPSCount]; + memcpy((void*)pStdVPSs, (void*)copy_src->pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * copy_src->stdVPSCount); } - if (copy_src->pAcquireTimeouts) { - pAcquireTimeouts = new uint32_t[copy_src->acquireCount]; - memcpy((void*)pAcquireTimeouts, (void*)copy_src->pAcquireTimeouts, sizeof(uint32_t) * copy_src->acquireCount); - } - if (releaseCount && copy_src->pReleaseSyncs) { - pReleaseSyncs = new VkDeviceMemory[releaseCount]; - for (uint32_t i = 0; i < releaseCount; ++i) { - pReleaseSyncs[i] = copy_src->pReleaseSyncs[i]; - } + if (copy_src->pStdSPSs) { + pStdSPSs = new StdVideoH265SequenceParameterSet[copy_src->stdSPSCount]; + memcpy((void*)pStdSPSs, (void*)copy_src->pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * copy_src->stdSPSCount); } - if (copy_src->pReleaseKeys) { - pReleaseKeys = new uint64_t[copy_src->releaseCount]; - memcpy((void*)pReleaseKeys, (void*)copy_src->pReleaseKeys, sizeof(uint64_t) * copy_src->releaseCount); + if (copy_src->pStdPPSs) { + pStdPPSs = new StdVideoH265PictureParameterSet[copy_src->stdPPSCount]; + memcpy((void*)pStdPPSs, (void*)copy_src->pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * copy_src->stdPPSCount); } } -safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR( - const VkImportSemaphoreWin32HandleInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::safe_VkVideoEncodeH265SessionParametersCreateInfoKHR( + const VkVideoEncodeH265SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), - semaphore(in_struct->semaphore), - flags(in_struct->flags), - handleType(in_struct->handleType), - handle(in_struct->handle), - name(in_struct->name) { + maxStdVPSCount(in_struct->maxStdVPSCount), + maxStdSPSCount(in_struct->maxStdSPSCount), + maxStdPPSCount(in_struct->maxStdPPSCount), + pParametersAddInfo(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + if (in_struct->pParametersAddInfo) + pParametersAddInfo = new safe_VkVideoEncodeH265SessionParametersAddInfoKHR(in_struct->pParametersAddInfo); } -safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR() - : sType(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR), +safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::safe_VkVideoEncodeH265SessionParametersCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR), pNext(nullptr), - semaphore(), - flags(), - handleType(), - handle(), - name() {} + maxStdVPSCount(), + maxStdSPSCount(), + maxStdPPSCount(), + pParametersAddInfo(nullptr) {} -safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR( - const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src) { +safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::safe_VkVideoEncodeH265SessionParametersCreateInfoKHR( + const safe_VkVideoEncodeH265SessionParametersCreateInfoKHR& copy_src) { sType = copy_src.sType; - semaphore = copy_src.semaphore; - flags = copy_src.flags; - handleType = copy_src.handleType; - handle = copy_src.handle; - name = copy_src.name; + maxStdVPSCount = copy_src.maxStdVPSCount; + maxStdSPSCount = copy_src.maxStdSPSCount; + maxStdPPSCount = copy_src.maxStdPPSCount; + pParametersAddInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pParametersAddInfo) + pParametersAddInfo = new safe_VkVideoEncodeH265SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo); } -safe_VkImportSemaphoreWin32HandleInfoKHR& safe_VkImportSemaphoreWin32HandleInfoKHR::operator=( - const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src) { +safe_VkVideoEncodeH265SessionParametersCreateInfoKHR& safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::operator=( + const safe_VkVideoEncodeH265SessionParametersCreateInfoKHR& copy_src) { if (©_src == this) return *this; + if (pParametersAddInfo) delete pParametersAddInfo; FreePnextChain(pNext); sType = copy_src.sType; - semaphore = copy_src.semaphore; - flags = copy_src.flags; - handleType = copy_src.handleType; - handle = copy_src.handle; - name = copy_src.name; + maxStdVPSCount = copy_src.maxStdVPSCount; + maxStdSPSCount = copy_src.maxStdSPSCount; + maxStdPPSCount = copy_src.maxStdPPSCount; + pParametersAddInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pParametersAddInfo) + pParametersAddInfo = new safe_VkVideoEncodeH265SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo); return *this; } -safe_VkImportSemaphoreWin32HandleInfoKHR::~safe_VkImportSemaphoreWin32HandleInfoKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::~safe_VkVideoEncodeH265SessionParametersCreateInfoKHR() { + if (pParametersAddInfo) delete pParametersAddInfo; + FreePnextChain(pNext); +} -void safe_VkImportSemaphoreWin32HandleInfoKHR::initialize(const VkImportSemaphoreWin32HandleInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::initialize( + const VkVideoEncodeH265SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pParametersAddInfo) delete pParametersAddInfo; FreePnextChain(pNext); sType = in_struct->sType; - semaphore = in_struct->semaphore; - flags = in_struct->flags; - handleType = in_struct->handleType; - handle = in_struct->handle; - name = in_struct->name; + maxStdVPSCount = in_struct->maxStdVPSCount; + maxStdSPSCount = in_struct->maxStdSPSCount; + maxStdPPSCount = in_struct->maxStdPPSCount; + pParametersAddInfo = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (in_struct->pParametersAddInfo) + pParametersAddInfo = new safe_VkVideoEncodeH265SessionParametersAddInfoKHR(in_struct->pParametersAddInfo); } -void safe_VkImportSemaphoreWin32HandleInfoKHR::initialize(const safe_VkImportSemaphoreWin32HandleInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::initialize( + const safe_VkVideoEncodeH265SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - semaphore = copy_src->semaphore; - flags = copy_src->flags; - handleType = copy_src->handleType; - handle = copy_src->handle; - name = copy_src->name; + maxStdVPSCount = copy_src->maxStdVPSCount; + maxStdSPSCount = copy_src->maxStdSPSCount; + maxStdPPSCount = copy_src->maxStdPPSCount; + pParametersAddInfo = nullptr; pNext = SafePnextCopy(copy_src->pNext); + if (copy_src->pParametersAddInfo) + pParametersAddInfo = new safe_VkVideoEncodeH265SessionParametersAddInfoKHR(*copy_src->pParametersAddInfo); } -safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR( - const VkExportSemaphoreWin32HandleInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), pAttributes(nullptr), dwAccess(in_struct->dwAccess), name(in_struct->name) { +safe_VkVideoEncodeH265SessionParametersGetInfoKHR::safe_VkVideoEncodeH265SessionParametersGetInfoKHR( + const VkVideoEncodeH265SessionParametersGetInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + writeStdVPS(in_struct->writeStdVPS), + writeStdSPS(in_struct->writeStdSPS), + writeStdPPS(in_struct->writeStdPPS), + stdVPSId(in_struct->stdVPSId), + stdSPSId(in_struct->stdSPSId), + stdPPSId(in_struct->stdPPSId) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pAttributes) { - pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes); - } } -safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR() - : sType(VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR), pNext(nullptr), pAttributes(nullptr), dwAccess(), name() {} +safe_VkVideoEncodeH265SessionParametersGetInfoKHR::safe_VkVideoEncodeH265SessionParametersGetInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR), + pNext(nullptr), + writeStdVPS(), + writeStdSPS(), + writeStdPPS(), + stdVPSId(), + stdSPSId(), + stdPPSId() {} -safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR( - const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src) { +safe_VkVideoEncodeH265SessionParametersGetInfoKHR::safe_VkVideoEncodeH265SessionParametersGetInfoKHR( + const safe_VkVideoEncodeH265SessionParametersGetInfoKHR& copy_src) { sType = copy_src.sType; - pAttributes = nullptr; - dwAccess = copy_src.dwAccess; - name = copy_src.name; + writeStdVPS = copy_src.writeStdVPS; + writeStdSPS = copy_src.writeStdSPS; + writeStdPPS = copy_src.writeStdPPS; + stdVPSId = copy_src.stdVPSId; + stdSPSId = copy_src.stdSPSId; + stdPPSId = copy_src.stdPPSId; pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pAttributes) { - pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes); - } } -safe_VkExportSemaphoreWin32HandleInfoKHR& safe_VkExportSemaphoreWin32HandleInfoKHR::operator=( - const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src) { +safe_VkVideoEncodeH265SessionParametersGetInfoKHR& safe_VkVideoEncodeH265SessionParametersGetInfoKHR::operator=( + const safe_VkVideoEncodeH265SessionParametersGetInfoKHR& copy_src) { if (©_src == this) return *this; - if (pAttributes) delete pAttributes; FreePnextChain(pNext); sType = copy_src.sType; - pAttributes = nullptr; - dwAccess = copy_src.dwAccess; - name = copy_src.name; + writeStdVPS = copy_src.writeStdVPS; + writeStdSPS = copy_src.writeStdSPS; + writeStdPPS = copy_src.writeStdPPS; + stdVPSId = copy_src.stdVPSId; + stdSPSId = copy_src.stdSPSId; + stdPPSId = copy_src.stdPPSId; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pAttributes) { - pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes); - } - return *this; } -safe_VkExportSemaphoreWin32HandleInfoKHR::~safe_VkExportSemaphoreWin32HandleInfoKHR() { - if (pAttributes) delete pAttributes; - FreePnextChain(pNext); -} +safe_VkVideoEncodeH265SessionParametersGetInfoKHR::~safe_VkVideoEncodeH265SessionParametersGetInfoKHR() { FreePnextChain(pNext); } -void safe_VkExportSemaphoreWin32HandleInfoKHR::initialize(const VkExportSemaphoreWin32HandleInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pAttributes) delete pAttributes; +void safe_VkVideoEncodeH265SessionParametersGetInfoKHR::initialize(const VkVideoEncodeH265SessionParametersGetInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - pAttributes = nullptr; - dwAccess = in_struct->dwAccess; - name = in_struct->name; + writeStdVPS = in_struct->writeStdVPS; + writeStdSPS = in_struct->writeStdSPS; + writeStdPPS = in_struct->writeStdPPS; + stdVPSId = in_struct->stdVPSId; + stdSPSId = in_struct->stdSPSId; + stdPPSId = in_struct->stdPPSId; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pAttributes) { - pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes); - } } -void safe_VkExportSemaphoreWin32HandleInfoKHR::initialize(const safe_VkExportSemaphoreWin32HandleInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265SessionParametersGetInfoKHR::initialize( + const safe_VkVideoEncodeH265SessionParametersGetInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - pAttributes = nullptr; - dwAccess = copy_src->dwAccess; - name = copy_src->name; + writeStdVPS = copy_src->writeStdVPS; + writeStdSPS = copy_src->writeStdSPS; + writeStdPPS = copy_src->writeStdPPS; + stdVPSId = copy_src->stdVPSId; + stdSPSId = copy_src->stdSPSId; + stdPPSId = copy_src->stdPPSId; pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pAttributes) { - pAttributes = new SECURITY_ATTRIBUTES(*copy_src->pAttributes); - } } -safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR( + const VkVideoEncodeH265SessionParametersFeedbackInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) : sType(in_struct->sType), - waitSemaphoreValuesCount(in_struct->waitSemaphoreValuesCount), - pWaitSemaphoreValues(nullptr), - signalSemaphoreValuesCount(in_struct->signalSemaphoreValuesCount), - pSignalSemaphoreValues(nullptr) { + hasStdVPSOverrides(in_struct->hasStdVPSOverrides), + hasStdSPSOverrides(in_struct->hasStdSPSOverrides), + hasStdPPSOverrides(in_struct->hasStdPPSOverrides) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pWaitSemaphoreValues) { - pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValuesCount]; - memcpy((void*)pWaitSemaphoreValues, (void*)in_struct->pWaitSemaphoreValues, - sizeof(uint64_t) * in_struct->waitSemaphoreValuesCount); - } +} - if (in_struct->pSignalSemaphoreValues) { - pSignalSemaphoreValues = new uint64_t[in_struct->signalSemaphoreValuesCount]; - memcpy((void*)pSignalSemaphoreValues, (void*)in_struct->pSignalSemaphoreValues, - sizeof(uint64_t) * in_struct->signalSemaphoreValuesCount); - } -} - -safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR() - : sType(VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR), +safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR), pNext(nullptr), - waitSemaphoreValuesCount(), - pWaitSemaphoreValues(nullptr), - signalSemaphoreValuesCount(), - pSignalSemaphoreValues(nullptr) {} + hasStdVPSOverrides(), + hasStdSPSOverrides(), + hasStdPPSOverrides() {} -safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR(const safe_VkD3D12FenceSubmitInfoKHR& copy_src) { +safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR( + const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR& copy_src) { sType = copy_src.sType; - waitSemaphoreValuesCount = copy_src.waitSemaphoreValuesCount; - pWaitSemaphoreValues = nullptr; - signalSemaphoreValuesCount = copy_src.signalSemaphoreValuesCount; - pSignalSemaphoreValues = nullptr; + hasStdVPSOverrides = copy_src.hasStdVPSOverrides; + hasStdSPSOverrides = copy_src.hasStdSPSOverrides; + hasStdPPSOverrides = copy_src.hasStdPPSOverrides; pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pWaitSemaphoreValues) { - pWaitSemaphoreValues = new uint64_t[copy_src.waitSemaphoreValuesCount]; - memcpy((void*)pWaitSemaphoreValues, (void*)copy_src.pWaitSemaphoreValues, - sizeof(uint64_t) * copy_src.waitSemaphoreValuesCount); - } - - if (copy_src.pSignalSemaphoreValues) { - pSignalSemaphoreValues = new uint64_t[copy_src.signalSemaphoreValuesCount]; - memcpy((void*)pSignalSemaphoreValues, (void*)copy_src.pSignalSemaphoreValues, - sizeof(uint64_t) * copy_src.signalSemaphoreValuesCount); - } } -safe_VkD3D12FenceSubmitInfoKHR& safe_VkD3D12FenceSubmitInfoKHR::operator=(const safe_VkD3D12FenceSubmitInfoKHR& copy_src) { +safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR& safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::operator=( + const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR& copy_src) { if (©_src == this) return *this; - if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues; - if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues; FreePnextChain(pNext); sType = copy_src.sType; - waitSemaphoreValuesCount = copy_src.waitSemaphoreValuesCount; - pWaitSemaphoreValues = nullptr; - signalSemaphoreValuesCount = copy_src.signalSemaphoreValuesCount; - pSignalSemaphoreValues = nullptr; + hasStdVPSOverrides = copy_src.hasStdVPSOverrides; + hasStdSPSOverrides = copy_src.hasStdSPSOverrides; + hasStdPPSOverrides = copy_src.hasStdPPSOverrides; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pWaitSemaphoreValues) { - pWaitSemaphoreValues = new uint64_t[copy_src.waitSemaphoreValuesCount]; - memcpy((void*)pWaitSemaphoreValues, (void*)copy_src.pWaitSemaphoreValues, - sizeof(uint64_t) * copy_src.waitSemaphoreValuesCount); - } - - if (copy_src.pSignalSemaphoreValues) { - pSignalSemaphoreValues = new uint64_t[copy_src.signalSemaphoreValuesCount]; - memcpy((void*)pSignalSemaphoreValues, (void*)copy_src.pSignalSemaphoreValues, - sizeof(uint64_t) * copy_src.signalSemaphoreValuesCount); - } - return *this; } -safe_VkD3D12FenceSubmitInfoKHR::~safe_VkD3D12FenceSubmitInfoKHR() { - if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues; - if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues; +safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::~safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR() { FreePnextChain(pNext); } -void safe_VkD3D12FenceSubmitInfoKHR::initialize(const VkD3D12FenceSubmitInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues; - if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues; +void safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::initialize( + const VkVideoEncodeH265SessionParametersFeedbackInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - waitSemaphoreValuesCount = in_struct->waitSemaphoreValuesCount; - pWaitSemaphoreValues = nullptr; - signalSemaphoreValuesCount = in_struct->signalSemaphoreValuesCount; - pSignalSemaphoreValues = nullptr; + hasStdVPSOverrides = in_struct->hasStdVPSOverrides; + hasStdSPSOverrides = in_struct->hasStdSPSOverrides; + hasStdPPSOverrides = in_struct->hasStdPPSOverrides; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pWaitSemaphoreValues) { - pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValuesCount]; - memcpy((void*)pWaitSemaphoreValues, (void*)in_struct->pWaitSemaphoreValues, - sizeof(uint64_t) * in_struct->waitSemaphoreValuesCount); - } - - if (in_struct->pSignalSemaphoreValues) { - pSignalSemaphoreValues = new uint64_t[in_struct->signalSemaphoreValuesCount]; - memcpy((void*)pSignalSemaphoreValues, (void*)in_struct->pSignalSemaphoreValues, - sizeof(uint64_t) * in_struct->signalSemaphoreValuesCount); - } } -void safe_VkD3D12FenceSubmitInfoKHR::initialize(const safe_VkD3D12FenceSubmitInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::initialize( + const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - waitSemaphoreValuesCount = copy_src->waitSemaphoreValuesCount; - pWaitSemaphoreValues = nullptr; - signalSemaphoreValuesCount = copy_src->signalSemaphoreValuesCount; - pSignalSemaphoreValues = nullptr; + hasStdVPSOverrides = copy_src->hasStdVPSOverrides; + hasStdSPSOverrides = copy_src->hasStdSPSOverrides; + hasStdPPSOverrides = copy_src->hasStdPPSOverrides; pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pWaitSemaphoreValues) { - pWaitSemaphoreValues = new uint64_t[copy_src->waitSemaphoreValuesCount]; - memcpy((void*)pWaitSemaphoreValues, (void*)copy_src->pWaitSemaphoreValues, - sizeof(uint64_t) * copy_src->waitSemaphoreValuesCount); - } - - if (copy_src->pSignalSemaphoreValues) { - pSignalSemaphoreValues = new uint64_t[copy_src->signalSemaphoreValuesCount]; - memcpy((void*)pSignalSemaphoreValues, (void*)copy_src->pSignalSemaphoreValues, - sizeof(uint64_t) * copy_src->signalSemaphoreValuesCount); - } } -safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), semaphore(in_struct->semaphore), handleType(in_struct->handleType) { +safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR( + const VkVideoEncodeH265NaluSliceSegmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), constantQp(in_struct->constantQp), pStdSliceSegmentHeader(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + if (in_struct->pStdSliceSegmentHeader) { + pStdSliceSegmentHeader = new StdVideoEncodeH265SliceSegmentHeader(*in_struct->pStdSliceSegmentHeader); + } } -safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR() - : sType(VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR), pNext(nullptr), semaphore(), handleType() {} +safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR), + pNext(nullptr), + constantQp(), + pStdSliceSegmentHeader(nullptr) {} -safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR( - const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src) { +safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR( + const safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR& copy_src) { sType = copy_src.sType; - semaphore = copy_src.semaphore; - handleType = copy_src.handleType; + constantQp = copy_src.constantQp; + pStdSliceSegmentHeader = nullptr; pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdSliceSegmentHeader) { + pStdSliceSegmentHeader = new StdVideoEncodeH265SliceSegmentHeader(*copy_src.pStdSliceSegmentHeader); + } } -safe_VkSemaphoreGetWin32HandleInfoKHR& safe_VkSemaphoreGetWin32HandleInfoKHR::operator=( - const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src) { +safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR& safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::operator=( + const safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR& copy_src) { if (©_src == this) return *this; + if (pStdSliceSegmentHeader) delete pStdSliceSegmentHeader; FreePnextChain(pNext); sType = copy_src.sType; - semaphore = copy_src.semaphore; - handleType = copy_src.handleType; + constantQp = copy_src.constantQp; + pStdSliceSegmentHeader = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pStdSliceSegmentHeader) { + pStdSliceSegmentHeader = new StdVideoEncodeH265SliceSegmentHeader(*copy_src.pStdSliceSegmentHeader); + } + return *this; } -safe_VkSemaphoreGetWin32HandleInfoKHR::~safe_VkSemaphoreGetWin32HandleInfoKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::~safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR() { + if (pStdSliceSegmentHeader) delete pStdSliceSegmentHeader; + FreePnextChain(pNext); +} -void safe_VkSemaphoreGetWin32HandleInfoKHR::initialize(const VkSemaphoreGetWin32HandleInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::initialize(const VkVideoEncodeH265NaluSliceSegmentInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdSliceSegmentHeader) delete pStdSliceSegmentHeader; FreePnextChain(pNext); sType = in_struct->sType; - semaphore = in_struct->semaphore; - handleType = in_struct->handleType; + constantQp = in_struct->constantQp; + pStdSliceSegmentHeader = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pStdSliceSegmentHeader) { + pStdSliceSegmentHeader = new StdVideoEncodeH265SliceSegmentHeader(*in_struct->pStdSliceSegmentHeader); + } } -void safe_VkSemaphoreGetWin32HandleInfoKHR::initialize(const safe_VkSemaphoreGetWin32HandleInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::initialize(const safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - semaphore = copy_src->semaphore; - handleType = copy_src->handleType; + constantQp = copy_src->constantQp; + pStdSliceSegmentHeader = nullptr; pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdSliceSegmentHeader) { + pStdSliceSegmentHeader = new StdVideoEncodeH265SliceSegmentHeader(*copy_src->pStdSliceSegmentHeader); + } } -#endif // VK_USE_PLATFORM_WIN32_KHR -safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkVideoEncodeH265PictureInfoKHR::safe_VkVideoEncodeH265PictureInfoKHR(const VkVideoEncodeH265PictureInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) : sType(in_struct->sType), - semaphore(in_struct->semaphore), - flags(in_struct->flags), - handleType(in_struct->handleType), - fd(in_struct->fd) { + naluSliceSegmentEntryCount(in_struct->naluSliceSegmentEntryCount), + pNaluSliceSegmentEntries(nullptr), + pStdPictureInfo(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + if (naluSliceSegmentEntryCount && in_struct->pNaluSliceSegmentEntries) { + pNaluSliceSegmentEntries = new safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR[naluSliceSegmentEntryCount]; + for (uint32_t i = 0; i < naluSliceSegmentEntryCount; ++i) { + pNaluSliceSegmentEntries[i].initialize(&in_struct->pNaluSliceSegmentEntries[i]); + } + } + + if (in_struct->pStdPictureInfo) { + pStdPictureInfo = new StdVideoEncodeH265PictureInfo(*in_struct->pStdPictureInfo); + } } -safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR() - : sType(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR), pNext(nullptr), semaphore(), flags(), handleType(), fd() {} +safe_VkVideoEncodeH265PictureInfoKHR::safe_VkVideoEncodeH265PictureInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR), + pNext(nullptr), + naluSliceSegmentEntryCount(), + pNaluSliceSegmentEntries(nullptr), + pStdPictureInfo(nullptr) {} -safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR(const safe_VkImportSemaphoreFdInfoKHR& copy_src) { +safe_VkVideoEncodeH265PictureInfoKHR::safe_VkVideoEncodeH265PictureInfoKHR(const safe_VkVideoEncodeH265PictureInfoKHR& copy_src) { sType = copy_src.sType; - semaphore = copy_src.semaphore; - flags = copy_src.flags; - handleType = copy_src.handleType; - fd = copy_src.fd; + naluSliceSegmentEntryCount = copy_src.naluSliceSegmentEntryCount; + pNaluSliceSegmentEntries = nullptr; + pStdPictureInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (naluSliceSegmentEntryCount && copy_src.pNaluSliceSegmentEntries) { + pNaluSliceSegmentEntries = new safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR[naluSliceSegmentEntryCount]; + for (uint32_t i = 0; i < naluSliceSegmentEntryCount; ++i) { + pNaluSliceSegmentEntries[i].initialize(©_src.pNaluSliceSegmentEntries[i]); + } + } + + if (copy_src.pStdPictureInfo) { + pStdPictureInfo = new StdVideoEncodeH265PictureInfo(*copy_src.pStdPictureInfo); + } } -safe_VkImportSemaphoreFdInfoKHR& safe_VkImportSemaphoreFdInfoKHR::operator=(const safe_VkImportSemaphoreFdInfoKHR& copy_src) { +safe_VkVideoEncodeH265PictureInfoKHR& safe_VkVideoEncodeH265PictureInfoKHR::operator=( + const safe_VkVideoEncodeH265PictureInfoKHR& copy_src) { if (©_src == this) return *this; + if (pNaluSliceSegmentEntries) delete[] pNaluSliceSegmentEntries; + if (pStdPictureInfo) delete pStdPictureInfo; FreePnextChain(pNext); sType = copy_src.sType; - semaphore = copy_src.semaphore; - flags = copy_src.flags; - handleType = copy_src.handleType; - fd = copy_src.fd; + naluSliceSegmentEntryCount = copy_src.naluSliceSegmentEntryCount; + pNaluSliceSegmentEntries = nullptr; + pStdPictureInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (naluSliceSegmentEntryCount && copy_src.pNaluSliceSegmentEntries) { + pNaluSliceSegmentEntries = new safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR[naluSliceSegmentEntryCount]; + for (uint32_t i = 0; i < naluSliceSegmentEntryCount; ++i) { + pNaluSliceSegmentEntries[i].initialize(©_src.pNaluSliceSegmentEntries[i]); + } + } + + if (copy_src.pStdPictureInfo) { + pStdPictureInfo = new StdVideoEncodeH265PictureInfo(*copy_src.pStdPictureInfo); + } return *this; } -safe_VkImportSemaphoreFdInfoKHR::~safe_VkImportSemaphoreFdInfoKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeH265PictureInfoKHR::~safe_VkVideoEncodeH265PictureInfoKHR() { + if (pNaluSliceSegmentEntries) delete[] pNaluSliceSegmentEntries; + if (pStdPictureInfo) delete pStdPictureInfo; + FreePnextChain(pNext); +} -void safe_VkImportSemaphoreFdInfoKHR::initialize(const VkImportSemaphoreFdInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265PictureInfoKHR::initialize(const VkVideoEncodeH265PictureInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pNaluSliceSegmentEntries) delete[] pNaluSliceSegmentEntries; + if (pStdPictureInfo) delete pStdPictureInfo; FreePnextChain(pNext); sType = in_struct->sType; - semaphore = in_struct->semaphore; - flags = in_struct->flags; - handleType = in_struct->handleType; - fd = in_struct->fd; + naluSliceSegmentEntryCount = in_struct->naluSliceSegmentEntryCount; + pNaluSliceSegmentEntries = nullptr; + pStdPictureInfo = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (naluSliceSegmentEntryCount && in_struct->pNaluSliceSegmentEntries) { + pNaluSliceSegmentEntries = new safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR[naluSliceSegmentEntryCount]; + for (uint32_t i = 0; i < naluSliceSegmentEntryCount; ++i) { + pNaluSliceSegmentEntries[i].initialize(&in_struct->pNaluSliceSegmentEntries[i]); + } + } + + if (in_struct->pStdPictureInfo) { + pStdPictureInfo = new StdVideoEncodeH265PictureInfo(*in_struct->pStdPictureInfo); + } } -void safe_VkImportSemaphoreFdInfoKHR::initialize(const safe_VkImportSemaphoreFdInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265PictureInfoKHR::initialize(const safe_VkVideoEncodeH265PictureInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - semaphore = copy_src->semaphore; - flags = copy_src->flags; - handleType = copy_src->handleType; - fd = copy_src->fd; + naluSliceSegmentEntryCount = copy_src->naluSliceSegmentEntryCount; + pNaluSliceSegmentEntries = nullptr; + pStdPictureInfo = nullptr; pNext = SafePnextCopy(copy_src->pNext); + if (naluSliceSegmentEntryCount && copy_src->pNaluSliceSegmentEntries) { + pNaluSliceSegmentEntries = new safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR[naluSliceSegmentEntryCount]; + for (uint32_t i = 0; i < naluSliceSegmentEntryCount; ++i) { + pNaluSliceSegmentEntries[i].initialize(©_src->pNaluSliceSegmentEntries[i]); + } + } + + if (copy_src->pStdPictureInfo) { + pStdPictureInfo = new StdVideoEncodeH265PictureInfo(*copy_src->pStdPictureInfo); + } } -safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), semaphore(in_struct->semaphore), handleType(in_struct->handleType) { +safe_VkVideoEncodeH265DpbSlotInfoKHR::safe_VkVideoEncodeH265DpbSlotInfoKHR(const VkVideoEncodeH265DpbSlotInfoKHR* 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 StdVideoEncodeH265ReferenceInfo(*in_struct->pStdReferenceInfo); + } } -safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR() - : sType(VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR), pNext(nullptr), semaphore(), handleType() {} +safe_VkVideoEncodeH265DpbSlotInfoKHR::safe_VkVideoEncodeH265DpbSlotInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {} -safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR(const safe_VkSemaphoreGetFdInfoKHR& copy_src) { +safe_VkVideoEncodeH265DpbSlotInfoKHR::safe_VkVideoEncodeH265DpbSlotInfoKHR(const safe_VkVideoEncodeH265DpbSlotInfoKHR& copy_src) { sType = copy_src.sType; - semaphore = copy_src.semaphore; - handleType = copy_src.handleType; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoEncodeH265ReferenceInfo(*copy_src.pStdReferenceInfo); + } } -safe_VkSemaphoreGetFdInfoKHR& safe_VkSemaphoreGetFdInfoKHR::operator=(const safe_VkSemaphoreGetFdInfoKHR& copy_src) { +safe_VkVideoEncodeH265DpbSlotInfoKHR& safe_VkVideoEncodeH265DpbSlotInfoKHR::operator=( + const safe_VkVideoEncodeH265DpbSlotInfoKHR& copy_src) { if (©_src == this) return *this; + if (pStdReferenceInfo) delete pStdReferenceInfo; FreePnextChain(pNext); sType = copy_src.sType; - semaphore = copy_src.semaphore; - handleType = copy_src.handleType; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoEncodeH265ReferenceInfo(*copy_src.pStdReferenceInfo); + } + return *this; } -safe_VkSemaphoreGetFdInfoKHR::~safe_VkSemaphoreGetFdInfoKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeH265DpbSlotInfoKHR::~safe_VkVideoEncodeH265DpbSlotInfoKHR() { + if (pStdReferenceInfo) delete pStdReferenceInfo; + FreePnextChain(pNext); +} -void safe_VkSemaphoreGetFdInfoKHR::initialize(const VkSemaphoreGetFdInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265DpbSlotInfoKHR::initialize(const VkVideoEncodeH265DpbSlotInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdReferenceInfo) delete pStdReferenceInfo; FreePnextChain(pNext); sType = in_struct->sType; - semaphore = in_struct->semaphore; - handleType = in_struct->handleType; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoEncodeH265ReferenceInfo(*in_struct->pStdReferenceInfo); + } } -void safe_VkSemaphoreGetFdInfoKHR::initialize(const safe_VkSemaphoreGetFdInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265DpbSlotInfoKHR::initialize(const safe_VkVideoEncodeH265DpbSlotInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - semaphore = copy_src->semaphore; - handleType = copy_src->handleType; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoEncodeH265ReferenceInfo(*copy_src->pStdReferenceInfo); + } } -safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR( - const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), maxPushDescriptors(in_struct->maxPushDescriptors) { +safe_VkVideoEncodeH265ProfileInfoKHR::safe_VkVideoEncodeH265ProfileInfoKHR(const VkVideoEncodeH265ProfileInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), stdProfileIdc(in_struct->stdProfileIdc) { 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_VkVideoEncodeH265ProfileInfoKHR::safe_VkVideoEncodeH265ProfileInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR), pNext(nullptr), stdProfileIdc() {} -safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR( - const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src) { +safe_VkVideoEncodeH265ProfileInfoKHR::safe_VkVideoEncodeH265ProfileInfoKHR(const safe_VkVideoEncodeH265ProfileInfoKHR& copy_src) { sType = copy_src.sType; - maxPushDescriptors = copy_src.maxPushDescriptors; + stdProfileIdc = copy_src.stdProfileIdc; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDevicePushDescriptorPropertiesKHR& safe_VkPhysicalDevicePushDescriptorPropertiesKHR::operator=( - const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src) { +safe_VkVideoEncodeH265ProfileInfoKHR& safe_VkVideoEncodeH265ProfileInfoKHR::operator=( + const safe_VkVideoEncodeH265ProfileInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - maxPushDescriptors = copy_src.maxPushDescriptors; + stdProfileIdc = copy_src.stdProfileIdc; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDevicePushDescriptorPropertiesKHR::~safe_VkPhysicalDevicePushDescriptorPropertiesKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeH265ProfileInfoKHR::~safe_VkVideoEncodeH265ProfileInfoKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265ProfileInfoKHR::initialize(const VkVideoEncodeH265ProfileInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - maxPushDescriptors = in_struct->maxPushDescriptors; + stdProfileIdc = in_struct->stdProfileIdc; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265ProfileInfoKHR::initialize(const safe_VkVideoEncodeH265ProfileInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - maxPushDescriptors = copy_src->maxPushDescriptors; + stdProfileIdc = copy_src->stdProfileIdc; 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) { - pRectangles = new VkRectLayerKHR[in_struct->rectangleCount]; - memcpy((void*)pRectangles, (void*)in_struct->pRectangles, sizeof(VkRectLayerKHR) * in_struct->rectangleCount); +safe_VkVideoEncodeH265RateControlInfoKHR::safe_VkVideoEncodeH265RateControlInfoKHR( + const VkVideoEncodeH265RateControlInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + gopFrameCount(in_struct->gopFrameCount), + idrPeriod(in_struct->idrPeriod), + consecutiveBFrameCount(in_struct->consecutiveBFrameCount), + subLayerCount(in_struct->subLayerCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPresentRegionKHR::safe_VkPresentRegionKHR() : rectangleCount(), pRectangles(nullptr) {} - -safe_VkPresentRegionKHR::safe_VkPresentRegionKHR(const safe_VkPresentRegionKHR& copy_src) { - rectangleCount = copy_src.rectangleCount; - pRectangles = nullptr; +safe_VkVideoEncodeH265RateControlInfoKHR::safe_VkVideoEncodeH265RateControlInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR), + pNext(nullptr), + flags(), + gopFrameCount(), + idrPeriod(), + consecutiveBFrameCount(), + subLayerCount() {} - if (copy_src.pRectangles) { - pRectangles = new VkRectLayerKHR[copy_src.rectangleCount]; - memcpy((void*)pRectangles, (void*)copy_src.pRectangles, sizeof(VkRectLayerKHR) * copy_src.rectangleCount); - } +safe_VkVideoEncodeH265RateControlInfoKHR::safe_VkVideoEncodeH265RateControlInfoKHR( + const safe_VkVideoEncodeH265RateControlInfoKHR& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + gopFrameCount = copy_src.gopFrameCount; + idrPeriod = copy_src.idrPeriod; + consecutiveBFrameCount = copy_src.consecutiveBFrameCount; + subLayerCount = copy_src.subLayerCount; + pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPresentRegionKHR& safe_VkPresentRegionKHR::operator=(const safe_VkPresentRegionKHR& copy_src) { +safe_VkVideoEncodeH265RateControlInfoKHR& safe_VkVideoEncodeH265RateControlInfoKHR::operator=( + const safe_VkVideoEncodeH265RateControlInfoKHR& copy_src) { if (©_src == this) return *this; - if (pRectangles) delete[] pRectangles; - - rectangleCount = copy_src.rectangleCount; - pRectangles = nullptr; + FreePnextChain(pNext); - if (copy_src.pRectangles) { - pRectangles = new VkRectLayerKHR[copy_src.rectangleCount]; - memcpy((void*)pRectangles, (void*)copy_src.pRectangles, sizeof(VkRectLayerKHR) * copy_src.rectangleCount); - } + sType = copy_src.sType; + flags = copy_src.flags; + gopFrameCount = copy_src.gopFrameCount; + idrPeriod = copy_src.idrPeriod; + consecutiveBFrameCount = copy_src.consecutiveBFrameCount; + subLayerCount = copy_src.subLayerCount; + pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPresentRegionKHR::~safe_VkPresentRegionKHR() { - if (pRectangles) delete[] pRectangles; -} - -void safe_VkPresentRegionKHR::initialize(const VkPresentRegionKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - if (pRectangles) delete[] pRectangles; - rectangleCount = in_struct->rectangleCount; - pRectangles = nullptr; +safe_VkVideoEncodeH265RateControlInfoKHR::~safe_VkVideoEncodeH265RateControlInfoKHR() { FreePnextChain(pNext); } - if (in_struct->pRectangles) { - pRectangles = new VkRectLayerKHR[in_struct->rectangleCount]; - memcpy((void*)pRectangles, (void*)in_struct->pRectangles, sizeof(VkRectLayerKHR) * in_struct->rectangleCount); - } +void safe_VkVideoEncodeH265RateControlInfoKHR::initialize(const VkVideoEncodeH265RateControlInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + gopFrameCount = in_struct->gopFrameCount; + idrPeriod = in_struct->idrPeriod; + consecutiveBFrameCount = in_struct->consecutiveBFrameCount; + subLayerCount = in_struct->subLayerCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPresentRegionKHR::initialize(const safe_VkPresentRegionKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - rectangleCount = copy_src->rectangleCount; - pRectangles = nullptr; - - if (copy_src->pRectangles) { - pRectangles = new VkRectLayerKHR[copy_src->rectangleCount]; - memcpy((void*)pRectangles, (void*)copy_src->pRectangles, sizeof(VkRectLayerKHR) * copy_src->rectangleCount); - } +void safe_VkVideoEncodeH265RateControlInfoKHR::initialize(const safe_VkVideoEncodeH265RateControlInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + gopFrameCount = copy_src->gopFrameCount; + idrPeriod = copy_src->idrPeriod; + consecutiveBFrameCount = copy_src->consecutiveBFrameCount; + subLayerCount = copy_src->subLayerCount; + pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR(const VkPresentRegionsKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pRegions(nullptr) { +safe_VkVideoEncodeH265RateControlLayerInfoKHR::safe_VkVideoEncodeH265RateControlLayerInfoKHR( + const VkVideoEncodeH265RateControlLayerInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + useMinQp(in_struct->useMinQp), + minQp(in_struct->minQp), + useMaxQp(in_struct->useMaxQp), + maxQp(in_struct->maxQp), + useMaxFrameSize(in_struct->useMaxFrameSize), + maxFrameSize(in_struct->maxFrameSize) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (swapchainCount && in_struct->pRegions) { - pRegions = new safe_VkPresentRegionKHR[swapchainCount]; - for (uint32_t i = 0; i < swapchainCount; ++i) { - pRegions[i].initialize(&in_struct->pRegions[i]); - } - } } -safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR() - : sType(VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR), pNext(nullptr), swapchainCount(), pRegions(nullptr) {} +safe_VkVideoEncodeH265RateControlLayerInfoKHR::safe_VkVideoEncodeH265RateControlLayerInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR), + pNext(nullptr), + useMinQp(), + minQp(), + useMaxQp(), + maxQp(), + useMaxFrameSize(), + maxFrameSize() {} -safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR(const safe_VkPresentRegionsKHR& copy_src) { +safe_VkVideoEncodeH265RateControlLayerInfoKHR::safe_VkVideoEncodeH265RateControlLayerInfoKHR( + const safe_VkVideoEncodeH265RateControlLayerInfoKHR& copy_src) { sType = copy_src.sType; - swapchainCount = copy_src.swapchainCount; - pRegions = nullptr; + useMinQp = copy_src.useMinQp; + minQp = copy_src.minQp; + useMaxQp = copy_src.useMaxQp; + maxQp = copy_src.maxQp; + useMaxFrameSize = copy_src.useMaxFrameSize; + maxFrameSize = copy_src.maxFrameSize; pNext = SafePnextCopy(copy_src.pNext); - if (swapchainCount && copy_src.pRegions) { - pRegions = new safe_VkPresentRegionKHR[swapchainCount]; - for (uint32_t i = 0; i < swapchainCount; ++i) { - pRegions[i].initialize(©_src.pRegions[i]); - } - } } -safe_VkPresentRegionsKHR& safe_VkPresentRegionsKHR::operator=(const safe_VkPresentRegionsKHR& copy_src) { +safe_VkVideoEncodeH265RateControlLayerInfoKHR& safe_VkVideoEncodeH265RateControlLayerInfoKHR::operator=( + const safe_VkVideoEncodeH265RateControlLayerInfoKHR& copy_src) { if (©_src == this) return *this; - if (pRegions) delete[] pRegions; FreePnextChain(pNext); sType = copy_src.sType; - swapchainCount = copy_src.swapchainCount; - pRegions = nullptr; + useMinQp = copy_src.useMinQp; + minQp = copy_src.minQp; + useMaxQp = copy_src.useMaxQp; + maxQp = copy_src.maxQp; + useMaxFrameSize = copy_src.useMaxFrameSize; + maxFrameSize = copy_src.maxFrameSize; pNext = SafePnextCopy(copy_src.pNext); - if (swapchainCount && copy_src.pRegions) { - pRegions = new safe_VkPresentRegionKHR[swapchainCount]; - for (uint32_t i = 0; i < swapchainCount; ++i) { - pRegions[i].initialize(©_src.pRegions[i]); - } - } return *this; } -safe_VkPresentRegionsKHR::~safe_VkPresentRegionsKHR() { - if (pRegions) delete[] pRegions; - FreePnextChain(pNext); -} +safe_VkVideoEncodeH265RateControlLayerInfoKHR::~safe_VkVideoEncodeH265RateControlLayerInfoKHR() { FreePnextChain(pNext); } -void safe_VkPresentRegionsKHR::initialize(const VkPresentRegionsKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - if (pRegions) delete[] pRegions; +void safe_VkVideoEncodeH265RateControlLayerInfoKHR::initialize(const VkVideoEncodeH265RateControlLayerInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - swapchainCount = in_struct->swapchainCount; - pRegions = nullptr; + useMinQp = in_struct->useMinQp; + minQp = in_struct->minQp; + useMaxQp = in_struct->useMaxQp; + maxQp = in_struct->maxQp; + useMaxFrameSize = in_struct->useMaxFrameSize; + maxFrameSize = in_struct->maxFrameSize; pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (swapchainCount && in_struct->pRegions) { - pRegions = new safe_VkPresentRegionKHR[swapchainCount]; - for (uint32_t i = 0; i < swapchainCount; ++i) { - pRegions[i].initialize(&in_struct->pRegions[i]); - } - } } -void safe_VkPresentRegionsKHR::initialize(const safe_VkPresentRegionsKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265RateControlLayerInfoKHR::initialize(const safe_VkVideoEncodeH265RateControlLayerInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - swapchainCount = copy_src->swapchainCount; - pRegions = nullptr; + useMinQp = copy_src->useMinQp; + minQp = copy_src->minQp; + useMaxQp = copy_src->useMaxQp; + maxQp = copy_src->maxQp; + useMaxFrameSize = copy_src->useMaxFrameSize; + maxFrameSize = copy_src->maxFrameSize; pNext = SafePnextCopy(copy_src->pNext); - if (swapchainCount && copy_src->pRegions) { - pRegions = new safe_VkPresentRegionKHR[swapchainCount]; - for (uint32_t i = 0; i < swapchainCount; ++i) { - pRegions[i].initialize(©_src->pRegions[i]); - } - } } -safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR( - const VkSharedPresentSurfaceCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), sharedPresentSupportedUsageFlags(in_struct->sharedPresentSupportedUsageFlags) { +safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::safe_VkVideoEncodeH265GopRemainingFrameInfoKHR( + const VkVideoEncodeH265GopRemainingFrameInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + useGopRemainingFrames(in_struct->useGopRemainingFrames), + gopRemainingI(in_struct->gopRemainingI), + gopRemainingP(in_struct->gopRemainingP), + gopRemainingB(in_struct->gopRemainingB) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR() - : sType(VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR), pNext(nullptr), sharedPresentSupportedUsageFlags() {} +safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::safe_VkVideoEncodeH265GopRemainingFrameInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR), + pNext(nullptr), + useGopRemainingFrames(), + gopRemainingI(), + gopRemainingP(), + gopRemainingB() {} -safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR( - const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src) { +safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::safe_VkVideoEncodeH265GopRemainingFrameInfoKHR( + const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR& copy_src) { sType = copy_src.sType; - sharedPresentSupportedUsageFlags = copy_src.sharedPresentSupportedUsageFlags; + useGopRemainingFrames = copy_src.useGopRemainingFrames; + gopRemainingI = copy_src.gopRemainingI; + gopRemainingP = copy_src.gopRemainingP; + gopRemainingB = copy_src.gopRemainingB; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkSharedPresentSurfaceCapabilitiesKHR& safe_VkSharedPresentSurfaceCapabilitiesKHR::operator=( - const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src) { +safe_VkVideoEncodeH265GopRemainingFrameInfoKHR& safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::operator=( + const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - sharedPresentSupportedUsageFlags = copy_src.sharedPresentSupportedUsageFlags; + useGopRemainingFrames = copy_src.useGopRemainingFrames; + gopRemainingI = copy_src.gopRemainingI; + gopRemainingP = copy_src.gopRemainingP; + gopRemainingB = copy_src.gopRemainingB; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkSharedPresentSurfaceCapabilitiesKHR::~safe_VkSharedPresentSurfaceCapabilitiesKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::~safe_VkVideoEncodeH265GopRemainingFrameInfoKHR() { FreePnextChain(pNext); } -void safe_VkSharedPresentSurfaceCapabilitiesKHR::initialize(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::initialize(const VkVideoEncodeH265GopRemainingFrameInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - sharedPresentSupportedUsageFlags = in_struct->sharedPresentSupportedUsageFlags; + useGopRemainingFrames = in_struct->useGopRemainingFrames; + gopRemainingI = in_struct->gopRemainingI; + gopRemainingP = in_struct->gopRemainingP; + gopRemainingB = in_struct->gopRemainingB; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkSharedPresentSurfaceCapabilitiesKHR::initialize(const safe_VkSharedPresentSurfaceCapabilitiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::initialize(const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - sharedPresentSupportedUsageFlags = copy_src->sharedPresentSupportedUsageFlags; + useGopRemainingFrames = copy_src->useGopRemainingFrames; + gopRemainingI = copy_src->gopRemainingI; + gopRemainingP = copy_src->gopRemainingP; + gopRemainingB = copy_src->gopRemainingB; pNext = SafePnextCopy(copy_src->pNext); } -#ifdef VK_USE_PLATFORM_WIN32_KHR -safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR* in_struct, +safe_VkVideoDecodeH264ProfileInfoKHR::safe_VkVideoDecodeH264ProfileInfoKHR(const VkVideoDecodeH264ProfileInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - fence(in_struct->fence), - flags(in_struct->flags), - handleType(in_struct->handleType), - handle(in_struct->handle), - name(in_struct->name) { + : sType(in_struct->sType), stdProfileIdc(in_struct->stdProfileIdc), pictureLayout(in_struct->pictureLayout) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR() - : sType(VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR), - pNext(nullptr), - fence(), - flags(), - handleType(), - handle(), - name() {} +safe_VkVideoDecodeH264ProfileInfoKHR::safe_VkVideoDecodeH264ProfileInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR), pNext(nullptr), stdProfileIdc(), pictureLayout() {} -safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR(const safe_VkImportFenceWin32HandleInfoKHR& copy_src) { +safe_VkVideoDecodeH264ProfileInfoKHR::safe_VkVideoDecodeH264ProfileInfoKHR(const safe_VkVideoDecodeH264ProfileInfoKHR& copy_src) { sType = copy_src.sType; - fence = copy_src.fence; - flags = copy_src.flags; - handleType = copy_src.handleType; - handle = copy_src.handle; - name = copy_src.name; + stdProfileIdc = copy_src.stdProfileIdc; + pictureLayout = copy_src.pictureLayout; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkImportFenceWin32HandleInfoKHR& safe_VkImportFenceWin32HandleInfoKHR::operator=( - const safe_VkImportFenceWin32HandleInfoKHR& copy_src) { +safe_VkVideoDecodeH264ProfileInfoKHR& safe_VkVideoDecodeH264ProfileInfoKHR::operator=( + const safe_VkVideoDecodeH264ProfileInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - fence = copy_src.fence; - flags = copy_src.flags; - handleType = copy_src.handleType; - handle = copy_src.handle; - name = copy_src.name; + stdProfileIdc = copy_src.stdProfileIdc; + pictureLayout = copy_src.pictureLayout; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkImportFenceWin32HandleInfoKHR::~safe_VkImportFenceWin32HandleInfoKHR() { FreePnextChain(pNext); } +safe_VkVideoDecodeH264ProfileInfoKHR::~safe_VkVideoDecodeH264ProfileInfoKHR() { FreePnextChain(pNext); } -void safe_VkImportFenceWin32HandleInfoKHR::initialize(const VkImportFenceWin32HandleInfoKHR* in_struct, +void safe_VkVideoDecodeH264ProfileInfoKHR::initialize(const VkVideoDecodeH264ProfileInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - fence = in_struct->fence; - flags = in_struct->flags; - handleType = in_struct->handleType; - handle = in_struct->handle; - name = in_struct->name; + stdProfileIdc = in_struct->stdProfileIdc; + pictureLayout = in_struct->pictureLayout; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkImportFenceWin32HandleInfoKHR::initialize(const safe_VkImportFenceWin32HandleInfoKHR* copy_src, +void safe_VkVideoDecodeH264ProfileInfoKHR::initialize(const safe_VkVideoDecodeH264ProfileInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - fence = copy_src->fence; - flags = copy_src->flags; - handleType = copy_src->handleType; - handle = copy_src->handle; - name = copy_src->name; + stdProfileIdc = copy_src->stdProfileIdc; + pictureLayout = copy_src->pictureLayout; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), pAttributes(nullptr), dwAccess(in_struct->dwAccess), name(in_struct->name) { +safe_VkVideoDecodeH264CapabilitiesKHR::safe_VkVideoDecodeH264CapabilitiesKHR(const VkVideoDecodeH264CapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), maxLevelIdc(in_struct->maxLevelIdc), fieldOffsetGranularity(in_struct->fieldOffsetGranularity) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pAttributes) { - pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes); - } } -safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR() - : sType(VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR), pNext(nullptr), pAttributes(nullptr), dwAccess(), name() {} +safe_VkVideoDecodeH264CapabilitiesKHR::safe_VkVideoDecodeH264CapabilitiesKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR), pNext(nullptr), maxLevelIdc(), fieldOffsetGranularity() {} -safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR(const safe_VkExportFenceWin32HandleInfoKHR& copy_src) { +safe_VkVideoDecodeH264CapabilitiesKHR::safe_VkVideoDecodeH264CapabilitiesKHR( + const safe_VkVideoDecodeH264CapabilitiesKHR& copy_src) { sType = copy_src.sType; - pAttributes = nullptr; - dwAccess = copy_src.dwAccess; - name = copy_src.name; + maxLevelIdc = copy_src.maxLevelIdc; + fieldOffsetGranularity = copy_src.fieldOffsetGranularity; pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pAttributes) { - pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes); - } } -safe_VkExportFenceWin32HandleInfoKHR& safe_VkExportFenceWin32HandleInfoKHR::operator=( - const safe_VkExportFenceWin32HandleInfoKHR& copy_src) { +safe_VkVideoDecodeH264CapabilitiesKHR& safe_VkVideoDecodeH264CapabilitiesKHR::operator=( + const safe_VkVideoDecodeH264CapabilitiesKHR& copy_src) { if (©_src == this) return *this; - if (pAttributes) delete pAttributes; FreePnextChain(pNext); sType = copy_src.sType; - pAttributes = nullptr; - dwAccess = copy_src.dwAccess; - name = copy_src.name; - pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pAttributes) { - pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes); - } + maxLevelIdc = copy_src.maxLevelIdc; + fieldOffsetGranularity = copy_src.fieldOffsetGranularity; + pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkExportFenceWin32HandleInfoKHR::~safe_VkExportFenceWin32HandleInfoKHR() { - if (pAttributes) delete pAttributes; - FreePnextChain(pNext); -} +safe_VkVideoDecodeH264CapabilitiesKHR::~safe_VkVideoDecodeH264CapabilitiesKHR() { FreePnextChain(pNext); } -void safe_VkExportFenceWin32HandleInfoKHR::initialize(const VkExportFenceWin32HandleInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pAttributes) delete pAttributes; +void safe_VkVideoDecodeH264CapabilitiesKHR::initialize(const VkVideoDecodeH264CapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - pAttributes = nullptr; - dwAccess = in_struct->dwAccess; - name = in_struct->name; + maxLevelIdc = in_struct->maxLevelIdc; + fieldOffsetGranularity = in_struct->fieldOffsetGranularity; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pAttributes) { - pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes); - } } -void safe_VkExportFenceWin32HandleInfoKHR::initialize(const safe_VkExportFenceWin32HandleInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoDecodeH264CapabilitiesKHR::initialize(const safe_VkVideoDecodeH264CapabilitiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - pAttributes = nullptr; - dwAccess = copy_src->dwAccess; - name = copy_src->name; + maxLevelIdc = copy_src->maxLevelIdc; + fieldOffsetGranularity = copy_src->fieldOffsetGranularity; pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pAttributes) { - pAttributes = new SECURITY_ATTRIBUTES(*copy_src->pAttributes); - } } -safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), fence(in_struct->fence), handleType(in_struct->handleType) { +safe_VkVideoDecodeH264SessionParametersAddInfoKHR::safe_VkVideoDecodeH264SessionParametersAddInfoKHR( + const VkVideoDecodeH264SessionParametersAddInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + stdSPSCount(in_struct->stdSPSCount), + pStdSPSs(nullptr), + stdPPSCount(in_struct->stdPPSCount), + pStdPPSs(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + if (in_struct->pStdSPSs) { + pStdSPSs = new StdVideoH264SequenceParameterSet[in_struct->stdSPSCount]; + memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * in_struct->stdSPSCount); + } + + if (in_struct->pStdPPSs) { + pStdPPSs = new StdVideoH264PictureParameterSet[in_struct->stdPPSCount]; + memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * in_struct->stdPPSCount); + } } -safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR() - : sType(VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR), pNext(nullptr), fence(), handleType() {} +safe_VkVideoDecodeH264SessionParametersAddInfoKHR::safe_VkVideoDecodeH264SessionParametersAddInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR), + pNext(nullptr), + stdSPSCount(), + pStdSPSs(nullptr), + stdPPSCount(), + pStdPPSs(nullptr) {} -safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR(const safe_VkFenceGetWin32HandleInfoKHR& copy_src) { +safe_VkVideoDecodeH264SessionParametersAddInfoKHR::safe_VkVideoDecodeH264SessionParametersAddInfoKHR( + const safe_VkVideoDecodeH264SessionParametersAddInfoKHR& copy_src) { sType = copy_src.sType; - fence = copy_src.fence; - handleType = copy_src.handleType; + stdSPSCount = copy_src.stdSPSCount; + pStdSPSs = nullptr; + stdPPSCount = copy_src.stdPPSCount; + pStdPPSs = nullptr; pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdSPSs) { + pStdSPSs = new StdVideoH264SequenceParameterSet[copy_src.stdSPSCount]; + memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * copy_src.stdSPSCount); + } + + if (copy_src.pStdPPSs) { + pStdPPSs = new StdVideoH264PictureParameterSet[copy_src.stdPPSCount]; + memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * copy_src.stdPPSCount); + } } -safe_VkFenceGetWin32HandleInfoKHR& safe_VkFenceGetWin32HandleInfoKHR::operator=(const safe_VkFenceGetWin32HandleInfoKHR& copy_src) { +safe_VkVideoDecodeH264SessionParametersAddInfoKHR& safe_VkVideoDecodeH264SessionParametersAddInfoKHR::operator=( + const safe_VkVideoDecodeH264SessionParametersAddInfoKHR& copy_src) { if (©_src == this) return *this; + if (pStdSPSs) delete[] pStdSPSs; + if (pStdPPSs) delete[] pStdPPSs; FreePnextChain(pNext); sType = copy_src.sType; - fence = copy_src.fence; - handleType = copy_src.handleType; + stdSPSCount = copy_src.stdSPSCount; + pStdSPSs = nullptr; + stdPPSCount = copy_src.stdPPSCount; + pStdPPSs = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pStdSPSs) { + pStdSPSs = new StdVideoH264SequenceParameterSet[copy_src.stdSPSCount]; + memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * copy_src.stdSPSCount); + } + + if (copy_src.pStdPPSs) { + pStdPPSs = new StdVideoH264PictureParameterSet[copy_src.stdPPSCount]; + memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * copy_src.stdPPSCount); + } + return *this; } -safe_VkFenceGetWin32HandleInfoKHR::~safe_VkFenceGetWin32HandleInfoKHR() { FreePnextChain(pNext); } +safe_VkVideoDecodeH264SessionParametersAddInfoKHR::~safe_VkVideoDecodeH264SessionParametersAddInfoKHR() { + if (pStdSPSs) delete[] pStdSPSs; + if (pStdPPSs) delete[] pStdPPSs; + FreePnextChain(pNext); +} -void safe_VkFenceGetWin32HandleInfoKHR::initialize(const VkFenceGetWin32HandleInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoDecodeH264SessionParametersAddInfoKHR::initialize(const VkVideoDecodeH264SessionParametersAddInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdSPSs) delete[] pStdSPSs; + if (pStdPPSs) delete[] pStdPPSs; FreePnextChain(pNext); sType = in_struct->sType; - fence = in_struct->fence; - handleType = in_struct->handleType; + stdSPSCount = in_struct->stdSPSCount; + pStdSPSs = nullptr; + stdPPSCount = in_struct->stdPPSCount; + pStdPPSs = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pStdSPSs) { + pStdSPSs = new StdVideoH264SequenceParameterSet[in_struct->stdSPSCount]; + memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * in_struct->stdSPSCount); + } + + if (in_struct->pStdPPSs) { + pStdPPSs = new StdVideoH264PictureParameterSet[in_struct->stdPPSCount]; + memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * in_struct->stdPPSCount); + } } -void safe_VkFenceGetWin32HandleInfoKHR::initialize(const safe_VkFenceGetWin32HandleInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoDecodeH264SessionParametersAddInfoKHR::initialize( + const safe_VkVideoDecodeH264SessionParametersAddInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - fence = copy_src->fence; - handleType = copy_src->handleType; + stdSPSCount = copy_src->stdSPSCount; + pStdSPSs = nullptr; + stdPPSCount = copy_src->stdPPSCount; + pStdPPSs = nullptr; pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdSPSs) { + pStdSPSs = new StdVideoH264SequenceParameterSet[copy_src->stdSPSCount]; + memcpy((void*)pStdSPSs, (void*)copy_src->pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * copy_src->stdSPSCount); + } + + if (copy_src->pStdPPSs) { + pStdPPSs = new StdVideoH264PictureParameterSet[copy_src->stdPPSCount]; + memcpy((void*)pStdPPSs, (void*)copy_src->pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * copy_src->stdPPSCount); + } } -#endif // VK_USE_PLATFORM_WIN32_KHR -safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::safe_VkVideoDecodeH264SessionParametersCreateInfoKHR( + const VkVideoDecodeH264SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), - fence(in_struct->fence), - flags(in_struct->flags), - handleType(in_struct->handleType), - fd(in_struct->fd) { + maxStdSPSCount(in_struct->maxStdSPSCount), + maxStdPPSCount(in_struct->maxStdPPSCount), + pParametersAddInfo(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + if (in_struct->pParametersAddInfo) + pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoKHR(in_struct->pParametersAddInfo); } -safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR() - : sType(VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR), pNext(nullptr), fence(), flags(), handleType(), fd() {} +safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::safe_VkVideoDecodeH264SessionParametersCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR), + pNext(nullptr), + maxStdSPSCount(), + maxStdPPSCount(), + pParametersAddInfo(nullptr) {} -safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR(const safe_VkImportFenceFdInfoKHR& copy_src) { +safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::safe_VkVideoDecodeH264SessionParametersCreateInfoKHR( + const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& copy_src) { sType = copy_src.sType; - fence = copy_src.fence; - flags = copy_src.flags; - handleType = copy_src.handleType; - fd = copy_src.fd; + maxStdSPSCount = copy_src.maxStdSPSCount; + maxStdPPSCount = copy_src.maxStdPPSCount; + pParametersAddInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pParametersAddInfo) + pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo); } -safe_VkImportFenceFdInfoKHR& safe_VkImportFenceFdInfoKHR::operator=(const safe_VkImportFenceFdInfoKHR& copy_src) { +safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::operator=( + const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& copy_src) { if (©_src == this) return *this; + if (pParametersAddInfo) delete pParametersAddInfo; FreePnextChain(pNext); sType = copy_src.sType; - fence = copy_src.fence; - flags = copy_src.flags; - handleType = copy_src.handleType; - fd = copy_src.fd; + maxStdSPSCount = copy_src.maxStdSPSCount; + maxStdPPSCount = copy_src.maxStdPPSCount; + pParametersAddInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pParametersAddInfo) + pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo); return *this; } -safe_VkImportFenceFdInfoKHR::~safe_VkImportFenceFdInfoKHR() { FreePnextChain(pNext); } +safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::~safe_VkVideoDecodeH264SessionParametersCreateInfoKHR() { + if (pParametersAddInfo) delete pParametersAddInfo; + FreePnextChain(pNext); +} -void safe_VkImportFenceFdInfoKHR::initialize(const VkImportFenceFdInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::initialize( + const VkVideoDecodeH264SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pParametersAddInfo) delete pParametersAddInfo; FreePnextChain(pNext); sType = in_struct->sType; - fence = in_struct->fence; - flags = in_struct->flags; - handleType = in_struct->handleType; - fd = in_struct->fd; + maxStdSPSCount = in_struct->maxStdSPSCount; + maxStdPPSCount = in_struct->maxStdPPSCount; + pParametersAddInfo = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (in_struct->pParametersAddInfo) + pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoKHR(in_struct->pParametersAddInfo); } -void safe_VkImportFenceFdInfoKHR::initialize(const safe_VkImportFenceFdInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::initialize( + const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - fence = copy_src->fence; - flags = copy_src->flags; - handleType = copy_src->handleType; - fd = copy_src->fd; + maxStdSPSCount = copy_src->maxStdSPSCount; + maxStdPPSCount = copy_src->maxStdPPSCount; + pParametersAddInfo = nullptr; pNext = SafePnextCopy(copy_src->pNext); + if (copy_src->pParametersAddInfo) + pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoKHR(*copy_src->pParametersAddInfo); } -safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), fence(in_struct->fence), handleType(in_struct->handleType) { +safe_VkVideoDecodeH264PictureInfoKHR::safe_VkVideoDecodeH264PictureInfoKHR(const VkVideoDecodeH264PictureInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), pStdPictureInfo(nullptr), sliceCount(in_struct->sliceCount), pSliceOffsets(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } -} - -safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR() - : sType(VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR), pNext(nullptr), fence(), handleType() {} + if (in_struct->pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*in_struct->pStdPictureInfo); + } -safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR(const safe_VkFenceGetFdInfoKHR& copy_src) { - sType = copy_src.sType; - fence = copy_src.fence; - handleType = copy_src.handleType; - pNext = SafePnextCopy(copy_src.pNext); + if (in_struct->pSliceOffsets) { + pSliceOffsets = new uint32_t[in_struct->sliceCount]; + memcpy((void*)pSliceOffsets, (void*)in_struct->pSliceOffsets, sizeof(uint32_t) * in_struct->sliceCount); + } } -safe_VkFenceGetFdInfoKHR& safe_VkFenceGetFdInfoKHR::operator=(const safe_VkFenceGetFdInfoKHR& copy_src) { +safe_VkVideoDecodeH264PictureInfoKHR::safe_VkVideoDecodeH264PictureInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR), + pNext(nullptr), + pStdPictureInfo(nullptr), + sliceCount(), + pSliceOffsets(nullptr) {} + +safe_VkVideoDecodeH264PictureInfoKHR::safe_VkVideoDecodeH264PictureInfoKHR(const safe_VkVideoDecodeH264PictureInfoKHR& copy_src) { + sType = copy_src.sType; + pStdPictureInfo = nullptr; + sliceCount = copy_src.sliceCount; + pSliceOffsets = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*copy_src.pStdPictureInfo); + } + + if (copy_src.pSliceOffsets) { + pSliceOffsets = new uint32_t[copy_src.sliceCount]; + memcpy((void*)pSliceOffsets, (void*)copy_src.pSliceOffsets, sizeof(uint32_t) * copy_src.sliceCount); + } +} + +safe_VkVideoDecodeH264PictureInfoKHR& safe_VkVideoDecodeH264PictureInfoKHR::operator=( + const safe_VkVideoDecodeH264PictureInfoKHR& copy_src) { if (©_src == this) return *this; + if (pStdPictureInfo) delete pStdPictureInfo; + if (pSliceOffsets) delete[] pSliceOffsets; FreePnextChain(pNext); sType = copy_src.sType; - fence = copy_src.fence; - handleType = copy_src.handleType; + pStdPictureInfo = nullptr; + sliceCount = copy_src.sliceCount; + pSliceOffsets = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*copy_src.pStdPictureInfo); + } + + if (copy_src.pSliceOffsets) { + pSliceOffsets = new uint32_t[copy_src.sliceCount]; + memcpy((void*)pSliceOffsets, (void*)copy_src.pSliceOffsets, sizeof(uint32_t) * copy_src.sliceCount); + } + return *this; } -safe_VkFenceGetFdInfoKHR::~safe_VkFenceGetFdInfoKHR() { FreePnextChain(pNext); } +safe_VkVideoDecodeH264PictureInfoKHR::~safe_VkVideoDecodeH264PictureInfoKHR() { + if (pStdPictureInfo) delete pStdPictureInfo; + if (pSliceOffsets) delete[] pSliceOffsets; + FreePnextChain(pNext); +} -void safe_VkFenceGetFdInfoKHR::initialize(const VkFenceGetFdInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoDecodeH264PictureInfoKHR::initialize(const VkVideoDecodeH264PictureInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdPictureInfo) delete pStdPictureInfo; + if (pSliceOffsets) delete[] pSliceOffsets; FreePnextChain(pNext); sType = in_struct->sType; - fence = in_struct->fence; - handleType = in_struct->handleType; + pStdPictureInfo = nullptr; + sliceCount = in_struct->sliceCount; + pSliceOffsets = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*in_struct->pStdPictureInfo); + } + + if (in_struct->pSliceOffsets) { + pSliceOffsets = new uint32_t[in_struct->sliceCount]; + memcpy((void*)pSliceOffsets, (void*)in_struct->pSliceOffsets, sizeof(uint32_t) * in_struct->sliceCount); + } } -void safe_VkFenceGetFdInfoKHR::initialize(const safe_VkFenceGetFdInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoDecodeH264PictureInfoKHR::initialize(const safe_VkVideoDecodeH264PictureInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - fence = copy_src->fence; - handleType = copy_src->handleType; + pStdPictureInfo = nullptr; + sliceCount = copy_src->sliceCount; + pSliceOffsets = nullptr; pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*copy_src->pStdPictureInfo); + } + + if (copy_src->pSliceOffsets) { + pSliceOffsets = new uint32_t[copy_src->sliceCount]; + memcpy((void*)pSliceOffsets, (void*)copy_src->pSliceOffsets, sizeof(uint32_t) * copy_src->sliceCount); + } } -safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::safe_VkPhysicalDevicePerformanceQueryFeaturesKHR( - const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - performanceCounterQueryPools(in_struct->performanceCounterQueryPools), - performanceCounterMultipleQueryPools(in_struct->performanceCounterMultipleQueryPools) { +safe_VkVideoDecodeH264DpbSlotInfoKHR::safe_VkVideoDecodeH264DpbSlotInfoKHR(const VkVideoDecodeH264DpbSlotInfoKHR* 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 StdVideoDecodeH264ReferenceInfo(*in_struct->pStdReferenceInfo); + } } -safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::safe_VkPhysicalDevicePerformanceQueryFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR), - pNext(nullptr), - performanceCounterQueryPools(), - performanceCounterMultipleQueryPools() {} +safe_VkVideoDecodeH264DpbSlotInfoKHR::safe_VkVideoDecodeH264DpbSlotInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {} -safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::safe_VkPhysicalDevicePerformanceQueryFeaturesKHR( - const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src) { +safe_VkVideoDecodeH264DpbSlotInfoKHR::safe_VkVideoDecodeH264DpbSlotInfoKHR(const safe_VkVideoDecodeH264DpbSlotInfoKHR& copy_src) { sType = copy_src.sType; - performanceCounterQueryPools = copy_src.performanceCounterQueryPools; - performanceCounterMultipleQueryPools = copy_src.performanceCounterMultipleQueryPools; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*copy_src.pStdReferenceInfo); + } } -safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::operator=( - const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src) { +safe_VkVideoDecodeH264DpbSlotInfoKHR& safe_VkVideoDecodeH264DpbSlotInfoKHR::operator=( + const safe_VkVideoDecodeH264DpbSlotInfoKHR& copy_src) { if (©_src == this) return *this; + if (pStdReferenceInfo) delete pStdReferenceInfo; FreePnextChain(pNext); sType = copy_src.sType; - performanceCounterQueryPools = copy_src.performanceCounterQueryPools; - performanceCounterMultipleQueryPools = copy_src.performanceCounterMultipleQueryPools; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*copy_src.pStdReferenceInfo); + } + return *this; } -safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::~safe_VkPhysicalDevicePerformanceQueryFeaturesKHR() { FreePnextChain(pNext); } +safe_VkVideoDecodeH264DpbSlotInfoKHR::~safe_VkVideoDecodeH264DpbSlotInfoKHR() { + if (pStdReferenceInfo) delete pStdReferenceInfo; + FreePnextChain(pNext); +} -void safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::initialize(const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoDecodeH264DpbSlotInfoKHR::initialize(const VkVideoDecodeH264DpbSlotInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdReferenceInfo) delete pStdReferenceInfo; FreePnextChain(pNext); sType = in_struct->sType; - performanceCounterQueryPools = in_struct->performanceCounterQueryPools; - performanceCounterMultipleQueryPools = in_struct->performanceCounterMultipleQueryPools; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*in_struct->pStdReferenceInfo); + } } -void safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::initialize(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoDecodeH264DpbSlotInfoKHR::initialize(const safe_VkVideoDecodeH264DpbSlotInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - performanceCounterQueryPools = copy_src->performanceCounterQueryPools; - performanceCounterMultipleQueryPools = copy_src->performanceCounterMultipleQueryPools; + pStdReferenceInfo = nullptr; pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*copy_src->pStdReferenceInfo); + } } -safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::safe_VkPhysicalDevicePerformanceQueryPropertiesKHR( - const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), allowCommandBufferQueryCopies(in_struct->allowCommandBufferQueryCopies) { +safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR( + const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + imageView(in_struct->imageView), + imageLayout(in_struct->imageLayout), + shadingRateAttachmentTexelSize(in_struct->shadingRateAttachmentTexelSize) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::safe_VkPhysicalDevicePerformanceQueryPropertiesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR), pNext(nullptr), allowCommandBufferQueryCopies() {} +safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR() + : sType(VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR), + pNext(nullptr), + imageView(), + imageLayout(), + shadingRateAttachmentTexelSize() {} -safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::safe_VkPhysicalDevicePerformanceQueryPropertiesKHR( - const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src) { +safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR( + const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src) { sType = copy_src.sType; - allowCommandBufferQueryCopies = copy_src.allowCommandBufferQueryCopies; + imageView = copy_src.imageView; + imageLayout = copy_src.imageLayout; + shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::operator=( - const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src) { +safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::operator=( + const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - allowCommandBufferQueryCopies = copy_src.allowCommandBufferQueryCopies; + imageView = copy_src.imageView; + imageLayout = copy_src.imageLayout; + shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::~safe_VkPhysicalDevicePerformanceQueryPropertiesKHR() { FreePnextChain(pNext); } +safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::~safe_VkRenderingFragmentShadingRateAttachmentInfoKHR() { + FreePnextChain(pNext); +} -void safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::initialize(const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::initialize( + const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - allowCommandBufferQueryCopies = in_struct->allowCommandBufferQueryCopies; + imageView = in_struct->imageView; + imageLayout = in_struct->imageLayout; + shadingRateAttachmentTexelSize = in_struct->shadingRateAttachmentTexelSize; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::initialize( - const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::initialize( + const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - allowCommandBufferQueryCopies = copy_src->allowCommandBufferQueryCopies; + imageView = copy_src->imageView; + imageLayout = copy_src->imageLayout; + shadingRateAttachmentTexelSize = copy_src->shadingRateAttachmentTexelSize; pNext = SafePnextCopy(copy_src->pNext); } +#ifdef VK_USE_PLATFORM_WIN32_KHR -safe_VkPerformanceCounterKHR::safe_VkPerformanceCounterKHR(const VkPerformanceCounterKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), unit(in_struct->unit), scope(in_struct->scope), storage(in_struct->storage) { +safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), handleType(in_struct->handleType), handle(in_struct->handle), name(in_struct->name) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { - uuid[i] = in_struct->uuid[i]; - } } -safe_VkPerformanceCounterKHR::safe_VkPerformanceCounterKHR() - : sType(VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR), pNext(nullptr), unit(), scope(), storage() {} +safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR() + : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR), pNext(nullptr), handleType(), handle(), name() {} -safe_VkPerformanceCounterKHR::safe_VkPerformanceCounterKHR(const safe_VkPerformanceCounterKHR& copy_src) { +safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR( + const safe_VkImportMemoryWin32HandleInfoKHR& copy_src) { sType = copy_src.sType; - unit = copy_src.unit; - scope = copy_src.scope; - storage = copy_src.storage; + handleType = copy_src.handleType; + handle = copy_src.handle; + name = copy_src.name; pNext = SafePnextCopy(copy_src.pNext); - - for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { - uuid[i] = copy_src.uuid[i]; - } } -safe_VkPerformanceCounterKHR& safe_VkPerformanceCounterKHR::operator=(const safe_VkPerformanceCounterKHR& copy_src) { +safe_VkImportMemoryWin32HandleInfoKHR& safe_VkImportMemoryWin32HandleInfoKHR::operator=( + const safe_VkImportMemoryWin32HandleInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - unit = copy_src.unit; - scope = copy_src.scope; - storage = copy_src.storage; + handleType = copy_src.handleType; + handle = copy_src.handle; + name = copy_src.name; pNext = SafePnextCopy(copy_src.pNext); - for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { - uuid[i] = copy_src.uuid[i]; - } - return *this; } -safe_VkPerformanceCounterKHR::~safe_VkPerformanceCounterKHR() { FreePnextChain(pNext); } +safe_VkImportMemoryWin32HandleInfoKHR::~safe_VkImportMemoryWin32HandleInfoKHR() { FreePnextChain(pNext); } -void safe_VkPerformanceCounterKHR::initialize(const VkPerformanceCounterKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkImportMemoryWin32HandleInfoKHR::initialize(const VkImportMemoryWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - unit = in_struct->unit; - scope = in_struct->scope; - storage = in_struct->storage; + handleType = in_struct->handleType; + handle = in_struct->handle; + name = in_struct->name; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { - uuid[i] = in_struct->uuid[i]; - } } -void safe_VkPerformanceCounterKHR::initialize(const safe_VkPerformanceCounterKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkImportMemoryWin32HandleInfoKHR::initialize(const safe_VkImportMemoryWin32HandleInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - unit = copy_src->unit; - scope = copy_src->scope; - storage = copy_src->storage; + handleType = copy_src->handleType; + handle = copy_src->handle; + name = copy_src->name; pNext = SafePnextCopy(copy_src->pNext); - - for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { - uuid[i] = copy_src->uuid[i]; - } } -safe_VkPerformanceCounterDescriptionKHR::safe_VkPerformanceCounterDescriptionKHR( - const VkPerformanceCounterDescriptionKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), flags(in_struct->flags) { +safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), pAttributes(nullptr), dwAccess(in_struct->dwAccess), name(in_struct->name) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = in_struct->name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - category[i] = in_struct->category[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = in_struct->description[i]; + if (in_struct->pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes); } } -safe_VkPerformanceCounterDescriptionKHR::safe_VkPerformanceCounterDescriptionKHR() - : sType(VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR), pNext(nullptr), flags() {} +safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR() + : sType(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR), pNext(nullptr), pAttributes(nullptr), dwAccess(), name() {} -safe_VkPerformanceCounterDescriptionKHR::safe_VkPerformanceCounterDescriptionKHR( - const safe_VkPerformanceCounterDescriptionKHR& copy_src) { +safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR( + const safe_VkExportMemoryWin32HandleInfoKHR& copy_src) { sType = copy_src.sType; - flags = copy_src.flags; + pAttributes = nullptr; + dwAccess = copy_src.dwAccess; + name = copy_src.name; pNext = SafePnextCopy(copy_src.pNext); - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = copy_src.name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - category[i] = copy_src.category[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = copy_src.description[i]; + if (copy_src.pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes); } } -safe_VkPerformanceCounterDescriptionKHR& safe_VkPerformanceCounterDescriptionKHR::operator=( - const safe_VkPerformanceCounterDescriptionKHR& copy_src) { +safe_VkExportMemoryWin32HandleInfoKHR& safe_VkExportMemoryWin32HandleInfoKHR::operator=( + const safe_VkExportMemoryWin32HandleInfoKHR& copy_src) { if (©_src == this) return *this; + if (pAttributes) delete pAttributes; FreePnextChain(pNext); sType = copy_src.sType; - flags = copy_src.flags; + pAttributes = nullptr; + dwAccess = copy_src.dwAccess; + name = copy_src.name; pNext = SafePnextCopy(copy_src.pNext); - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = copy_src.name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - category[i] = copy_src.category[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = copy_src.description[i]; + if (copy_src.pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes); } return *this; } -safe_VkPerformanceCounterDescriptionKHR::~safe_VkPerformanceCounterDescriptionKHR() { FreePnextChain(pNext); } +safe_VkExportMemoryWin32HandleInfoKHR::~safe_VkExportMemoryWin32HandleInfoKHR() { + if (pAttributes) delete pAttributes; + FreePnextChain(pNext); +} -void safe_VkPerformanceCounterDescriptionKHR::initialize(const VkPerformanceCounterDescriptionKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkExportMemoryWin32HandleInfoKHR::initialize(const VkExportMemoryWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pAttributes) delete pAttributes; FreePnextChain(pNext); sType = in_struct->sType; - flags = in_struct->flags; + pAttributes = nullptr; + dwAccess = in_struct->dwAccess; + name = in_struct->name; pNext = SafePnextCopy(in_struct->pNext, copy_state); - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = in_struct->name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - category[i] = in_struct->category[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = in_struct->description[i]; + if (in_struct->pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes); } } -void safe_VkPerformanceCounterDescriptionKHR::initialize(const safe_VkPerformanceCounterDescriptionKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkExportMemoryWin32HandleInfoKHR::initialize(const safe_VkExportMemoryWin32HandleInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - flags = copy_src->flags; + pAttributes = nullptr; + dwAccess = copy_src->dwAccess; + name = copy_src->name; pNext = SafePnextCopy(copy_src->pNext); - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = copy_src->name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - category[i] = copy_src->category[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = copy_src->description[i]; + if (copy_src->pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*copy_src->pAttributes); } } -safe_VkQueryPoolPerformanceCreateInfoKHR::safe_VkQueryPoolPerformanceCreateInfoKHR( - const VkQueryPoolPerformanceCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - queueFamilyIndex(in_struct->queueFamilyIndex), - counterIndexCount(in_struct->counterIndexCount), - pCounterIndices(nullptr) { +safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), memoryTypeBits(in_struct->memoryTypeBits) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pCounterIndices) { - pCounterIndices = new uint32_t[in_struct->counterIndexCount]; - memcpy((void*)pCounterIndices, (void*)in_struct->pCounterIndices, sizeof(uint32_t) * in_struct->counterIndexCount); - } } -safe_VkQueryPoolPerformanceCreateInfoKHR::safe_VkQueryPoolPerformanceCreateInfoKHR() - : sType(VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR), - pNext(nullptr), - queueFamilyIndex(), - counterIndexCount(), - pCounterIndices(nullptr) {} +safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR() + : sType(VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR), pNext(nullptr), memoryTypeBits() {} -safe_VkQueryPoolPerformanceCreateInfoKHR::safe_VkQueryPoolPerformanceCreateInfoKHR( - const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src) { +safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR( + const safe_VkMemoryWin32HandlePropertiesKHR& copy_src) { sType = copy_src.sType; - queueFamilyIndex = copy_src.queueFamilyIndex; - counterIndexCount = copy_src.counterIndexCount; - pCounterIndices = nullptr; + memoryTypeBits = copy_src.memoryTypeBits; pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pCounterIndices) { - pCounterIndices = new uint32_t[copy_src.counterIndexCount]; - memcpy((void*)pCounterIndices, (void*)copy_src.pCounterIndices, sizeof(uint32_t) * copy_src.counterIndexCount); - } } -safe_VkQueryPoolPerformanceCreateInfoKHR& safe_VkQueryPoolPerformanceCreateInfoKHR::operator=( - const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src) { +safe_VkMemoryWin32HandlePropertiesKHR& safe_VkMemoryWin32HandlePropertiesKHR::operator=( + const safe_VkMemoryWin32HandlePropertiesKHR& copy_src) { if (©_src == this) return *this; - if (pCounterIndices) delete[] pCounterIndices; FreePnextChain(pNext); sType = copy_src.sType; - queueFamilyIndex = copy_src.queueFamilyIndex; - counterIndexCount = copy_src.counterIndexCount; - pCounterIndices = nullptr; + memoryTypeBits = copy_src.memoryTypeBits; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pCounterIndices) { - pCounterIndices = new uint32_t[copy_src.counterIndexCount]; - memcpy((void*)pCounterIndices, (void*)copy_src.pCounterIndices, sizeof(uint32_t) * copy_src.counterIndexCount); - } - return *this; } -safe_VkQueryPoolPerformanceCreateInfoKHR::~safe_VkQueryPoolPerformanceCreateInfoKHR() { - if (pCounterIndices) delete[] pCounterIndices; - FreePnextChain(pNext); -} +safe_VkMemoryWin32HandlePropertiesKHR::~safe_VkMemoryWin32HandlePropertiesKHR() { FreePnextChain(pNext); } -void safe_VkQueryPoolPerformanceCreateInfoKHR::initialize(const VkQueryPoolPerformanceCreateInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pCounterIndices) delete[] pCounterIndices; +void safe_VkMemoryWin32HandlePropertiesKHR::initialize(const VkMemoryWin32HandlePropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - queueFamilyIndex = in_struct->queueFamilyIndex; - counterIndexCount = in_struct->counterIndexCount; - pCounterIndices = nullptr; + memoryTypeBits = in_struct->memoryTypeBits; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pCounterIndices) { - pCounterIndices = new uint32_t[in_struct->counterIndexCount]; - memcpy((void*)pCounterIndices, (void*)in_struct->pCounterIndices, sizeof(uint32_t) * in_struct->counterIndexCount); - } } -void safe_VkQueryPoolPerformanceCreateInfoKHR::initialize(const safe_VkQueryPoolPerformanceCreateInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkMemoryWin32HandlePropertiesKHR::initialize(const safe_VkMemoryWin32HandlePropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - queueFamilyIndex = copy_src->queueFamilyIndex; - counterIndexCount = copy_src->counterIndexCount; - pCounterIndices = nullptr; + memoryTypeBits = copy_src->memoryTypeBits; pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pCounterIndices) { - pCounterIndices = new uint32_t[copy_src->counterIndexCount]; - memcpy((void*)pCounterIndices, (void*)copy_src->pCounterIndices, sizeof(uint32_t) * copy_src->counterIndexCount); - } } -safe_VkAcquireProfilingLockInfoKHR::safe_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR* in_struct, +safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), flags(in_struct->flags), timeout(in_struct->timeout) { + : sType(in_struct->sType), memory(in_struct->memory), handleType(in_struct->handleType) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkAcquireProfilingLockInfoKHR::safe_VkAcquireProfilingLockInfoKHR() - : sType(VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR), pNext(nullptr), flags(), timeout() {} +safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR() + : sType(VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR), pNext(nullptr), memory(), handleType() {} -safe_VkAcquireProfilingLockInfoKHR::safe_VkAcquireProfilingLockInfoKHR(const safe_VkAcquireProfilingLockInfoKHR& copy_src) { +safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR(const safe_VkMemoryGetWin32HandleInfoKHR& copy_src) { sType = copy_src.sType; - flags = copy_src.flags; - timeout = copy_src.timeout; + memory = copy_src.memory; + handleType = copy_src.handleType; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkAcquireProfilingLockInfoKHR& safe_VkAcquireProfilingLockInfoKHR::operator=( - const safe_VkAcquireProfilingLockInfoKHR& copy_src) { +safe_VkMemoryGetWin32HandleInfoKHR& safe_VkMemoryGetWin32HandleInfoKHR::operator=( + const safe_VkMemoryGetWin32HandleInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - flags = copy_src.flags; - timeout = copy_src.timeout; + memory = copy_src.memory; + handleType = copy_src.handleType; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkAcquireProfilingLockInfoKHR::~safe_VkAcquireProfilingLockInfoKHR() { FreePnextChain(pNext); } +safe_VkMemoryGetWin32HandleInfoKHR::~safe_VkMemoryGetWin32HandleInfoKHR() { FreePnextChain(pNext); } -void safe_VkAcquireProfilingLockInfoKHR::initialize(const VkAcquireProfilingLockInfoKHR* in_struct, +void safe_VkMemoryGetWin32HandleInfoKHR::initialize(const VkMemoryGetWin32HandleInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - flags = in_struct->flags; - timeout = in_struct->timeout; + memory = in_struct->memory; + handleType = in_struct->handleType; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkAcquireProfilingLockInfoKHR::initialize(const safe_VkAcquireProfilingLockInfoKHR* copy_src, +void safe_VkMemoryGetWin32HandleInfoKHR::initialize(const safe_VkMemoryGetWin32HandleInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - flags = copy_src->flags; - timeout = copy_src->timeout; + memory = copy_src->memory; + handleType = copy_src->handleType; pNext = SafePnextCopy(copy_src->pNext); } +#endif // VK_USE_PLATFORM_WIN32_KHR -safe_VkPerformanceQuerySubmitInfoKHR::safe_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), counterPassIndex(in_struct->counterPassIndex) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); +safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), handleType(in_struct->handleType), fd(in_struct->fd) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPerformanceQuerySubmitInfoKHR::safe_VkPerformanceQuerySubmitInfoKHR() - : sType(VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR), pNext(nullptr), counterPassIndex() {} +safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR() + : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR), pNext(nullptr), handleType(), fd() {} -safe_VkPerformanceQuerySubmitInfoKHR::safe_VkPerformanceQuerySubmitInfoKHR(const safe_VkPerformanceQuerySubmitInfoKHR& copy_src) { +safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR(const safe_VkImportMemoryFdInfoKHR& copy_src) { sType = copy_src.sType; - counterPassIndex = copy_src.counterPassIndex; + handleType = copy_src.handleType; + fd = copy_src.fd; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPerformanceQuerySubmitInfoKHR& safe_VkPerformanceQuerySubmitInfoKHR::operator=( - const safe_VkPerformanceQuerySubmitInfoKHR& copy_src) { +safe_VkImportMemoryFdInfoKHR& safe_VkImportMemoryFdInfoKHR::operator=(const safe_VkImportMemoryFdInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - counterPassIndex = copy_src.counterPassIndex; + handleType = copy_src.handleType; + fd = copy_src.fd; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPerformanceQuerySubmitInfoKHR::~safe_VkPerformanceQuerySubmitInfoKHR() { FreePnextChain(pNext); } +safe_VkImportMemoryFdInfoKHR::~safe_VkImportMemoryFdInfoKHR() { FreePnextChain(pNext); } -void safe_VkPerformanceQuerySubmitInfoKHR::initialize(const VkPerformanceQuerySubmitInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkImportMemoryFdInfoKHR::initialize(const VkImportMemoryFdInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - counterPassIndex = in_struct->counterPassIndex; + handleType = in_struct->handleType; + fd = in_struct->fd; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPerformanceQuerySubmitInfoKHR::initialize(const safe_VkPerformanceQuerySubmitInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkImportMemoryFdInfoKHR::initialize(const safe_VkImportMemoryFdInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - counterPassIndex = copy_src->counterPassIndex; + handleType = copy_src->handleType; + fd = copy_src->fd; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), surface(in_struct->surface) { +safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), memoryTypeBits(in_struct->memoryTypeBits) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR), pNext(nullptr), surface() {} +safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR), pNext(nullptr), memoryTypeBits() {} -safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR(const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src) { +safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR(const safe_VkMemoryFdPropertiesKHR& copy_src) { sType = copy_src.sType; - surface = copy_src.surface; + memoryTypeBits = copy_src.memoryTypeBits; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceSurfaceInfo2KHR& safe_VkPhysicalDeviceSurfaceInfo2KHR::operator=( - const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src) { +safe_VkMemoryFdPropertiesKHR& safe_VkMemoryFdPropertiesKHR::operator=(const safe_VkMemoryFdPropertiesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - surface = copy_src.surface; + memoryTypeBits = copy_src.memoryTypeBits; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceSurfaceInfo2KHR::~safe_VkPhysicalDeviceSurfaceInfo2KHR() { FreePnextChain(pNext); } +safe_VkMemoryFdPropertiesKHR::~safe_VkMemoryFdPropertiesKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceSurfaceInfo2KHR::initialize(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkMemoryFdPropertiesKHR::initialize(const VkMemoryFdPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - surface = in_struct->surface; + memoryTypeBits = in_struct->memoryTypeBits; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceSurfaceInfo2KHR::initialize(const safe_VkPhysicalDeviceSurfaceInfo2KHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkMemoryFdPropertiesKHR::initialize(const safe_VkMemoryFdPropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - surface = copy_src->surface; + memoryTypeBits = copy_src->memoryTypeBits; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), surfaceCapabilities(in_struct->surfaceCapabilities) { +safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), memory(in_struct->memory), handleType(in_struct->handleType) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR() - : sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR), pNext(nullptr), surfaceCapabilities() {} +safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR() + : sType(VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR), pNext(nullptr), memory(), handleType() {} -safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR(const safe_VkSurfaceCapabilities2KHR& copy_src) { +safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR(const safe_VkMemoryGetFdInfoKHR& copy_src) { sType = copy_src.sType; - surfaceCapabilities = copy_src.surfaceCapabilities; + memory = copy_src.memory; + handleType = copy_src.handleType; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkSurfaceCapabilities2KHR& safe_VkSurfaceCapabilities2KHR::operator=(const safe_VkSurfaceCapabilities2KHR& copy_src) { +safe_VkMemoryGetFdInfoKHR& safe_VkMemoryGetFdInfoKHR::operator=(const safe_VkMemoryGetFdInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - surfaceCapabilities = copy_src.surfaceCapabilities; + memory = copy_src.memory; + handleType = copy_src.handleType; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkSurfaceCapabilities2KHR::~safe_VkSurfaceCapabilities2KHR() { FreePnextChain(pNext); } +safe_VkMemoryGetFdInfoKHR::~safe_VkMemoryGetFdInfoKHR() { FreePnextChain(pNext); } -void safe_VkSurfaceCapabilities2KHR::initialize(const VkSurfaceCapabilities2KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkMemoryGetFdInfoKHR::initialize(const VkMemoryGetFdInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - surfaceCapabilities = in_struct->surfaceCapabilities; + memory = in_struct->memory; + handleType = in_struct->handleType; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkSurfaceCapabilities2KHR::initialize(const safe_VkSurfaceCapabilities2KHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkMemoryGetFdInfoKHR::initialize(const safe_VkMemoryGetFdInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - surfaceCapabilities = copy_src->surfaceCapabilities; + memory = copy_src->memory; + handleType = copy_src->handleType; pNext = SafePnextCopy(copy_src->pNext); } +#ifdef VK_USE_PLATFORM_WIN32_KHR -safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), surfaceFormat(in_struct->surfaceFormat) { +safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR( + const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + acquireCount(in_struct->acquireCount), + pAcquireSyncs(nullptr), + pAcquireKeys(nullptr), + pAcquireTimeouts(nullptr), + releaseCount(in_struct->releaseCount), + pReleaseSyncs(nullptr), + pReleaseKeys(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } -} + if (acquireCount && in_struct->pAcquireSyncs) { + pAcquireSyncs = new VkDeviceMemory[acquireCount]; + for (uint32_t i = 0; i < acquireCount; ++i) { + pAcquireSyncs[i] = in_struct->pAcquireSyncs[i]; + } + } -safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR() - : sType(VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR), pNext(nullptr), surfaceFormat() {} + if (in_struct->pAcquireKeys) { + pAcquireKeys = new uint64_t[in_struct->acquireCount]; + memcpy((void*)pAcquireKeys, (void*)in_struct->pAcquireKeys, sizeof(uint64_t) * in_struct->acquireCount); + } -safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR(const safe_VkSurfaceFormat2KHR& copy_src) { - sType = copy_src.sType; - surfaceFormat = copy_src.surfaceFormat; - pNext = SafePnextCopy(copy_src.pNext); -} + if (in_struct->pAcquireTimeouts) { + pAcquireTimeouts = new uint32_t[in_struct->acquireCount]; + memcpy((void*)pAcquireTimeouts, (void*)in_struct->pAcquireTimeouts, sizeof(uint32_t) * in_struct->acquireCount); + } + if (releaseCount && in_struct->pReleaseSyncs) { + pReleaseSyncs = new VkDeviceMemory[releaseCount]; + for (uint32_t i = 0; i < releaseCount; ++i) { + pReleaseSyncs[i] = in_struct->pReleaseSyncs[i]; + } + } -safe_VkSurfaceFormat2KHR& safe_VkSurfaceFormat2KHR::operator=(const safe_VkSurfaceFormat2KHR& copy_src) { - if (©_src == this) return *this; + if (in_struct->pReleaseKeys) { + pReleaseKeys = new uint64_t[in_struct->releaseCount]; + memcpy((void*)pReleaseKeys, (void*)in_struct->pReleaseKeys, sizeof(uint64_t) * in_struct->releaseCount); + } +} - FreePnextChain(pNext); +safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR() + : sType(VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR), + pNext(nullptr), + acquireCount(), + pAcquireSyncs(nullptr), + pAcquireKeys(nullptr), + pAcquireTimeouts(nullptr), + releaseCount(), + pReleaseSyncs(nullptr), + pReleaseKeys(nullptr) {} +safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR( + const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src) { sType = copy_src.sType; - surfaceFormat = copy_src.surfaceFormat; + acquireCount = copy_src.acquireCount; + pAcquireSyncs = nullptr; + pAcquireKeys = nullptr; + pAcquireTimeouts = nullptr; + releaseCount = copy_src.releaseCount; + pReleaseSyncs = nullptr; + pReleaseKeys = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (acquireCount && copy_src.pAcquireSyncs) { + pAcquireSyncs = new VkDeviceMemory[acquireCount]; + for (uint32_t i = 0; i < acquireCount; ++i) { + pAcquireSyncs[i] = copy_src.pAcquireSyncs[i]; + } + } - return *this; -} - -safe_VkSurfaceFormat2KHR::~safe_VkSurfaceFormat2KHR() { FreePnextChain(pNext); } - -void safe_VkSurfaceFormat2KHR::initialize(const VkSurfaceFormat2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - surfaceFormat = in_struct->surfaceFormat; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkSurfaceFormat2KHR::initialize(const safe_VkSurfaceFormat2KHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - surfaceFormat = copy_src->surfaceFormat; - pNext = SafePnextCopy(copy_src->pNext); -} - -safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR(const VkDisplayProperties2KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), displayProperties(&in_struct->displayProperties) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (copy_src.pAcquireKeys) { + pAcquireKeys = new uint64_t[copy_src.acquireCount]; + memcpy((void*)pAcquireKeys, (void*)copy_src.pAcquireKeys, sizeof(uint64_t) * copy_src.acquireCount); } -} -safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR() : sType(VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR), pNext(nullptr) {} + if (copy_src.pAcquireTimeouts) { + pAcquireTimeouts = new uint32_t[copy_src.acquireCount]; + memcpy((void*)pAcquireTimeouts, (void*)copy_src.pAcquireTimeouts, sizeof(uint32_t) * copy_src.acquireCount); + } + if (releaseCount && copy_src.pReleaseSyncs) { + pReleaseSyncs = new VkDeviceMemory[releaseCount]; + for (uint32_t i = 0; i < releaseCount; ++i) { + pReleaseSyncs[i] = copy_src.pReleaseSyncs[i]; + } + } -safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR(const safe_VkDisplayProperties2KHR& copy_src) { - sType = copy_src.sType; - displayProperties.initialize(©_src.displayProperties); - pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pReleaseKeys) { + pReleaseKeys = new uint64_t[copy_src.releaseCount]; + memcpy((void*)pReleaseKeys, (void*)copy_src.pReleaseKeys, sizeof(uint64_t) * copy_src.releaseCount); + } } -safe_VkDisplayProperties2KHR& safe_VkDisplayProperties2KHR::operator=(const safe_VkDisplayProperties2KHR& copy_src) { +safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::operator=( + const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src) { if (©_src == this) return *this; + if (pAcquireSyncs) delete[] pAcquireSyncs; + if (pAcquireKeys) delete[] pAcquireKeys; + if (pAcquireTimeouts) delete[] pAcquireTimeouts; + if (pReleaseSyncs) delete[] pReleaseSyncs; + if (pReleaseKeys) delete[] pReleaseKeys; FreePnextChain(pNext); sType = copy_src.sType; - displayProperties.initialize(©_src.displayProperties); + acquireCount = copy_src.acquireCount; + pAcquireSyncs = nullptr; + pAcquireKeys = nullptr; + pAcquireTimeouts = nullptr; + releaseCount = copy_src.releaseCount; + pReleaseSyncs = nullptr; + pReleaseKeys = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (acquireCount && copy_src.pAcquireSyncs) { + pAcquireSyncs = new VkDeviceMemory[acquireCount]; + for (uint32_t i = 0; i < acquireCount; ++i) { + pAcquireSyncs[i] = copy_src.pAcquireSyncs[i]; + } + } - return *this; -} - -safe_VkDisplayProperties2KHR::~safe_VkDisplayProperties2KHR() { FreePnextChain(pNext); } + if (copy_src.pAcquireKeys) { + pAcquireKeys = new uint64_t[copy_src.acquireCount]; + memcpy((void*)pAcquireKeys, (void*)copy_src.pAcquireKeys, sizeof(uint64_t) * copy_src.acquireCount); + } -void safe_VkDisplayProperties2KHR::initialize(const VkDisplayProperties2KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { + if (copy_src.pAcquireTimeouts) { + pAcquireTimeouts = new uint32_t[copy_src.acquireCount]; + memcpy((void*)pAcquireTimeouts, (void*)copy_src.pAcquireTimeouts, sizeof(uint32_t) * copy_src.acquireCount); + } + if (releaseCount && copy_src.pReleaseSyncs) { + pReleaseSyncs = new VkDeviceMemory[releaseCount]; + for (uint32_t i = 0; i < releaseCount; ++i) { + pReleaseSyncs[i] = copy_src.pReleaseSyncs[i]; + } + } + + if (copy_src.pReleaseKeys) { + pReleaseKeys = new uint64_t[copy_src.releaseCount]; + memcpy((void*)pReleaseKeys, (void*)copy_src.pReleaseKeys, sizeof(uint64_t) * copy_src.releaseCount); + } + + return *this; +} + +safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::~safe_VkWin32KeyedMutexAcquireReleaseInfoKHR() { + if (pAcquireSyncs) delete[] pAcquireSyncs; + if (pAcquireKeys) delete[] pAcquireKeys; + if (pAcquireTimeouts) delete[] pAcquireTimeouts; + if (pReleaseSyncs) delete[] pReleaseSyncs; + if (pReleaseKeys) delete[] pReleaseKeys; + FreePnextChain(pNext); +} + +void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pAcquireSyncs) delete[] pAcquireSyncs; + if (pAcquireKeys) delete[] pAcquireKeys; + if (pAcquireTimeouts) delete[] pAcquireTimeouts; + if (pReleaseSyncs) delete[] pReleaseSyncs; + if (pReleaseKeys) delete[] pReleaseKeys; FreePnextChain(pNext); sType = in_struct->sType; - displayProperties.initialize(&in_struct->displayProperties); + acquireCount = in_struct->acquireCount; + pAcquireSyncs = nullptr; + pAcquireKeys = nullptr; + pAcquireTimeouts = nullptr; + releaseCount = in_struct->releaseCount; + pReleaseSyncs = nullptr; + pReleaseKeys = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (acquireCount && in_struct->pAcquireSyncs) { + pAcquireSyncs = new VkDeviceMemory[acquireCount]; + for (uint32_t i = 0; i < acquireCount; ++i) { + pAcquireSyncs[i] = in_struct->pAcquireSyncs[i]; + } + } + + if (in_struct->pAcquireKeys) { + pAcquireKeys = new uint64_t[in_struct->acquireCount]; + memcpy((void*)pAcquireKeys, (void*)in_struct->pAcquireKeys, sizeof(uint64_t) * in_struct->acquireCount); + } + + if (in_struct->pAcquireTimeouts) { + pAcquireTimeouts = new uint32_t[in_struct->acquireCount]; + memcpy((void*)pAcquireTimeouts, (void*)in_struct->pAcquireTimeouts, sizeof(uint32_t) * in_struct->acquireCount); + } + if (releaseCount && in_struct->pReleaseSyncs) { + pReleaseSyncs = new VkDeviceMemory[releaseCount]; + for (uint32_t i = 0; i < releaseCount; ++i) { + pReleaseSyncs[i] = in_struct->pReleaseSyncs[i]; + } + } + + if (in_struct->pReleaseKeys) { + pReleaseKeys = new uint64_t[in_struct->releaseCount]; + memcpy((void*)pReleaseKeys, (void*)in_struct->pReleaseKeys, sizeof(uint64_t) * in_struct->releaseCount); + } } -void safe_VkDisplayProperties2KHR::initialize(const safe_VkDisplayProperties2KHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - displayProperties.initialize(©_src->displayProperties); + acquireCount = copy_src->acquireCount; + pAcquireSyncs = nullptr; + pAcquireKeys = nullptr; + pAcquireTimeouts = nullptr; + releaseCount = copy_src->releaseCount; + pReleaseSyncs = nullptr; + pReleaseKeys = nullptr; pNext = SafePnextCopy(copy_src->pNext); + if (acquireCount && copy_src->pAcquireSyncs) { + pAcquireSyncs = new VkDeviceMemory[acquireCount]; + for (uint32_t i = 0; i < acquireCount; ++i) { + pAcquireSyncs[i] = copy_src->pAcquireSyncs[i]; + } + } + + if (copy_src->pAcquireKeys) { + pAcquireKeys = new uint64_t[copy_src->acquireCount]; + memcpy((void*)pAcquireKeys, (void*)copy_src->pAcquireKeys, sizeof(uint64_t) * copy_src->acquireCount); + } + + if (copy_src->pAcquireTimeouts) { + pAcquireTimeouts = new uint32_t[copy_src->acquireCount]; + memcpy((void*)pAcquireTimeouts, (void*)copy_src->pAcquireTimeouts, sizeof(uint32_t) * copy_src->acquireCount); + } + if (releaseCount && copy_src->pReleaseSyncs) { + pReleaseSyncs = new VkDeviceMemory[releaseCount]; + for (uint32_t i = 0; i < releaseCount; ++i) { + pReleaseSyncs[i] = copy_src->pReleaseSyncs[i]; + } + } + + if (copy_src->pReleaseKeys) { + pReleaseKeys = new uint64_t[copy_src->releaseCount]; + memcpy((void*)pReleaseKeys, (void*)copy_src->pReleaseKeys, sizeof(uint64_t) * copy_src->releaseCount); + } } -safe_VkDisplayPlaneProperties2KHR::safe_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), displayPlaneProperties(in_struct->displayPlaneProperties) { +safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR( + const VkImportSemaphoreWin32HandleInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + semaphore(in_struct->semaphore), + flags(in_struct->flags), + handleType(in_struct->handleType), + handle(in_struct->handle), + name(in_struct->name) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkDisplayPlaneProperties2KHR::safe_VkDisplayPlaneProperties2KHR() - : sType(VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR), pNext(nullptr), displayPlaneProperties() {} +safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR() + : sType(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR), + pNext(nullptr), + semaphore(), + flags(), + handleType(), + handle(), + name() {} -safe_VkDisplayPlaneProperties2KHR::safe_VkDisplayPlaneProperties2KHR(const safe_VkDisplayPlaneProperties2KHR& copy_src) { +safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR( + const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src) { sType = copy_src.sType; - displayPlaneProperties = copy_src.displayPlaneProperties; + semaphore = copy_src.semaphore; + flags = copy_src.flags; + handleType = copy_src.handleType; + handle = copy_src.handle; + name = copy_src.name; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkDisplayPlaneProperties2KHR& safe_VkDisplayPlaneProperties2KHR::operator=(const safe_VkDisplayPlaneProperties2KHR& copy_src) { +safe_VkImportSemaphoreWin32HandleInfoKHR& safe_VkImportSemaphoreWin32HandleInfoKHR::operator=( + const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - displayPlaneProperties = copy_src.displayPlaneProperties; + semaphore = copy_src.semaphore; + flags = copy_src.flags; + handleType = copy_src.handleType; + handle = copy_src.handle; + name = copy_src.name; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkDisplayPlaneProperties2KHR::~safe_VkDisplayPlaneProperties2KHR() { FreePnextChain(pNext); } +safe_VkImportSemaphoreWin32HandleInfoKHR::~safe_VkImportSemaphoreWin32HandleInfoKHR() { FreePnextChain(pNext); } -void safe_VkDisplayPlaneProperties2KHR::initialize(const VkDisplayPlaneProperties2KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkImportSemaphoreWin32HandleInfoKHR::initialize(const VkImportSemaphoreWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - displayPlaneProperties = in_struct->displayPlaneProperties; + semaphore = in_struct->semaphore; + flags = in_struct->flags; + handleType = in_struct->handleType; + handle = in_struct->handle; + name = in_struct->name; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkDisplayPlaneProperties2KHR::initialize(const safe_VkDisplayPlaneProperties2KHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkImportSemaphoreWin32HandleInfoKHR::initialize(const safe_VkImportSemaphoreWin32HandleInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - displayPlaneProperties = copy_src->displayPlaneProperties; + semaphore = copy_src->semaphore; + flags = copy_src->flags; + handleType = copy_src->handleType; + handle = copy_src->handle; + name = copy_src->name; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkDisplayModeProperties2KHR::safe_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), displayModeProperties(in_struct->displayModeProperties) { +safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR( + const VkExportSemaphoreWin32HandleInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pAttributes(nullptr), dwAccess(in_struct->dwAccess), name(in_struct->name) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + if (in_struct->pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes); + } } -safe_VkDisplayModeProperties2KHR::safe_VkDisplayModeProperties2KHR() - : sType(VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR), pNext(nullptr), displayModeProperties() {} +safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR() + : sType(VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR), pNext(nullptr), pAttributes(nullptr), dwAccess(), name() {} -safe_VkDisplayModeProperties2KHR::safe_VkDisplayModeProperties2KHR(const safe_VkDisplayModeProperties2KHR& copy_src) { +safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR( + const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src) { sType = copy_src.sType; - displayModeProperties = copy_src.displayModeProperties; + pAttributes = nullptr; + dwAccess = copy_src.dwAccess; + name = copy_src.name; pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes); + } } -safe_VkDisplayModeProperties2KHR& safe_VkDisplayModeProperties2KHR::operator=(const safe_VkDisplayModeProperties2KHR& copy_src) { +safe_VkExportSemaphoreWin32HandleInfoKHR& safe_VkExportSemaphoreWin32HandleInfoKHR::operator=( + const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src) { if (©_src == this) return *this; + if (pAttributes) delete pAttributes; FreePnextChain(pNext); sType = copy_src.sType; - displayModeProperties = copy_src.displayModeProperties; + pAttributes = nullptr; + dwAccess = copy_src.dwAccess; + name = copy_src.name; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes); + } + return *this; } -safe_VkDisplayModeProperties2KHR::~safe_VkDisplayModeProperties2KHR() { FreePnextChain(pNext); } +safe_VkExportSemaphoreWin32HandleInfoKHR::~safe_VkExportSemaphoreWin32HandleInfoKHR() { + if (pAttributes) delete pAttributes; + FreePnextChain(pNext); +} -void safe_VkDisplayModeProperties2KHR::initialize(const VkDisplayModeProperties2KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkExportSemaphoreWin32HandleInfoKHR::initialize(const VkExportSemaphoreWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pAttributes) delete pAttributes; FreePnextChain(pNext); sType = in_struct->sType; - displayModeProperties = in_struct->displayModeProperties; + pAttributes = nullptr; + dwAccess = in_struct->dwAccess; + name = in_struct->name; pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes); + } } -void safe_VkDisplayModeProperties2KHR::initialize(const safe_VkDisplayModeProperties2KHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkExportSemaphoreWin32HandleInfoKHR::initialize(const safe_VkExportSemaphoreWin32HandleInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - displayModeProperties = copy_src->displayModeProperties; + pAttributes = nullptr; + dwAccess = copy_src->dwAccess; + name = copy_src->name; pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*copy_src->pAttributes); + } } -safe_VkDisplayPlaneInfo2KHR::safe_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), mode(in_struct->mode), planeIndex(in_struct->planeIndex) { +safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + waitSemaphoreValuesCount(in_struct->waitSemaphoreValuesCount), + pWaitSemaphoreValues(nullptr), + signalSemaphoreValuesCount(in_struct->signalSemaphoreValuesCount), + pSignalSemaphoreValues(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } -} + if (in_struct->pWaitSemaphoreValues) { + pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValuesCount]; + memcpy((void*)pWaitSemaphoreValues, (void*)in_struct->pWaitSemaphoreValues, + sizeof(uint64_t) * in_struct->waitSemaphoreValuesCount); + } -safe_VkDisplayPlaneInfo2KHR::safe_VkDisplayPlaneInfo2KHR() - : sType(VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR), pNext(nullptr), mode(), planeIndex() {} + if (in_struct->pSignalSemaphoreValues) { + pSignalSemaphoreValues = new uint64_t[in_struct->signalSemaphoreValuesCount]; + memcpy((void*)pSignalSemaphoreValues, (void*)in_struct->pSignalSemaphoreValues, + sizeof(uint64_t) * in_struct->signalSemaphoreValuesCount); + } +} -safe_VkDisplayPlaneInfo2KHR::safe_VkDisplayPlaneInfo2KHR(const safe_VkDisplayPlaneInfo2KHR& copy_src) { +safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR() + : sType(VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR), + pNext(nullptr), + waitSemaphoreValuesCount(), + pWaitSemaphoreValues(nullptr), + signalSemaphoreValuesCount(), + pSignalSemaphoreValues(nullptr) {} + +safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR(const safe_VkD3D12FenceSubmitInfoKHR& copy_src) { sType = copy_src.sType; - mode = copy_src.mode; - planeIndex = copy_src.planeIndex; + waitSemaphoreValuesCount = copy_src.waitSemaphoreValuesCount; + pWaitSemaphoreValues = nullptr; + signalSemaphoreValuesCount = copy_src.signalSemaphoreValuesCount; + pSignalSemaphoreValues = nullptr; pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pWaitSemaphoreValues) { + pWaitSemaphoreValues = new uint64_t[copy_src.waitSemaphoreValuesCount]; + memcpy((void*)pWaitSemaphoreValues, (void*)copy_src.pWaitSemaphoreValues, + sizeof(uint64_t) * copy_src.waitSemaphoreValuesCount); + } + + if (copy_src.pSignalSemaphoreValues) { + pSignalSemaphoreValues = new uint64_t[copy_src.signalSemaphoreValuesCount]; + memcpy((void*)pSignalSemaphoreValues, (void*)copy_src.pSignalSemaphoreValues, + sizeof(uint64_t) * copy_src.signalSemaphoreValuesCount); + } } -safe_VkDisplayPlaneInfo2KHR& safe_VkDisplayPlaneInfo2KHR::operator=(const safe_VkDisplayPlaneInfo2KHR& copy_src) { +safe_VkD3D12FenceSubmitInfoKHR& safe_VkD3D12FenceSubmitInfoKHR::operator=(const safe_VkD3D12FenceSubmitInfoKHR& copy_src) { if (©_src == this) return *this; + if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues; + if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues; FreePnextChain(pNext); sType = copy_src.sType; - mode = copy_src.mode; - planeIndex = copy_src.planeIndex; + waitSemaphoreValuesCount = copy_src.waitSemaphoreValuesCount; + pWaitSemaphoreValues = nullptr; + signalSemaphoreValuesCount = copy_src.signalSemaphoreValuesCount; + pSignalSemaphoreValues = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pWaitSemaphoreValues) { + pWaitSemaphoreValues = new uint64_t[copy_src.waitSemaphoreValuesCount]; + memcpy((void*)pWaitSemaphoreValues, (void*)copy_src.pWaitSemaphoreValues, + sizeof(uint64_t) * copy_src.waitSemaphoreValuesCount); + } + + if (copy_src.pSignalSemaphoreValues) { + pSignalSemaphoreValues = new uint64_t[copy_src.signalSemaphoreValuesCount]; + memcpy((void*)pSignalSemaphoreValues, (void*)copy_src.pSignalSemaphoreValues, + sizeof(uint64_t) * copy_src.signalSemaphoreValuesCount); + } + return *this; } -safe_VkDisplayPlaneInfo2KHR::~safe_VkDisplayPlaneInfo2KHR() { FreePnextChain(pNext); } +safe_VkD3D12FenceSubmitInfoKHR::~safe_VkD3D12FenceSubmitInfoKHR() { + if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues; + if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues; + FreePnextChain(pNext); +} -void safe_VkDisplayPlaneInfo2KHR::initialize(const VkDisplayPlaneInfo2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkD3D12FenceSubmitInfoKHR::initialize(const VkD3D12FenceSubmitInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues; + if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues; FreePnextChain(pNext); sType = in_struct->sType; - mode = in_struct->mode; - planeIndex = in_struct->planeIndex; + waitSemaphoreValuesCount = in_struct->waitSemaphoreValuesCount; + pWaitSemaphoreValues = nullptr; + signalSemaphoreValuesCount = in_struct->signalSemaphoreValuesCount; + pSignalSemaphoreValues = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pWaitSemaphoreValues) { + pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValuesCount]; + memcpy((void*)pWaitSemaphoreValues, (void*)in_struct->pWaitSemaphoreValues, + sizeof(uint64_t) * in_struct->waitSemaphoreValuesCount); + } + + if (in_struct->pSignalSemaphoreValues) { + pSignalSemaphoreValues = new uint64_t[in_struct->signalSemaphoreValuesCount]; + memcpy((void*)pSignalSemaphoreValues, (void*)in_struct->pSignalSemaphoreValues, + sizeof(uint64_t) * in_struct->signalSemaphoreValuesCount); + } } -void safe_VkDisplayPlaneInfo2KHR::initialize(const safe_VkDisplayPlaneInfo2KHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkD3D12FenceSubmitInfoKHR::initialize(const safe_VkD3D12FenceSubmitInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - mode = copy_src->mode; - planeIndex = copy_src->planeIndex; + waitSemaphoreValuesCount = copy_src->waitSemaphoreValuesCount; + pWaitSemaphoreValues = nullptr; + signalSemaphoreValuesCount = copy_src->signalSemaphoreValuesCount; + pSignalSemaphoreValues = nullptr; pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pWaitSemaphoreValues) { + pWaitSemaphoreValues = new uint64_t[copy_src->waitSemaphoreValuesCount]; + memcpy((void*)pWaitSemaphoreValues, (void*)copy_src->pWaitSemaphoreValues, + sizeof(uint64_t) * copy_src->waitSemaphoreValuesCount); + } + + if (copy_src->pSignalSemaphoreValues) { + pSignalSemaphoreValues = new uint64_t[copy_src->signalSemaphoreValuesCount]; + memcpy((void*)pSignalSemaphoreValues, (void*)copy_src->pSignalSemaphoreValues, + sizeof(uint64_t) * copy_src->signalSemaphoreValuesCount); + } } -safe_VkDisplayPlaneCapabilities2KHR::safe_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), capabilities(in_struct->capabilities) { +safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), semaphore(in_struct->semaphore), handleType(in_struct->handleType) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkDisplayPlaneCapabilities2KHR::safe_VkDisplayPlaneCapabilities2KHR() - : sType(VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR), pNext(nullptr), capabilities() {} +safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR() + : sType(VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR), pNext(nullptr), semaphore(), handleType() {} -safe_VkDisplayPlaneCapabilities2KHR::safe_VkDisplayPlaneCapabilities2KHR(const safe_VkDisplayPlaneCapabilities2KHR& copy_src) { +safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR( + const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src) { sType = copy_src.sType; - capabilities = copy_src.capabilities; + semaphore = copy_src.semaphore; + handleType = copy_src.handleType; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkDisplayPlaneCapabilities2KHR& safe_VkDisplayPlaneCapabilities2KHR::operator=( - const safe_VkDisplayPlaneCapabilities2KHR& copy_src) { +safe_VkSemaphoreGetWin32HandleInfoKHR& safe_VkSemaphoreGetWin32HandleInfoKHR::operator=( + const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - capabilities = copy_src.capabilities; + semaphore = copy_src.semaphore; + handleType = copy_src.handleType; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkDisplayPlaneCapabilities2KHR::~safe_VkDisplayPlaneCapabilities2KHR() { FreePnextChain(pNext); } +safe_VkSemaphoreGetWin32HandleInfoKHR::~safe_VkSemaphoreGetWin32HandleInfoKHR() { FreePnextChain(pNext); } -void safe_VkDisplayPlaneCapabilities2KHR::initialize(const VkDisplayPlaneCapabilities2KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkSemaphoreGetWin32HandleInfoKHR::initialize(const VkSemaphoreGetWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - capabilities = in_struct->capabilities; + semaphore = in_struct->semaphore; + handleType = in_struct->handleType; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkDisplayPlaneCapabilities2KHR::initialize(const safe_VkDisplayPlaneCapabilities2KHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkSemaphoreGetWin32HandleInfoKHR::initialize(const safe_VkSemaphoreGetWin32HandleInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - capabilities = copy_src->capabilities; + semaphore = copy_src->semaphore; + handleType = copy_src->handleType; pNext = SafePnextCopy(copy_src->pNext); } -#ifdef VK_ENABLE_BETA_EXTENSIONS +#endif // VK_USE_PLATFORM_WIN32_KHR -safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR( - const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), - constantAlphaColorBlendFactors(in_struct->constantAlphaColorBlendFactors), - events(in_struct->events), - imageViewFormatReinterpretation(in_struct->imageViewFormatReinterpretation), - imageViewFormatSwizzle(in_struct->imageViewFormatSwizzle), - imageView2DOn3DImage(in_struct->imageView2DOn3DImage), - multisampleArrayImage(in_struct->multisampleArrayImage), - mutableComparisonSamplers(in_struct->mutableComparisonSamplers), - pointPolygons(in_struct->pointPolygons), - samplerMipLodBias(in_struct->samplerMipLodBias), - separateStencilMaskRef(in_struct->separateStencilMaskRef), - shaderSampleRateInterpolationFunctions(in_struct->shaderSampleRateInterpolationFunctions), - tessellationIsolines(in_struct->tessellationIsolines), - tessellationPointMode(in_struct->tessellationPointMode), - triangleFans(in_struct->triangleFans), - vertexAttributeAccessBeyondStride(in_struct->vertexAttributeAccessBeyondStride) { + semaphore(in_struct->semaphore), + flags(in_struct->flags), + handleType(in_struct->handleType), + fd(in_struct->fd) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR), - pNext(nullptr), - constantAlphaColorBlendFactors(), - events(), - imageViewFormatReinterpretation(), - imageViewFormatSwizzle(), - imageView2DOn3DImage(), - multisampleArrayImage(), - mutableComparisonSamplers(), - pointPolygons(), - samplerMipLodBias(), - separateStencilMaskRef(), - shaderSampleRateInterpolationFunctions(), - tessellationIsolines(), - tessellationPointMode(), - triangleFans(), - vertexAttributeAccessBeyondStride() {} +safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR() + : sType(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR), pNext(nullptr), semaphore(), flags(), handleType(), fd() {} -safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR( - const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src) { +safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR(const safe_VkImportSemaphoreFdInfoKHR& copy_src) { sType = copy_src.sType; - constantAlphaColorBlendFactors = copy_src.constantAlphaColorBlendFactors; - events = copy_src.events; - imageViewFormatReinterpretation = copy_src.imageViewFormatReinterpretation; - imageViewFormatSwizzle = copy_src.imageViewFormatSwizzle; - imageView2DOn3DImage = copy_src.imageView2DOn3DImage; - multisampleArrayImage = copy_src.multisampleArrayImage; - mutableComparisonSamplers = copy_src.mutableComparisonSamplers; - pointPolygons = copy_src.pointPolygons; - samplerMipLodBias = copy_src.samplerMipLodBias; - separateStencilMaskRef = copy_src.separateStencilMaskRef; - shaderSampleRateInterpolationFunctions = copy_src.shaderSampleRateInterpolationFunctions; - tessellationIsolines = copy_src.tessellationIsolines; - tessellationPointMode = copy_src.tessellationPointMode; - triangleFans = copy_src.triangleFans; - vertexAttributeAccessBeyondStride = copy_src.vertexAttributeAccessBeyondStride; + semaphore = copy_src.semaphore; + flags = copy_src.flags; + handleType = copy_src.handleType; + fd = copy_src.fd; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::operator=( - const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src) { +safe_VkImportSemaphoreFdInfoKHR& safe_VkImportSemaphoreFdInfoKHR::operator=(const safe_VkImportSemaphoreFdInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - constantAlphaColorBlendFactors = copy_src.constantAlphaColorBlendFactors; - events = copy_src.events; - imageViewFormatReinterpretation = copy_src.imageViewFormatReinterpretation; - imageViewFormatSwizzle = copy_src.imageViewFormatSwizzle; - imageView2DOn3DImage = copy_src.imageView2DOn3DImage; - multisampleArrayImage = copy_src.multisampleArrayImage; - mutableComparisonSamplers = copy_src.mutableComparisonSamplers; - pointPolygons = copy_src.pointPolygons; - samplerMipLodBias = copy_src.samplerMipLodBias; - separateStencilMaskRef = copy_src.separateStencilMaskRef; - shaderSampleRateInterpolationFunctions = copy_src.shaderSampleRateInterpolationFunctions; - tessellationIsolines = copy_src.tessellationIsolines; - tessellationPointMode = copy_src.tessellationPointMode; - triangleFans = copy_src.triangleFans; - vertexAttributeAccessBeyondStride = copy_src.vertexAttributeAccessBeyondStride; + semaphore = copy_src.semaphore; + flags = copy_src.flags; + handleType = copy_src.handleType; + fd = copy_src.fd; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::~safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR() { FreePnextChain(pNext); } +safe_VkImportSemaphoreFdInfoKHR::~safe_VkImportSemaphoreFdInfoKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::initialize(const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkImportSemaphoreFdInfoKHR::initialize(const VkImportSemaphoreFdInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - constantAlphaColorBlendFactors = in_struct->constantAlphaColorBlendFactors; - events = in_struct->events; - imageViewFormatReinterpretation = in_struct->imageViewFormatReinterpretation; - imageViewFormatSwizzle = in_struct->imageViewFormatSwizzle; - imageView2DOn3DImage = in_struct->imageView2DOn3DImage; - multisampleArrayImage = in_struct->multisampleArrayImage; - mutableComparisonSamplers = in_struct->mutableComparisonSamplers; - pointPolygons = in_struct->pointPolygons; - samplerMipLodBias = in_struct->samplerMipLodBias; - separateStencilMaskRef = in_struct->separateStencilMaskRef; - shaderSampleRateInterpolationFunctions = in_struct->shaderSampleRateInterpolationFunctions; - tessellationIsolines = in_struct->tessellationIsolines; - tessellationPointMode = in_struct->tessellationPointMode; - triangleFans = in_struct->triangleFans; - vertexAttributeAccessBeyondStride = in_struct->vertexAttributeAccessBeyondStride; + semaphore = in_struct->semaphore; + flags = in_struct->flags; + handleType = in_struct->handleType; + fd = in_struct->fd; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::initialize( - const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkImportSemaphoreFdInfoKHR::initialize(const safe_VkImportSemaphoreFdInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - constantAlphaColorBlendFactors = copy_src->constantAlphaColorBlendFactors; - events = copy_src->events; - imageViewFormatReinterpretation = copy_src->imageViewFormatReinterpretation; - imageViewFormatSwizzle = copy_src->imageViewFormatSwizzle; - imageView2DOn3DImage = copy_src->imageView2DOn3DImage; - multisampleArrayImage = copy_src->multisampleArrayImage; - mutableComparisonSamplers = copy_src->mutableComparisonSamplers; - pointPolygons = copy_src->pointPolygons; - samplerMipLodBias = copy_src->samplerMipLodBias; - separateStencilMaskRef = copy_src->separateStencilMaskRef; - shaderSampleRateInterpolationFunctions = copy_src->shaderSampleRateInterpolationFunctions; - tessellationIsolines = copy_src->tessellationIsolines; - tessellationPointMode = copy_src->tessellationPointMode; - triangleFans = copy_src->triangleFans; - vertexAttributeAccessBeyondStride = copy_src->vertexAttributeAccessBeyondStride; + semaphore = copy_src->semaphore; + flags = copy_src->flags; + handleType = copy_src->handleType; + fd = copy_src->fd; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR( - const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), minVertexInputBindingStrideAlignment(in_struct->minVertexInputBindingStrideAlignment) { +safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), semaphore(in_struct->semaphore), handleType(in_struct->handleType) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR), - pNext(nullptr), - minVertexInputBindingStrideAlignment() {} +safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR() + : sType(VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR), pNext(nullptr), semaphore(), handleType() {} -safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR( - const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src) { +safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR(const safe_VkSemaphoreGetFdInfoKHR& copy_src) { sType = copy_src.sType; - minVertexInputBindingStrideAlignment = copy_src.minVertexInputBindingStrideAlignment; + semaphore = copy_src.semaphore; + handleType = copy_src.handleType; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::operator=( - const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src) { +safe_VkSemaphoreGetFdInfoKHR& safe_VkSemaphoreGetFdInfoKHR::operator=(const safe_VkSemaphoreGetFdInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - minVertexInputBindingStrideAlignment = copy_src.minVertexInputBindingStrideAlignment; + semaphore = copy_src.semaphore; + handleType = copy_src.handleType; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::~safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR() { - FreePnextChain(pNext); -} +safe_VkSemaphoreGetFdInfoKHR::~safe_VkSemaphoreGetFdInfoKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::initialize( - const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkSemaphoreGetFdInfoKHR::initialize(const VkSemaphoreGetFdInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - minVertexInputBindingStrideAlignment = in_struct->minVertexInputBindingStrideAlignment; + semaphore = in_struct->semaphore; + handleType = in_struct->handleType; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::initialize( - const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkSemaphoreGetFdInfoKHR::initialize(const safe_VkSemaphoreGetFdInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - minVertexInputBindingStrideAlignment = copy_src->minVertexInputBindingStrideAlignment; + semaphore = copy_src->semaphore; + handleType = copy_src->handleType; pNext = SafePnextCopy(copy_src->pNext); } -#endif // VK_ENABLE_BETA_EXTENSIONS -safe_VkPhysicalDeviceShaderClockFeaturesKHR::safe_VkPhysicalDeviceShaderClockFeaturesKHR( - const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - shaderSubgroupClock(in_struct->shaderSubgroupClock), - shaderDeviceClock(in_struct->shaderDeviceClock) { +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_VkPhysicalDeviceShaderClockFeaturesKHR::safe_VkPhysicalDeviceShaderClockFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR), - pNext(nullptr), - shaderSubgroupClock(), - shaderDeviceClock() {} +safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR), pNext(nullptr), maxPushDescriptors() {} -safe_VkPhysicalDeviceShaderClockFeaturesKHR::safe_VkPhysicalDeviceShaderClockFeaturesKHR( - const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src) { +safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR( + const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src) { sType = copy_src.sType; - shaderSubgroupClock = copy_src.shaderSubgroupClock; - shaderDeviceClock = copy_src.shaderDeviceClock; + maxPushDescriptors = copy_src.maxPushDescriptors; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceShaderClockFeaturesKHR& safe_VkPhysicalDeviceShaderClockFeaturesKHR::operator=( - const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src) { +safe_VkPhysicalDevicePushDescriptorPropertiesKHR& safe_VkPhysicalDevicePushDescriptorPropertiesKHR::operator=( + const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - shaderSubgroupClock = copy_src.shaderSubgroupClock; - shaderDeviceClock = copy_src.shaderDeviceClock; + maxPushDescriptors = copy_src.maxPushDescriptors; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceShaderClockFeaturesKHR::~safe_VkPhysicalDeviceShaderClockFeaturesKHR() { FreePnextChain(pNext); } +safe_VkPhysicalDevicePushDescriptorPropertiesKHR::~safe_VkPhysicalDevicePushDescriptorPropertiesKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceShaderClockFeaturesKHR::initialize(const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - shaderSubgroupClock = in_struct->shaderSubgroupClock; - shaderDeviceClock = in_struct->shaderDeviceClock; + maxPushDescriptors = in_struct->maxPushDescriptors; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceShaderClockFeaturesKHR::initialize(const safe_VkPhysicalDeviceShaderClockFeaturesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - shaderSubgroupClock = copy_src->shaderSubgroupClock; - shaderDeviceClock = copy_src->shaderDeviceClock; + maxPushDescriptors = copy_src->maxPushDescriptors; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkVideoDecodeH265ProfileInfoKHR::safe_VkVideoDecodeH265ProfileInfoKHR(const VkVideoDecodeH265ProfileInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), stdProfileIdc(in_struct->stdProfileIdc) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); +safe_VkPresentRegionKHR::safe_VkPresentRegionKHR(const VkPresentRegionKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) + : rectangleCount(in_struct->rectangleCount), pRectangles(nullptr) { + if (in_struct->pRectangles) { + pRectangles = new VkRectLayerKHR[in_struct->rectangleCount]; + memcpy((void*)pRectangles, (void*)in_struct->pRectangles, sizeof(VkRectLayerKHR) * in_struct->rectangleCount); } } -safe_VkVideoDecodeH265ProfileInfoKHR::safe_VkVideoDecodeH265ProfileInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR), pNext(nullptr), stdProfileIdc() {} +safe_VkPresentRegionKHR::safe_VkPresentRegionKHR() : rectangleCount(), pRectangles(nullptr) {} -safe_VkVideoDecodeH265ProfileInfoKHR::safe_VkVideoDecodeH265ProfileInfoKHR(const safe_VkVideoDecodeH265ProfileInfoKHR& copy_src) { - sType = copy_src.sType; - stdProfileIdc = copy_src.stdProfileIdc; - pNext = SafePnextCopy(copy_src.pNext); +safe_VkPresentRegionKHR::safe_VkPresentRegionKHR(const safe_VkPresentRegionKHR& copy_src) { + rectangleCount = copy_src.rectangleCount; + pRectangles = nullptr; + + if (copy_src.pRectangles) { + pRectangles = new VkRectLayerKHR[copy_src.rectangleCount]; + memcpy((void*)pRectangles, (void*)copy_src.pRectangles, sizeof(VkRectLayerKHR) * copy_src.rectangleCount); + } } -safe_VkVideoDecodeH265ProfileInfoKHR& safe_VkVideoDecodeH265ProfileInfoKHR::operator=( - const safe_VkVideoDecodeH265ProfileInfoKHR& copy_src) { +safe_VkPresentRegionKHR& safe_VkPresentRegionKHR::operator=(const safe_VkPresentRegionKHR& copy_src) { if (©_src == this) return *this; - FreePnextChain(pNext); + if (pRectangles) delete[] pRectangles; - sType = copy_src.sType; - stdProfileIdc = copy_src.stdProfileIdc; - pNext = SafePnextCopy(copy_src.pNext); + rectangleCount = copy_src.rectangleCount; + pRectangles = nullptr; + + if (copy_src.pRectangles) { + pRectangles = new VkRectLayerKHR[copy_src.rectangleCount]; + memcpy((void*)pRectangles, (void*)copy_src.pRectangles, sizeof(VkRectLayerKHR) * copy_src.rectangleCount); + } return *this; } -safe_VkVideoDecodeH265ProfileInfoKHR::~safe_VkVideoDecodeH265ProfileInfoKHR() { FreePnextChain(pNext); } +safe_VkPresentRegionKHR::~safe_VkPresentRegionKHR() { + if (pRectangles) delete[] pRectangles; +} -void safe_VkVideoDecodeH265ProfileInfoKHR::initialize(const VkVideoDecodeH265ProfileInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - stdProfileIdc = in_struct->stdProfileIdc; - pNext = SafePnextCopy(in_struct->pNext, copy_state); +void safe_VkPresentRegionKHR::initialize(const VkPresentRegionKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pRectangles) delete[] pRectangles; + rectangleCount = in_struct->rectangleCount; + pRectangles = nullptr; + + if (in_struct->pRectangles) { + pRectangles = new VkRectLayerKHR[in_struct->rectangleCount]; + memcpy((void*)pRectangles, (void*)in_struct->pRectangles, sizeof(VkRectLayerKHR) * in_struct->rectangleCount); + } } -void safe_VkVideoDecodeH265ProfileInfoKHR::initialize(const safe_VkVideoDecodeH265ProfileInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - stdProfileIdc = copy_src->stdProfileIdc; - pNext = SafePnextCopy(copy_src->pNext); +void safe_VkPresentRegionKHR::initialize(const safe_VkPresentRegionKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + rectangleCount = copy_src->rectangleCount; + pRectangles = nullptr; + + if (copy_src->pRectangles) { + pRectangles = new VkRectLayerKHR[copy_src->rectangleCount]; + memcpy((void*)pRectangles, (void*)copy_src->pRectangles, sizeof(VkRectLayerKHR) * copy_src->rectangleCount); + } } -safe_VkVideoDecodeH265CapabilitiesKHR::safe_VkVideoDecodeH265CapabilitiesKHR(const VkVideoDecodeH265CapabilitiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), maxLevelIdc(in_struct->maxLevelIdc) { +safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR(const VkPresentRegionsKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pRegions(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + if (swapchainCount && in_struct->pRegions) { + pRegions = new safe_VkPresentRegionKHR[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } } -safe_VkVideoDecodeH265CapabilitiesKHR::safe_VkVideoDecodeH265CapabilitiesKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR), pNext(nullptr), maxLevelIdc() {} +safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR() + : sType(VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR), pNext(nullptr), swapchainCount(), pRegions(nullptr) {} -safe_VkVideoDecodeH265CapabilitiesKHR::safe_VkVideoDecodeH265CapabilitiesKHR( - const safe_VkVideoDecodeH265CapabilitiesKHR& copy_src) { +safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR(const safe_VkPresentRegionsKHR& copy_src) { sType = copy_src.sType; - maxLevelIdc = copy_src.maxLevelIdc; + swapchainCount = copy_src.swapchainCount; + pRegions = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (swapchainCount && copy_src.pRegions) { + pRegions = new safe_VkPresentRegionKHR[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } } -safe_VkVideoDecodeH265CapabilitiesKHR& safe_VkVideoDecodeH265CapabilitiesKHR::operator=( - const safe_VkVideoDecodeH265CapabilitiesKHR& copy_src) { +safe_VkPresentRegionsKHR& safe_VkPresentRegionsKHR::operator=(const safe_VkPresentRegionsKHR& copy_src) { if (©_src == this) return *this; + if (pRegions) delete[] pRegions; FreePnextChain(pNext); sType = copy_src.sType; - maxLevelIdc = copy_src.maxLevelIdc; + swapchainCount = copy_src.swapchainCount; + pRegions = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (swapchainCount && copy_src.pRegions) { + pRegions = new safe_VkPresentRegionKHR[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } return *this; } -safe_VkVideoDecodeH265CapabilitiesKHR::~safe_VkVideoDecodeH265CapabilitiesKHR() { FreePnextChain(pNext); } +safe_VkPresentRegionsKHR::~safe_VkPresentRegionsKHR() { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); +} -void safe_VkVideoDecodeH265CapabilitiesKHR::initialize(const VkVideoDecodeH265CapabilitiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPresentRegionsKHR::initialize(const VkPresentRegionsKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pRegions) delete[] pRegions; FreePnextChain(pNext); sType = in_struct->sType; - maxLevelIdc = in_struct->maxLevelIdc; + swapchainCount = in_struct->swapchainCount; + pRegions = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (swapchainCount && in_struct->pRegions) { + pRegions = new safe_VkPresentRegionKHR[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } } -void safe_VkVideoDecodeH265CapabilitiesKHR::initialize(const safe_VkVideoDecodeH265CapabilitiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPresentRegionsKHR::initialize(const safe_VkPresentRegionsKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - maxLevelIdc = copy_src->maxLevelIdc; + swapchainCount = copy_src->swapchainCount; + pRegions = nullptr; pNext = SafePnextCopy(copy_src->pNext); + if (swapchainCount && copy_src->pRegions) { + pRegions = new safe_VkPresentRegionKHR[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pRegions[i].initialize(©_src->pRegions[i]); + } + } } -safe_VkVideoDecodeH265SessionParametersAddInfoKHR::safe_VkVideoDecodeH265SessionParametersAddInfoKHR( - const VkVideoDecodeH265SessionParametersAddInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - stdVPSCount(in_struct->stdVPSCount), - pStdVPSs(nullptr), - stdSPSCount(in_struct->stdSPSCount), - pStdSPSs(nullptr), - stdPPSCount(in_struct->stdPPSCount), - pStdPPSs(nullptr) { +safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR( + const VkSharedPresentSurfaceCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), sharedPresentSupportedUsageFlags(in_struct->sharedPresentSupportedUsageFlags) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pStdVPSs) { - pStdVPSs = new StdVideoH265VideoParameterSet[in_struct->stdVPSCount]; - memcpy((void*)pStdVPSs, (void*)in_struct->pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * in_struct->stdVPSCount); - } - - if (in_struct->pStdSPSs) { - pStdSPSs = new StdVideoH265SequenceParameterSet[in_struct->stdSPSCount]; - memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * in_struct->stdSPSCount); - } - - if (in_struct->pStdPPSs) { - pStdPPSs = new StdVideoH265PictureParameterSet[in_struct->stdPPSCount]; - memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * in_struct->stdPPSCount); - } } -safe_VkVideoDecodeH265SessionParametersAddInfoKHR::safe_VkVideoDecodeH265SessionParametersAddInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR), - pNext(nullptr), - stdVPSCount(), - pStdVPSs(nullptr), - stdSPSCount(), - pStdSPSs(nullptr), - stdPPSCount(), - pStdPPSs(nullptr) {} +safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR() + : sType(VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR), pNext(nullptr), sharedPresentSupportedUsageFlags() {} -safe_VkVideoDecodeH265SessionParametersAddInfoKHR::safe_VkVideoDecodeH265SessionParametersAddInfoKHR( - const safe_VkVideoDecodeH265SessionParametersAddInfoKHR& copy_src) { +safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR( + const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src) { sType = copy_src.sType; - stdVPSCount = copy_src.stdVPSCount; - pStdVPSs = nullptr; - stdSPSCount = copy_src.stdSPSCount; - pStdSPSs = nullptr; - stdPPSCount = copy_src.stdPPSCount; - pStdPPSs = nullptr; + sharedPresentSupportedUsageFlags = copy_src.sharedPresentSupportedUsageFlags; pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdVPSs) { - pStdVPSs = new StdVideoH265VideoParameterSet[copy_src.stdVPSCount]; - memcpy((void*)pStdVPSs, (void*)copy_src.pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * copy_src.stdVPSCount); - } - - if (copy_src.pStdSPSs) { - pStdSPSs = new StdVideoH265SequenceParameterSet[copy_src.stdSPSCount]; - memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * copy_src.stdSPSCount); - } - - if (copy_src.pStdPPSs) { - pStdPPSs = new StdVideoH265PictureParameterSet[copy_src.stdPPSCount]; - memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * copy_src.stdPPSCount); - } } -safe_VkVideoDecodeH265SessionParametersAddInfoKHR& safe_VkVideoDecodeH265SessionParametersAddInfoKHR::operator=( - const safe_VkVideoDecodeH265SessionParametersAddInfoKHR& copy_src) { +safe_VkSharedPresentSurfaceCapabilitiesKHR& safe_VkSharedPresentSurfaceCapabilitiesKHR::operator=( + const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src) { if (©_src == this) return *this; - if (pStdVPSs) delete[] pStdVPSs; - if (pStdSPSs) delete[] pStdSPSs; - if (pStdPPSs) delete[] pStdPPSs; FreePnextChain(pNext); sType = copy_src.sType; - stdVPSCount = copy_src.stdVPSCount; - pStdVPSs = nullptr; - stdSPSCount = copy_src.stdSPSCount; - pStdSPSs = nullptr; - stdPPSCount = copy_src.stdPPSCount; - pStdPPSs = nullptr; + sharedPresentSupportedUsageFlags = copy_src.sharedPresentSupportedUsageFlags; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pStdVPSs) { - pStdVPSs = new StdVideoH265VideoParameterSet[copy_src.stdVPSCount]; - memcpy((void*)pStdVPSs, (void*)copy_src.pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * copy_src.stdVPSCount); - } - - if (copy_src.pStdSPSs) { - pStdSPSs = new StdVideoH265SequenceParameterSet[copy_src.stdSPSCount]; - memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * copy_src.stdSPSCount); - } - - if (copy_src.pStdPPSs) { - pStdPPSs = new StdVideoH265PictureParameterSet[copy_src.stdPPSCount]; - memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * copy_src.stdPPSCount); - } - return *this; } -safe_VkVideoDecodeH265SessionParametersAddInfoKHR::~safe_VkVideoDecodeH265SessionParametersAddInfoKHR() { - if (pStdVPSs) delete[] pStdVPSs; - if (pStdSPSs) delete[] pStdSPSs; - if (pStdPPSs) delete[] pStdPPSs; - FreePnextChain(pNext); -} +safe_VkSharedPresentSurfaceCapabilitiesKHR::~safe_VkSharedPresentSurfaceCapabilitiesKHR() { FreePnextChain(pNext); } -void safe_VkVideoDecodeH265SessionParametersAddInfoKHR::initialize(const VkVideoDecodeH265SessionParametersAddInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pStdVPSs) delete[] pStdVPSs; - if (pStdSPSs) delete[] pStdSPSs; - if (pStdPPSs) delete[] pStdPPSs; +void safe_VkSharedPresentSurfaceCapabilitiesKHR::initialize(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - stdVPSCount = in_struct->stdVPSCount; - pStdVPSs = nullptr; - stdSPSCount = in_struct->stdSPSCount; - pStdSPSs = nullptr; - stdPPSCount = in_struct->stdPPSCount; - pStdPPSs = nullptr; + sharedPresentSupportedUsageFlags = in_struct->sharedPresentSupportedUsageFlags; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pStdVPSs) { - pStdVPSs = new StdVideoH265VideoParameterSet[in_struct->stdVPSCount]; - memcpy((void*)pStdVPSs, (void*)in_struct->pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * in_struct->stdVPSCount); - } - - if (in_struct->pStdSPSs) { - pStdSPSs = new StdVideoH265SequenceParameterSet[in_struct->stdSPSCount]; - memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * in_struct->stdSPSCount); - } - - if (in_struct->pStdPPSs) { - pStdPPSs = new StdVideoH265PictureParameterSet[in_struct->stdPPSCount]; - memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * in_struct->stdPPSCount); - } } -void safe_VkVideoDecodeH265SessionParametersAddInfoKHR::initialize( - const safe_VkVideoDecodeH265SessionParametersAddInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkSharedPresentSurfaceCapabilitiesKHR::initialize(const safe_VkSharedPresentSurfaceCapabilitiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - stdVPSCount = copy_src->stdVPSCount; - pStdVPSs = nullptr; - stdSPSCount = copy_src->stdSPSCount; - pStdSPSs = nullptr; - stdPPSCount = copy_src->stdPPSCount; - pStdPPSs = nullptr; + sharedPresentSupportedUsageFlags = copy_src->sharedPresentSupportedUsageFlags; pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pStdVPSs) { - pStdVPSs = new StdVideoH265VideoParameterSet[copy_src->stdVPSCount]; - memcpy((void*)pStdVPSs, (void*)copy_src->pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * copy_src->stdVPSCount); - } - - if (copy_src->pStdSPSs) { - pStdSPSs = new StdVideoH265SequenceParameterSet[copy_src->stdSPSCount]; - memcpy((void*)pStdSPSs, (void*)copy_src->pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * copy_src->stdSPSCount); - } - - if (copy_src->pStdPPSs) { - pStdPPSs = new StdVideoH265PictureParameterSet[copy_src->stdPPSCount]; - memcpy((void*)pStdPPSs, (void*)copy_src->pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * copy_src->stdPPSCount); - } } +#ifdef VK_USE_PLATFORM_WIN32_KHR -safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::safe_VkVideoDecodeH265SessionParametersCreateInfoKHR( - const VkVideoDecodeH265SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) : sType(in_struct->sType), - maxStdVPSCount(in_struct->maxStdVPSCount), - maxStdSPSCount(in_struct->maxStdSPSCount), - maxStdPPSCount(in_struct->maxStdPPSCount), - pParametersAddInfo(nullptr) { + fence(in_struct->fence), + flags(in_struct->flags), + handleType(in_struct->handleType), + handle(in_struct->handle), + name(in_struct->name) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoKHR(in_struct->pParametersAddInfo); } -safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::safe_VkVideoDecodeH265SessionParametersCreateInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR), +safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR() + : sType(VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR), pNext(nullptr), - maxStdVPSCount(), - maxStdSPSCount(), - maxStdPPSCount(), - pParametersAddInfo(nullptr) {} + fence(), + flags(), + handleType(), + handle(), + name() {} -safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::safe_VkVideoDecodeH265SessionParametersCreateInfoKHR( - const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& copy_src) { +safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR(const safe_VkImportFenceWin32HandleInfoKHR& copy_src) { sType = copy_src.sType; - maxStdVPSCount = copy_src.maxStdVPSCount; - maxStdSPSCount = copy_src.maxStdSPSCount; - maxStdPPSCount = copy_src.maxStdPPSCount; - pParametersAddInfo = nullptr; + fence = copy_src.fence; + flags = copy_src.flags; + handleType = copy_src.handleType; + handle = copy_src.handle; + name = copy_src.name; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo); } -safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::operator=( - const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& copy_src) { +safe_VkImportFenceWin32HandleInfoKHR& safe_VkImportFenceWin32HandleInfoKHR::operator=( + const safe_VkImportFenceWin32HandleInfoKHR& copy_src) { if (©_src == this) return *this; - if (pParametersAddInfo) delete pParametersAddInfo; FreePnextChain(pNext); sType = copy_src.sType; - maxStdVPSCount = copy_src.maxStdVPSCount; - maxStdSPSCount = copy_src.maxStdSPSCount; - maxStdPPSCount = copy_src.maxStdPPSCount; - pParametersAddInfo = nullptr; + fence = copy_src.fence; + flags = copy_src.flags; + handleType = copy_src.handleType; + handle = copy_src.handle; + name = copy_src.name; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo); return *this; } -safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::~safe_VkVideoDecodeH265SessionParametersCreateInfoKHR() { - if (pParametersAddInfo) delete pParametersAddInfo; - FreePnextChain(pNext); -} +safe_VkImportFenceWin32HandleInfoKHR::~safe_VkImportFenceWin32HandleInfoKHR() { FreePnextChain(pNext); } -void safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::initialize( - const VkVideoDecodeH265SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - if (pParametersAddInfo) delete pParametersAddInfo; +void safe_VkImportFenceWin32HandleInfoKHR::initialize(const VkImportFenceWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - maxStdVPSCount = in_struct->maxStdVPSCount; - maxStdSPSCount = in_struct->maxStdSPSCount; - maxStdPPSCount = in_struct->maxStdPPSCount; - pParametersAddInfo = nullptr; + fence = in_struct->fence; + flags = in_struct->flags; + handleType = in_struct->handleType; + handle = in_struct->handle; + name = in_struct->name; pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (in_struct->pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoKHR(in_struct->pParametersAddInfo); } -void safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::initialize( - const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkImportFenceWin32HandleInfoKHR::initialize(const safe_VkImportFenceWin32HandleInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - maxStdVPSCount = copy_src->maxStdVPSCount; - maxStdSPSCount = copy_src->maxStdSPSCount; - maxStdPPSCount = copy_src->maxStdPPSCount; - pParametersAddInfo = nullptr; + fence = copy_src->fence; + flags = copy_src->flags; + handleType = copy_src->handleType; + handle = copy_src->handle; + name = copy_src->name; pNext = SafePnextCopy(copy_src->pNext); - if (copy_src->pParametersAddInfo) - pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoKHR(*copy_src->pParametersAddInfo); } -safe_VkVideoDecodeH265PictureInfoKHR::safe_VkVideoDecodeH265PictureInfoKHR(const VkVideoDecodeH265PictureInfoKHR* in_struct, +safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - pStdPictureInfo(nullptr), - sliceSegmentCount(in_struct->sliceSegmentCount), - pSliceSegmentOffsets(nullptr) { + : sType(in_struct->sType), pAttributes(nullptr), dwAccess(in_struct->dwAccess), name(in_struct->name) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pStdPictureInfo) { - pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*in_struct->pStdPictureInfo); - } - - if (in_struct->pSliceSegmentOffsets) { - pSliceSegmentOffsets = new uint32_t[in_struct->sliceSegmentCount]; - memcpy((void*)pSliceSegmentOffsets, (void*)in_struct->pSliceSegmentOffsets, - sizeof(uint32_t) * in_struct->sliceSegmentCount); + if (in_struct->pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes); } } -safe_VkVideoDecodeH265PictureInfoKHR::safe_VkVideoDecodeH265PictureInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR), - pNext(nullptr), - pStdPictureInfo(nullptr), - sliceSegmentCount(), - pSliceSegmentOffsets(nullptr) {} +safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR() + : sType(VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR), pNext(nullptr), pAttributes(nullptr), dwAccess(), name() {} -safe_VkVideoDecodeH265PictureInfoKHR::safe_VkVideoDecodeH265PictureInfoKHR(const safe_VkVideoDecodeH265PictureInfoKHR& copy_src) { +safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR(const safe_VkExportFenceWin32HandleInfoKHR& copy_src) { sType = copy_src.sType; - pStdPictureInfo = nullptr; - sliceSegmentCount = copy_src.sliceSegmentCount; - pSliceSegmentOffsets = nullptr; + pAttributes = nullptr; + dwAccess = copy_src.dwAccess; + name = copy_src.name; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pStdPictureInfo) { - pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*copy_src.pStdPictureInfo); - } - - if (copy_src.pSliceSegmentOffsets) { - pSliceSegmentOffsets = new uint32_t[copy_src.sliceSegmentCount]; - memcpy((void*)pSliceSegmentOffsets, (void*)copy_src.pSliceSegmentOffsets, sizeof(uint32_t) * copy_src.sliceSegmentCount); + if (copy_src.pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes); } } -safe_VkVideoDecodeH265PictureInfoKHR& safe_VkVideoDecodeH265PictureInfoKHR::operator=( - const safe_VkVideoDecodeH265PictureInfoKHR& copy_src) { +safe_VkExportFenceWin32HandleInfoKHR& safe_VkExportFenceWin32HandleInfoKHR::operator=( + const safe_VkExportFenceWin32HandleInfoKHR& copy_src) { if (©_src == this) return *this; - if (pStdPictureInfo) delete pStdPictureInfo; - if (pSliceSegmentOffsets) delete[] pSliceSegmentOffsets; + if (pAttributes) delete pAttributes; FreePnextChain(pNext); sType = copy_src.sType; - pStdPictureInfo = nullptr; - sliceSegmentCount = copy_src.sliceSegmentCount; - pSliceSegmentOffsets = nullptr; + pAttributes = nullptr; + dwAccess = copy_src.dwAccess; + name = copy_src.name; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pStdPictureInfo) { - pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*copy_src.pStdPictureInfo); - } - - if (copy_src.pSliceSegmentOffsets) { - pSliceSegmentOffsets = new uint32_t[copy_src.sliceSegmentCount]; - memcpy((void*)pSliceSegmentOffsets, (void*)copy_src.pSliceSegmentOffsets, sizeof(uint32_t) * copy_src.sliceSegmentCount); + if (copy_src.pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes); } return *this; } -safe_VkVideoDecodeH265PictureInfoKHR::~safe_VkVideoDecodeH265PictureInfoKHR() { - if (pStdPictureInfo) delete pStdPictureInfo; - if (pSliceSegmentOffsets) delete[] pSliceSegmentOffsets; +safe_VkExportFenceWin32HandleInfoKHR::~safe_VkExportFenceWin32HandleInfoKHR() { + if (pAttributes) delete pAttributes; FreePnextChain(pNext); } -void safe_VkVideoDecodeH265PictureInfoKHR::initialize(const VkVideoDecodeH265PictureInfoKHR* in_struct, +void safe_VkExportFenceWin32HandleInfoKHR::initialize(const VkExportFenceWin32HandleInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - if (pStdPictureInfo) delete pStdPictureInfo; - if (pSliceSegmentOffsets) delete[] pSliceSegmentOffsets; + if (pAttributes) delete pAttributes; FreePnextChain(pNext); sType = in_struct->sType; - pStdPictureInfo = nullptr; - sliceSegmentCount = in_struct->sliceSegmentCount; - pSliceSegmentOffsets = nullptr; + pAttributes = nullptr; + dwAccess = in_struct->dwAccess; + name = in_struct->name; pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (in_struct->pStdPictureInfo) { - pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*in_struct->pStdPictureInfo); - } - - if (in_struct->pSliceSegmentOffsets) { - pSliceSegmentOffsets = new uint32_t[in_struct->sliceSegmentCount]; - memcpy((void*)pSliceSegmentOffsets, (void*)in_struct->pSliceSegmentOffsets, - sizeof(uint32_t) * in_struct->sliceSegmentCount); + if (in_struct->pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes); } } -void safe_VkVideoDecodeH265PictureInfoKHR::initialize(const safe_VkVideoDecodeH265PictureInfoKHR* copy_src, +void safe_VkExportFenceWin32HandleInfoKHR::initialize(const safe_VkExportFenceWin32HandleInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - pStdPictureInfo = nullptr; - sliceSegmentCount = copy_src->sliceSegmentCount; - pSliceSegmentOffsets = nullptr; + pAttributes = nullptr; + dwAccess = copy_src->dwAccess; + name = copy_src->name; pNext = SafePnextCopy(copy_src->pNext); - if (copy_src->pStdPictureInfo) { - pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*copy_src->pStdPictureInfo); - } - - if (copy_src->pSliceSegmentOffsets) { - pSliceSegmentOffsets = new uint32_t[copy_src->sliceSegmentCount]; - memcpy((void*)pSliceSegmentOffsets, (void*)copy_src->pSliceSegmentOffsets, sizeof(uint32_t) * copy_src->sliceSegmentCount); + if (copy_src->pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*copy_src->pAttributes); } } -safe_VkVideoDecodeH265DpbSlotInfoKHR::safe_VkVideoDecodeH265DpbSlotInfoKHR(const VkVideoDecodeH265DpbSlotInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), pStdReferenceInfo(nullptr) { +safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), fence(in_struct->fence), handleType(in_struct->handleType) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoDecodeH265ReferenceInfo(*in_struct->pStdReferenceInfo); - } } -safe_VkVideoDecodeH265DpbSlotInfoKHR::safe_VkVideoDecodeH265DpbSlotInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {} +safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR() + : sType(VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR), pNext(nullptr), fence(), handleType() {} -safe_VkVideoDecodeH265DpbSlotInfoKHR::safe_VkVideoDecodeH265DpbSlotInfoKHR(const safe_VkVideoDecodeH265DpbSlotInfoKHR& copy_src) { +safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR(const safe_VkFenceGetWin32HandleInfoKHR& copy_src) { sType = copy_src.sType; - pStdReferenceInfo = nullptr; + fence = copy_src.fence; + handleType = copy_src.handleType; pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoDecodeH265ReferenceInfo(*copy_src.pStdReferenceInfo); - } } -safe_VkVideoDecodeH265DpbSlotInfoKHR& safe_VkVideoDecodeH265DpbSlotInfoKHR::operator=( - const safe_VkVideoDecodeH265DpbSlotInfoKHR& copy_src) { +safe_VkFenceGetWin32HandleInfoKHR& safe_VkFenceGetWin32HandleInfoKHR::operator=(const safe_VkFenceGetWin32HandleInfoKHR& copy_src) { if (©_src == this) return *this; - if (pStdReferenceInfo) delete pStdReferenceInfo; FreePnextChain(pNext); sType = copy_src.sType; - pStdReferenceInfo = nullptr; + fence = copy_src.fence; + handleType = copy_src.handleType; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoDecodeH265ReferenceInfo(*copy_src.pStdReferenceInfo); - } - return *this; } -safe_VkVideoDecodeH265DpbSlotInfoKHR::~safe_VkVideoDecodeH265DpbSlotInfoKHR() { - if (pStdReferenceInfo) delete pStdReferenceInfo; - FreePnextChain(pNext); -} +safe_VkFenceGetWin32HandleInfoKHR::~safe_VkFenceGetWin32HandleInfoKHR() { FreePnextChain(pNext); } -void safe_VkVideoDecodeH265DpbSlotInfoKHR::initialize(const VkVideoDecodeH265DpbSlotInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pStdReferenceInfo) delete pStdReferenceInfo; +void safe_VkFenceGetWin32HandleInfoKHR::initialize(const VkFenceGetWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - pStdReferenceInfo = nullptr; + fence = in_struct->fence; + handleType = in_struct->handleType; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoDecodeH265ReferenceInfo(*in_struct->pStdReferenceInfo); - } } -void safe_VkVideoDecodeH265DpbSlotInfoKHR::initialize(const safe_VkVideoDecodeH265DpbSlotInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkFenceGetWin32HandleInfoKHR::initialize(const safe_VkFenceGetWin32HandleInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - pStdReferenceInfo = nullptr; + fence = copy_src->fence; + handleType = copy_src->handleType; pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pStdReferenceInfo) { - pStdReferenceInfo = new StdVideoDecodeH265ReferenceInfo(*copy_src->pStdReferenceInfo); - } } +#endif // VK_USE_PLATFORM_WIN32_KHR -safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::safe_VkDeviceQueueGlobalPriorityCreateInfoKHR( - const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), globalPriority(in_struct->globalPriority) { +safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + fence(in_struct->fence), + flags(in_struct->flags), + handleType(in_struct->handleType), + fd(in_struct->fd) { 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_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR() + : sType(VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR), pNext(nullptr), fence(), flags(), handleType(), fd() {} -safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::safe_VkDeviceQueueGlobalPriorityCreateInfoKHR( - const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& copy_src) { +safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR(const safe_VkImportFenceFdInfoKHR& copy_src) { sType = copy_src.sType; - globalPriority = copy_src.globalPriority; + fence = copy_src.fence; + flags = copy_src.flags; + handleType = copy_src.handleType; + fd = copy_src.fd; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::operator=( - const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& copy_src) { +safe_VkImportFenceFdInfoKHR& safe_VkImportFenceFdInfoKHR::operator=(const safe_VkImportFenceFdInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - globalPriority = copy_src.globalPriority; + fence = copy_src.fence; + flags = copy_src.flags; + handleType = copy_src.handleType; + fd = copy_src.fd; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::~safe_VkDeviceQueueGlobalPriorityCreateInfoKHR() { FreePnextChain(pNext); } +safe_VkImportFenceFdInfoKHR::~safe_VkImportFenceFdInfoKHR() { FreePnextChain(pNext); } -void safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::initialize(const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkImportFenceFdInfoKHR::initialize(const VkImportFenceFdInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - globalPriority = in_struct->globalPriority; + fence = in_struct->fence; + flags = in_struct->flags; + handleType = in_struct->handleType; + fd = in_struct->fd; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::initialize(const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkImportFenceFdInfoKHR::initialize(const safe_VkImportFenceFdInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - globalPriority = copy_src->globalPriority; + fence = copy_src->fence; + flags = copy_src->flags; + handleType = copy_src->handleType; + fd = copy_src->fd; 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) { +safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), fence(in_struct->fence), handleType(in_struct->handleType) { 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_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR() + : sType(VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR), pNext(nullptr), fence(), handleType() {} -safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR( - const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src) { +safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR(const safe_VkFenceGetFdInfoKHR& copy_src) { sType = copy_src.sType; - globalPriorityQuery = copy_src.globalPriorityQuery; + fence = copy_src.fence; + handleType = copy_src.handleType; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::operator=( - const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src) { +safe_VkFenceGetFdInfoKHR& safe_VkFenceGetFdInfoKHR::operator=(const safe_VkFenceGetFdInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - globalPriorityQuery = copy_src.globalPriorityQuery; + fence = copy_src.fence; + handleType = copy_src.handleType; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::~safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR() { - FreePnextChain(pNext); -} +safe_VkFenceGetFdInfoKHR::~safe_VkFenceGetFdInfoKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::initialize( - const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkFenceGetFdInfoKHR::initialize(const VkFenceGetFdInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - globalPriorityQuery = in_struct->globalPriorityQuery; + fence = in_struct->fence; + handleType = in_struct->handleType; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::initialize( - const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkFenceGetFdInfoKHR::initialize(const safe_VkFenceGetFdInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - globalPriorityQuery = copy_src->globalPriorityQuery; - pNext = SafePnextCopy(copy_src->pNext); + fence = copy_src->fence; + handleType = copy_src->handleType; + 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) { +safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::safe_VkPhysicalDevicePerformanceQueryFeaturesKHR( + const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + performanceCounterQueryPools(in_struct->performanceCounterQueryPools), + performanceCounterMultipleQueryPools(in_struct->performanceCounterMultipleQueryPools) { 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_VkPhysicalDevicePerformanceQueryFeaturesKHR::safe_VkPhysicalDevicePerformanceQueryFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR), + pNext(nullptr), + performanceCounterQueryPools(), + performanceCounterMultipleQueryPools() {} -safe_VkQueueFamilyGlobalPriorityPropertiesKHR::safe_VkQueueFamilyGlobalPriorityPropertiesKHR( - const safe_VkQueueFamilyGlobalPriorityPropertiesKHR& copy_src) { +safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::safe_VkPhysicalDevicePerformanceQueryFeaturesKHR( + const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src) { sType = copy_src.sType; - priorityCount = copy_src.priorityCount; + performanceCounterQueryPools = copy_src.performanceCounterQueryPools; + performanceCounterMultipleQueryPools = copy_src.performanceCounterMultipleQueryPools; 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) { +safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::operator=( + const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - priorityCount = copy_src.priorityCount; + performanceCounterQueryPools = copy_src.performanceCounterQueryPools; + performanceCounterMultipleQueryPools = copy_src.performanceCounterMultipleQueryPools; 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); } +safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::~safe_VkPhysicalDevicePerformanceQueryFeaturesKHR() { FreePnextChain(pNext); } -void safe_VkQueueFamilyGlobalPriorityPropertiesKHR::initialize(const VkQueueFamilyGlobalPriorityPropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::initialize(const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - priorityCount = in_struct->priorityCount; + performanceCounterQueryPools = in_struct->performanceCounterQueryPools; + performanceCounterMultipleQueryPools = in_struct->performanceCounterMultipleQueryPools; 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) { +void safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::initialize(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - priorityCount = copy_src->priorityCount; + performanceCounterQueryPools = copy_src->performanceCounterQueryPools; + performanceCounterMultipleQueryPools = copy_src->performanceCounterMultipleQueryPools; 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), - pFragmentShadingRateAttachment(nullptr), - shadingRateAttachmentTexelSize(in_struct->shadingRateAttachmentTexelSize) { +safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::safe_VkPhysicalDevicePerformanceQueryPropertiesKHR( + const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), allowCommandBufferQueryCopies(in_struct->allowCommandBufferQueryCopies) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pFragmentShadingRateAttachment) - pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(in_struct->pFragmentShadingRateAttachment); } -safe_VkFragmentShadingRateAttachmentInfoKHR::safe_VkFragmentShadingRateAttachmentInfoKHR() - : sType(VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR), - pNext(nullptr), - pFragmentShadingRateAttachment(nullptr), - shadingRateAttachmentTexelSize() {} +safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::safe_VkPhysicalDevicePerformanceQueryPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR), pNext(nullptr), allowCommandBufferQueryCopies() {} -safe_VkFragmentShadingRateAttachmentInfoKHR::safe_VkFragmentShadingRateAttachmentInfoKHR( - const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src) { +safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::safe_VkPhysicalDevicePerformanceQueryPropertiesKHR( + const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src) { sType = copy_src.sType; - pFragmentShadingRateAttachment = nullptr; - shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize; + allowCommandBufferQueryCopies = copy_src.allowCommandBufferQueryCopies; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pFragmentShadingRateAttachment) - pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(*copy_src.pFragmentShadingRateAttachment); } -safe_VkFragmentShadingRateAttachmentInfoKHR& safe_VkFragmentShadingRateAttachmentInfoKHR::operator=( - const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src) { +safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::operator=( + const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src) { if (©_src == this) return *this; - if (pFragmentShadingRateAttachment) delete pFragmentShadingRateAttachment; FreePnextChain(pNext); sType = copy_src.sType; - pFragmentShadingRateAttachment = nullptr; - shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize; + allowCommandBufferQueryCopies = copy_src.allowCommandBufferQueryCopies; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pFragmentShadingRateAttachment) - pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(*copy_src.pFragmentShadingRateAttachment); return *this; } -safe_VkFragmentShadingRateAttachmentInfoKHR::~safe_VkFragmentShadingRateAttachmentInfoKHR() { - if (pFragmentShadingRateAttachment) delete pFragmentShadingRateAttachment; - FreePnextChain(pNext); -} +safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::~safe_VkPhysicalDevicePerformanceQueryPropertiesKHR() { FreePnextChain(pNext); } -void safe_VkFragmentShadingRateAttachmentInfoKHR::initialize(const VkFragmentShadingRateAttachmentInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pFragmentShadingRateAttachment) delete pFragmentShadingRateAttachment; +void safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::initialize(const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - pFragmentShadingRateAttachment = nullptr; - shadingRateAttachmentTexelSize = in_struct->shadingRateAttachmentTexelSize; + allowCommandBufferQueryCopies = in_struct->allowCommandBufferQueryCopies; pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (in_struct->pFragmentShadingRateAttachment) - pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(in_struct->pFragmentShadingRateAttachment); } -void safe_VkFragmentShadingRateAttachmentInfoKHR::initialize(const safe_VkFragmentShadingRateAttachmentInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::initialize( + const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - pFragmentShadingRateAttachment = nullptr; - shadingRateAttachmentTexelSize = copy_src->shadingRateAttachmentTexelSize; + allowCommandBufferQueryCopies = copy_src->allowCommandBufferQueryCopies; pNext = SafePnextCopy(copy_src->pNext); - if (copy_src->pFragmentShadingRateAttachment) - pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(*copy_src->pFragmentShadingRateAttachment); } -safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::safe_VkPipelineFragmentShadingRateStateCreateInfoKHR( - const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), fragmentSize(in_struct->fragmentSize) { +safe_VkPerformanceCounterKHR::safe_VkPerformanceCounterKHR(const VkPerformanceCounterKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), unit(in_struct->unit), scope(in_struct->scope), storage(in_struct->storage) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - for (uint32_t i = 0; i < 2; ++i) { - combinerOps[i] = in_struct->combinerOps[i]; + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + uuid[i] = in_struct->uuid[i]; } } -safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::safe_VkPipelineFragmentShadingRateStateCreateInfoKHR() - : sType(VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR), pNext(nullptr), fragmentSize() {} +safe_VkPerformanceCounterKHR::safe_VkPerformanceCounterKHR() + : sType(VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR), pNext(nullptr), unit(), scope(), storage() {} -safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::safe_VkPipelineFragmentShadingRateStateCreateInfoKHR( - const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src) { +safe_VkPerformanceCounterKHR::safe_VkPerformanceCounterKHR(const safe_VkPerformanceCounterKHR& copy_src) { sType = copy_src.sType; - fragmentSize = copy_src.fragmentSize; + unit = copy_src.unit; + scope = copy_src.scope; + storage = copy_src.storage; pNext = SafePnextCopy(copy_src.pNext); - for (uint32_t i = 0; i < 2; ++i) { - combinerOps[i] = copy_src.combinerOps[i]; + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + uuid[i] = copy_src.uuid[i]; } } -safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::operator=( - const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src) { +safe_VkPerformanceCounterKHR& safe_VkPerformanceCounterKHR::operator=(const safe_VkPerformanceCounterKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - fragmentSize = copy_src.fragmentSize; + unit = copy_src.unit; + scope = copy_src.scope; + storage = copy_src.storage; pNext = SafePnextCopy(copy_src.pNext); - for (uint32_t i = 0; i < 2; ++i) { - combinerOps[i] = copy_src.combinerOps[i]; + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + uuid[i] = copy_src.uuid[i]; } return *this; } -safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::~safe_VkPipelineFragmentShadingRateStateCreateInfoKHR() { - FreePnextChain(pNext); -} +safe_VkPerformanceCounterKHR::~safe_VkPerformanceCounterKHR() { FreePnextChain(pNext); } -void safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::initialize( - const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPerformanceCounterKHR::initialize(const VkPerformanceCounterKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - fragmentSize = in_struct->fragmentSize; + unit = in_struct->unit; + scope = in_struct->scope; + storage = in_struct->storage; pNext = SafePnextCopy(in_struct->pNext, copy_state); - for (uint32_t i = 0; i < 2; ++i) { - combinerOps[i] = in_struct->combinerOps[i]; + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + uuid[i] = in_struct->uuid[i]; } } -void safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::initialize( - const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPerformanceCounterKHR::initialize(const safe_VkPerformanceCounterKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - fragmentSize = copy_src->fragmentSize; + unit = copy_src->unit; + scope = copy_src->scope; + storage = copy_src->storage; pNext = SafePnextCopy(copy_src->pNext); - for (uint32_t i = 0; i < 2; ++i) { - combinerOps[i] = copy_src->combinerOps[i]; + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + uuid[i] = copy_src->uuid[i]; } } -safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR( - const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - pipelineFragmentShadingRate(in_struct->pipelineFragmentShadingRate), - primitiveFragmentShadingRate(in_struct->primitiveFragmentShadingRate), - attachmentFragmentShadingRate(in_struct->attachmentFragmentShadingRate) { +safe_VkPerformanceCounterDescriptionKHR::safe_VkPerformanceCounterDescriptionKHR( + const VkPerformanceCounterDescriptionKHR* 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); } + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = in_struct->name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + category[i] = in_struct->category[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = in_struct->description[i]; + } } -safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR), - pNext(nullptr), - pipelineFragmentShadingRate(), - primitiveFragmentShadingRate(), - attachmentFragmentShadingRate() {} +safe_VkPerformanceCounterDescriptionKHR::safe_VkPerformanceCounterDescriptionKHR() + : sType(VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR), pNext(nullptr), flags() {} -safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR( - const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src) { +safe_VkPerformanceCounterDescriptionKHR::safe_VkPerformanceCounterDescriptionKHR( + const safe_VkPerformanceCounterDescriptionKHR& copy_src) { sType = copy_src.sType; - pipelineFragmentShadingRate = copy_src.pipelineFragmentShadingRate; - primitiveFragmentShadingRate = copy_src.primitiveFragmentShadingRate; - attachmentFragmentShadingRate = copy_src.attachmentFragmentShadingRate; + flags = copy_src.flags; pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = copy_src.name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + category[i] = copy_src.category[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = copy_src.description[i]; + } } -safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::operator=( - const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src) { +safe_VkPerformanceCounterDescriptionKHR& safe_VkPerformanceCounterDescriptionKHR::operator=( + const safe_VkPerformanceCounterDescriptionKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - pipelineFragmentShadingRate = copy_src.pipelineFragmentShadingRate; - primitiveFragmentShadingRate = copy_src.primitiveFragmentShadingRate; - attachmentFragmentShadingRate = copy_src.attachmentFragmentShadingRate; + flags = copy_src.flags; pNext = SafePnextCopy(copy_src.pNext); - return *this; -} - -safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::~safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR() { - FreePnextChain(pNext); -} + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = copy_src.name[i]; + } -void safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::initialize( - const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + category[i] = copy_src.category[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = copy_src.description[i]; + } + + return *this; +} + +safe_VkPerformanceCounterDescriptionKHR::~safe_VkPerformanceCounterDescriptionKHR() { FreePnextChain(pNext); } + +void safe_VkPerformanceCounterDescriptionKHR::initialize(const VkPerformanceCounterDescriptionKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - pipelineFragmentShadingRate = in_struct->pipelineFragmentShadingRate; - primitiveFragmentShadingRate = in_struct->primitiveFragmentShadingRate; - attachmentFragmentShadingRate = in_struct->attachmentFragmentShadingRate; + flags = in_struct->flags; pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = in_struct->name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + category[i] = in_struct->category[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = in_struct->description[i]; + } } -void safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::initialize( - const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPerformanceCounterDescriptionKHR::initialize(const safe_VkPerformanceCounterDescriptionKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - pipelineFragmentShadingRate = copy_src->pipelineFragmentShadingRate; - primitiveFragmentShadingRate = copy_src->primitiveFragmentShadingRate; - attachmentFragmentShadingRate = copy_src->attachmentFragmentShadingRate; + flags = copy_src->flags; pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = copy_src->name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + category[i] = copy_src->category[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = copy_src->description[i]; + } } -safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR( - const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkQueryPoolPerformanceCreateInfoKHR::safe_VkQueryPoolPerformanceCreateInfoKHR( + const VkQueryPoolPerformanceCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), - minFragmentShadingRateAttachmentTexelSize(in_struct->minFragmentShadingRateAttachmentTexelSize), - maxFragmentShadingRateAttachmentTexelSize(in_struct->maxFragmentShadingRateAttachmentTexelSize), - maxFragmentShadingRateAttachmentTexelSizeAspectRatio(in_struct->maxFragmentShadingRateAttachmentTexelSizeAspectRatio), - primitiveFragmentShadingRateWithMultipleViewports(in_struct->primitiveFragmentShadingRateWithMultipleViewports), - layeredShadingRateAttachments(in_struct->layeredShadingRateAttachments), - fragmentShadingRateNonTrivialCombinerOps(in_struct->fragmentShadingRateNonTrivialCombinerOps), - maxFragmentSize(in_struct->maxFragmentSize), - maxFragmentSizeAspectRatio(in_struct->maxFragmentSizeAspectRatio), - maxFragmentShadingRateCoverageSamples(in_struct->maxFragmentShadingRateCoverageSamples), - maxFragmentShadingRateRasterizationSamples(in_struct->maxFragmentShadingRateRasterizationSamples), - fragmentShadingRateWithShaderDepthStencilWrites(in_struct->fragmentShadingRateWithShaderDepthStencilWrites), - fragmentShadingRateWithSampleMask(in_struct->fragmentShadingRateWithSampleMask), - fragmentShadingRateWithShaderSampleMask(in_struct->fragmentShadingRateWithShaderSampleMask), - fragmentShadingRateWithConservativeRasterization(in_struct->fragmentShadingRateWithConservativeRasterization), - fragmentShadingRateWithFragmentShaderInterlock(in_struct->fragmentShadingRateWithFragmentShaderInterlock), - fragmentShadingRateWithCustomSampleLocations(in_struct->fragmentShadingRateWithCustomSampleLocations), - fragmentShadingRateStrictMultiplyCombiner(in_struct->fragmentShadingRateStrictMultiplyCombiner) { + queueFamilyIndex(in_struct->queueFamilyIndex), + counterIndexCount(in_struct->counterIndexCount), + pCounterIndices(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + if (in_struct->pCounterIndices) { + pCounterIndices = new uint32_t[in_struct->counterIndexCount]; + memcpy((void*)pCounterIndices, (void*)in_struct->pCounterIndices, sizeof(uint32_t) * in_struct->counterIndexCount); + } } -safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR), +safe_VkQueryPoolPerformanceCreateInfoKHR::safe_VkQueryPoolPerformanceCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR), pNext(nullptr), - minFragmentShadingRateAttachmentTexelSize(), - maxFragmentShadingRateAttachmentTexelSize(), - maxFragmentShadingRateAttachmentTexelSizeAspectRatio(), - primitiveFragmentShadingRateWithMultipleViewports(), - layeredShadingRateAttachments(), - fragmentShadingRateNonTrivialCombinerOps(), - maxFragmentSize(), - maxFragmentSizeAspectRatio(), - maxFragmentShadingRateCoverageSamples(), - maxFragmentShadingRateRasterizationSamples(), - fragmentShadingRateWithShaderDepthStencilWrites(), - fragmentShadingRateWithSampleMask(), - fragmentShadingRateWithShaderSampleMask(), - fragmentShadingRateWithConservativeRasterization(), - fragmentShadingRateWithFragmentShaderInterlock(), - fragmentShadingRateWithCustomSampleLocations(), - fragmentShadingRateStrictMultiplyCombiner() {} + queueFamilyIndex(), + counterIndexCount(), + pCounterIndices(nullptr) {} -safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR( - const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src) { +safe_VkQueryPoolPerformanceCreateInfoKHR::safe_VkQueryPoolPerformanceCreateInfoKHR( + const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src) { sType = copy_src.sType; - minFragmentShadingRateAttachmentTexelSize = copy_src.minFragmentShadingRateAttachmentTexelSize; - maxFragmentShadingRateAttachmentTexelSize = copy_src.maxFragmentShadingRateAttachmentTexelSize; - maxFragmentShadingRateAttachmentTexelSizeAspectRatio = copy_src.maxFragmentShadingRateAttachmentTexelSizeAspectRatio; - primitiveFragmentShadingRateWithMultipleViewports = copy_src.primitiveFragmentShadingRateWithMultipleViewports; - layeredShadingRateAttachments = copy_src.layeredShadingRateAttachments; - fragmentShadingRateNonTrivialCombinerOps = copy_src.fragmentShadingRateNonTrivialCombinerOps; - maxFragmentSize = copy_src.maxFragmentSize; - maxFragmentSizeAspectRatio = copy_src.maxFragmentSizeAspectRatio; - maxFragmentShadingRateCoverageSamples = copy_src.maxFragmentShadingRateCoverageSamples; - maxFragmentShadingRateRasterizationSamples = copy_src.maxFragmentShadingRateRasterizationSamples; - fragmentShadingRateWithShaderDepthStencilWrites = copy_src.fragmentShadingRateWithShaderDepthStencilWrites; - fragmentShadingRateWithSampleMask = copy_src.fragmentShadingRateWithSampleMask; - fragmentShadingRateWithShaderSampleMask = copy_src.fragmentShadingRateWithShaderSampleMask; - fragmentShadingRateWithConservativeRasterization = copy_src.fragmentShadingRateWithConservativeRasterization; - fragmentShadingRateWithFragmentShaderInterlock = copy_src.fragmentShadingRateWithFragmentShaderInterlock; - fragmentShadingRateWithCustomSampleLocations = copy_src.fragmentShadingRateWithCustomSampleLocations; - fragmentShadingRateStrictMultiplyCombiner = copy_src.fragmentShadingRateStrictMultiplyCombiner; + queueFamilyIndex = copy_src.queueFamilyIndex; + counterIndexCount = copy_src.counterIndexCount; + pCounterIndices = nullptr; pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pCounterIndices) { + pCounterIndices = new uint32_t[copy_src.counterIndexCount]; + memcpy((void*)pCounterIndices, (void*)copy_src.pCounterIndices, sizeof(uint32_t) * copy_src.counterIndexCount); + } } -safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::operator=( - const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src) { +safe_VkQueryPoolPerformanceCreateInfoKHR& safe_VkQueryPoolPerformanceCreateInfoKHR::operator=( + const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src) { if (©_src == this) return *this; + if (pCounterIndices) delete[] pCounterIndices; FreePnextChain(pNext); sType = copy_src.sType; - minFragmentShadingRateAttachmentTexelSize = copy_src.minFragmentShadingRateAttachmentTexelSize; - maxFragmentShadingRateAttachmentTexelSize = copy_src.maxFragmentShadingRateAttachmentTexelSize; - maxFragmentShadingRateAttachmentTexelSizeAspectRatio = copy_src.maxFragmentShadingRateAttachmentTexelSizeAspectRatio; - primitiveFragmentShadingRateWithMultipleViewports = copy_src.primitiveFragmentShadingRateWithMultipleViewports; - layeredShadingRateAttachments = copy_src.layeredShadingRateAttachments; - fragmentShadingRateNonTrivialCombinerOps = copy_src.fragmentShadingRateNonTrivialCombinerOps; - maxFragmentSize = copy_src.maxFragmentSize; - maxFragmentSizeAspectRatio = copy_src.maxFragmentSizeAspectRatio; - maxFragmentShadingRateCoverageSamples = copy_src.maxFragmentShadingRateCoverageSamples; - maxFragmentShadingRateRasterizationSamples = copy_src.maxFragmentShadingRateRasterizationSamples; - fragmentShadingRateWithShaderDepthStencilWrites = copy_src.fragmentShadingRateWithShaderDepthStencilWrites; - fragmentShadingRateWithSampleMask = copy_src.fragmentShadingRateWithSampleMask; - fragmentShadingRateWithShaderSampleMask = copy_src.fragmentShadingRateWithShaderSampleMask; - fragmentShadingRateWithConservativeRasterization = copy_src.fragmentShadingRateWithConservativeRasterization; - fragmentShadingRateWithFragmentShaderInterlock = copy_src.fragmentShadingRateWithFragmentShaderInterlock; - fragmentShadingRateWithCustomSampleLocations = copy_src.fragmentShadingRateWithCustomSampleLocations; - fragmentShadingRateStrictMultiplyCombiner = copy_src.fragmentShadingRateStrictMultiplyCombiner; + queueFamilyIndex = copy_src.queueFamilyIndex; + counterIndexCount = copy_src.counterIndexCount; + pCounterIndices = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pCounterIndices) { + pCounterIndices = new uint32_t[copy_src.counterIndexCount]; + memcpy((void*)pCounterIndices, (void*)copy_src.pCounterIndices, sizeof(uint32_t) * copy_src.counterIndexCount); + } + return *this; } -safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::~safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR() { +safe_VkQueryPoolPerformanceCreateInfoKHR::~safe_VkQueryPoolPerformanceCreateInfoKHR() { + if (pCounterIndices) delete[] pCounterIndices; FreePnextChain(pNext); } -void safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::initialize( - const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkQueryPoolPerformanceCreateInfoKHR::initialize(const VkQueryPoolPerformanceCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pCounterIndices) delete[] pCounterIndices; + FreePnextChain(pNext); + sType = in_struct->sType; + queueFamilyIndex = in_struct->queueFamilyIndex; + counterIndexCount = in_struct->counterIndexCount; + pCounterIndices = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pCounterIndices) { + pCounterIndices = new uint32_t[in_struct->counterIndexCount]; + memcpy((void*)pCounterIndices, (void*)in_struct->pCounterIndices, sizeof(uint32_t) * in_struct->counterIndexCount); + } +} + +void safe_VkQueryPoolPerformanceCreateInfoKHR::initialize(const safe_VkQueryPoolPerformanceCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + queueFamilyIndex = copy_src->queueFamilyIndex; + counterIndexCount = copy_src->counterIndexCount; + pCounterIndices = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pCounterIndices) { + pCounterIndices = new uint32_t[copy_src->counterIndexCount]; + memcpy((void*)pCounterIndices, (void*)copy_src->pCounterIndices, sizeof(uint32_t) * copy_src->counterIndexCount); + } +} + +safe_VkAcquireProfilingLockInfoKHR::safe_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), timeout(in_struct->timeout) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAcquireProfilingLockInfoKHR::safe_VkAcquireProfilingLockInfoKHR() + : sType(VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR), pNext(nullptr), flags(), timeout() {} + +safe_VkAcquireProfilingLockInfoKHR::safe_VkAcquireProfilingLockInfoKHR(const safe_VkAcquireProfilingLockInfoKHR& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + timeout = copy_src.timeout; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAcquireProfilingLockInfoKHR& safe_VkAcquireProfilingLockInfoKHR::operator=( + const safe_VkAcquireProfilingLockInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + timeout = copy_src.timeout; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAcquireProfilingLockInfoKHR::~safe_VkAcquireProfilingLockInfoKHR() { FreePnextChain(pNext); } + +void safe_VkAcquireProfilingLockInfoKHR::initialize(const VkAcquireProfilingLockInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + timeout = in_struct->timeout; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAcquireProfilingLockInfoKHR::initialize(const safe_VkAcquireProfilingLockInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + timeout = copy_src->timeout; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPerformanceQuerySubmitInfoKHR::safe_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), counterPassIndex(in_struct->counterPassIndex) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPerformanceQuerySubmitInfoKHR::safe_VkPerformanceQuerySubmitInfoKHR() + : sType(VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR), pNext(nullptr), counterPassIndex() {} + +safe_VkPerformanceQuerySubmitInfoKHR::safe_VkPerformanceQuerySubmitInfoKHR(const safe_VkPerformanceQuerySubmitInfoKHR& copy_src) { + sType = copy_src.sType; + counterPassIndex = copy_src.counterPassIndex; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPerformanceQuerySubmitInfoKHR& safe_VkPerformanceQuerySubmitInfoKHR::operator=( + const safe_VkPerformanceQuerySubmitInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + counterPassIndex = copy_src.counterPassIndex; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPerformanceQuerySubmitInfoKHR::~safe_VkPerformanceQuerySubmitInfoKHR() { FreePnextChain(pNext); } + +void safe_VkPerformanceQuerySubmitInfoKHR::initialize(const VkPerformanceQuerySubmitInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + counterPassIndex = in_struct->counterPassIndex; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPerformanceQuerySubmitInfoKHR::initialize(const safe_VkPerformanceQuerySubmitInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + counterPassIndex = copy_src->counterPassIndex; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), surface(in_struct->surface) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR), pNext(nullptr), surface() {} + +safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR(const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src) { + sType = copy_src.sType; + surface = copy_src.surface; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceSurfaceInfo2KHR& safe_VkPhysicalDeviceSurfaceInfo2KHR::operator=( + const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + surface = copy_src.surface; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceSurfaceInfo2KHR::~safe_VkPhysicalDeviceSurfaceInfo2KHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceSurfaceInfo2KHR::initialize(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + surface = in_struct->surface; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceSurfaceInfo2KHR::initialize(const safe_VkPhysicalDeviceSurfaceInfo2KHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + surface = copy_src->surface; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), surfaceCapabilities(in_struct->surfaceCapabilities) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR() + : sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR), pNext(nullptr), surfaceCapabilities() {} + +safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR(const safe_VkSurfaceCapabilities2KHR& copy_src) { + sType = copy_src.sType; + surfaceCapabilities = copy_src.surfaceCapabilities; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSurfaceCapabilities2KHR& safe_VkSurfaceCapabilities2KHR::operator=(const safe_VkSurfaceCapabilities2KHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + surfaceCapabilities = copy_src.surfaceCapabilities; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSurfaceCapabilities2KHR::~safe_VkSurfaceCapabilities2KHR() { FreePnextChain(pNext); } + +void safe_VkSurfaceCapabilities2KHR::initialize(const VkSurfaceCapabilities2KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + surfaceCapabilities = in_struct->surfaceCapabilities; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSurfaceCapabilities2KHR::initialize(const safe_VkSurfaceCapabilities2KHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + surfaceCapabilities = copy_src->surfaceCapabilities; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), surfaceFormat(in_struct->surfaceFormat) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR() + : sType(VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR), pNext(nullptr), surfaceFormat() {} + +safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR(const safe_VkSurfaceFormat2KHR& copy_src) { + sType = copy_src.sType; + surfaceFormat = copy_src.surfaceFormat; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSurfaceFormat2KHR& safe_VkSurfaceFormat2KHR::operator=(const safe_VkSurfaceFormat2KHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + surfaceFormat = copy_src.surfaceFormat; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSurfaceFormat2KHR::~safe_VkSurfaceFormat2KHR() { FreePnextChain(pNext); } + +void safe_VkSurfaceFormat2KHR::initialize(const VkSurfaceFormat2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + surfaceFormat = in_struct->surfaceFormat; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSurfaceFormat2KHR::initialize(const safe_VkSurfaceFormat2KHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + surfaceFormat = copy_src->surfaceFormat; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR(const VkDisplayProperties2KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), displayProperties(&in_struct->displayProperties) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR() : sType(VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR), pNext(nullptr) {} + +safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR(const safe_VkDisplayProperties2KHR& copy_src) { + sType = copy_src.sType; + displayProperties.initialize(©_src.displayProperties); + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDisplayProperties2KHR& safe_VkDisplayProperties2KHR::operator=(const safe_VkDisplayProperties2KHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + displayProperties.initialize(©_src.displayProperties); + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDisplayProperties2KHR::~safe_VkDisplayProperties2KHR() { FreePnextChain(pNext); } + +void safe_VkDisplayProperties2KHR::initialize(const VkDisplayProperties2KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + displayProperties.initialize(&in_struct->displayProperties); + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDisplayProperties2KHR::initialize(const safe_VkDisplayProperties2KHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + displayProperties.initialize(©_src->displayProperties); + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDisplayPlaneProperties2KHR::safe_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), displayPlaneProperties(in_struct->displayPlaneProperties) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDisplayPlaneProperties2KHR::safe_VkDisplayPlaneProperties2KHR() + : sType(VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR), pNext(nullptr), displayPlaneProperties() {} + +safe_VkDisplayPlaneProperties2KHR::safe_VkDisplayPlaneProperties2KHR(const safe_VkDisplayPlaneProperties2KHR& copy_src) { + sType = copy_src.sType; + displayPlaneProperties = copy_src.displayPlaneProperties; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDisplayPlaneProperties2KHR& safe_VkDisplayPlaneProperties2KHR::operator=(const safe_VkDisplayPlaneProperties2KHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + displayPlaneProperties = copy_src.displayPlaneProperties; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDisplayPlaneProperties2KHR::~safe_VkDisplayPlaneProperties2KHR() { FreePnextChain(pNext); } + +void safe_VkDisplayPlaneProperties2KHR::initialize(const VkDisplayPlaneProperties2KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + displayPlaneProperties = in_struct->displayPlaneProperties; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDisplayPlaneProperties2KHR::initialize(const safe_VkDisplayPlaneProperties2KHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + displayPlaneProperties = copy_src->displayPlaneProperties; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDisplayModeProperties2KHR::safe_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), displayModeProperties(in_struct->displayModeProperties) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDisplayModeProperties2KHR::safe_VkDisplayModeProperties2KHR() + : sType(VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR), pNext(nullptr), displayModeProperties() {} + +safe_VkDisplayModeProperties2KHR::safe_VkDisplayModeProperties2KHR(const safe_VkDisplayModeProperties2KHR& copy_src) { + sType = copy_src.sType; + displayModeProperties = copy_src.displayModeProperties; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDisplayModeProperties2KHR& safe_VkDisplayModeProperties2KHR::operator=(const safe_VkDisplayModeProperties2KHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + displayModeProperties = copy_src.displayModeProperties; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDisplayModeProperties2KHR::~safe_VkDisplayModeProperties2KHR() { FreePnextChain(pNext); } + +void safe_VkDisplayModeProperties2KHR::initialize(const VkDisplayModeProperties2KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + displayModeProperties = in_struct->displayModeProperties; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDisplayModeProperties2KHR::initialize(const safe_VkDisplayModeProperties2KHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + displayModeProperties = copy_src->displayModeProperties; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDisplayPlaneInfo2KHR::safe_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), mode(in_struct->mode), planeIndex(in_struct->planeIndex) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDisplayPlaneInfo2KHR::safe_VkDisplayPlaneInfo2KHR() + : sType(VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR), pNext(nullptr), mode(), planeIndex() {} + +safe_VkDisplayPlaneInfo2KHR::safe_VkDisplayPlaneInfo2KHR(const safe_VkDisplayPlaneInfo2KHR& copy_src) { + sType = copy_src.sType; + mode = copy_src.mode; + planeIndex = copy_src.planeIndex; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDisplayPlaneInfo2KHR& safe_VkDisplayPlaneInfo2KHR::operator=(const safe_VkDisplayPlaneInfo2KHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + mode = copy_src.mode; + planeIndex = copy_src.planeIndex; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDisplayPlaneInfo2KHR::~safe_VkDisplayPlaneInfo2KHR() { FreePnextChain(pNext); } + +void safe_VkDisplayPlaneInfo2KHR::initialize(const VkDisplayPlaneInfo2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + mode = in_struct->mode; + planeIndex = in_struct->planeIndex; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDisplayPlaneInfo2KHR::initialize(const safe_VkDisplayPlaneInfo2KHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + mode = copy_src->mode; + planeIndex = copy_src->planeIndex; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDisplayPlaneCapabilities2KHR::safe_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), capabilities(in_struct->capabilities) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDisplayPlaneCapabilities2KHR::safe_VkDisplayPlaneCapabilities2KHR() + : sType(VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR), pNext(nullptr), capabilities() {} + +safe_VkDisplayPlaneCapabilities2KHR::safe_VkDisplayPlaneCapabilities2KHR(const safe_VkDisplayPlaneCapabilities2KHR& copy_src) { + sType = copy_src.sType; + capabilities = copy_src.capabilities; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDisplayPlaneCapabilities2KHR& safe_VkDisplayPlaneCapabilities2KHR::operator=( + const safe_VkDisplayPlaneCapabilities2KHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + capabilities = copy_src.capabilities; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDisplayPlaneCapabilities2KHR::~safe_VkDisplayPlaneCapabilities2KHR() { FreePnextChain(pNext); } + +void safe_VkDisplayPlaneCapabilities2KHR::initialize(const VkDisplayPlaneCapabilities2KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + capabilities = in_struct->capabilities; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDisplayPlaneCapabilities2KHR::initialize(const safe_VkDisplayPlaneCapabilities2KHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + capabilities = copy_src->capabilities; + pNext = SafePnextCopy(copy_src->pNext); +} +#ifdef VK_ENABLE_BETA_EXTENSIONS + +safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR( + const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + constantAlphaColorBlendFactors(in_struct->constantAlphaColorBlendFactors), + events(in_struct->events), + imageViewFormatReinterpretation(in_struct->imageViewFormatReinterpretation), + imageViewFormatSwizzle(in_struct->imageViewFormatSwizzle), + imageView2DOn3DImage(in_struct->imageView2DOn3DImage), + multisampleArrayImage(in_struct->multisampleArrayImage), + mutableComparisonSamplers(in_struct->mutableComparisonSamplers), + pointPolygons(in_struct->pointPolygons), + samplerMipLodBias(in_struct->samplerMipLodBias), + separateStencilMaskRef(in_struct->separateStencilMaskRef), + shaderSampleRateInterpolationFunctions(in_struct->shaderSampleRateInterpolationFunctions), + tessellationIsolines(in_struct->tessellationIsolines), + tessellationPointMode(in_struct->tessellationPointMode), + triangleFans(in_struct->triangleFans), + vertexAttributeAccessBeyondStride(in_struct->vertexAttributeAccessBeyondStride) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR), + pNext(nullptr), + constantAlphaColorBlendFactors(), + events(), + imageViewFormatReinterpretation(), + imageViewFormatSwizzle(), + imageView2DOn3DImage(), + multisampleArrayImage(), + mutableComparisonSamplers(), + pointPolygons(), + samplerMipLodBias(), + separateStencilMaskRef(), + shaderSampleRateInterpolationFunctions(), + tessellationIsolines(), + tessellationPointMode(), + triangleFans(), + vertexAttributeAccessBeyondStride() {} + +safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR( + const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src) { + sType = copy_src.sType; + constantAlphaColorBlendFactors = copy_src.constantAlphaColorBlendFactors; + events = copy_src.events; + imageViewFormatReinterpretation = copy_src.imageViewFormatReinterpretation; + imageViewFormatSwizzle = copy_src.imageViewFormatSwizzle; + imageView2DOn3DImage = copy_src.imageView2DOn3DImage; + multisampleArrayImage = copy_src.multisampleArrayImage; + mutableComparisonSamplers = copy_src.mutableComparisonSamplers; + pointPolygons = copy_src.pointPolygons; + samplerMipLodBias = copy_src.samplerMipLodBias; + separateStencilMaskRef = copy_src.separateStencilMaskRef; + shaderSampleRateInterpolationFunctions = copy_src.shaderSampleRateInterpolationFunctions; + tessellationIsolines = copy_src.tessellationIsolines; + tessellationPointMode = copy_src.tessellationPointMode; + triangleFans = copy_src.triangleFans; + vertexAttributeAccessBeyondStride = copy_src.vertexAttributeAccessBeyondStride; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::operator=( + const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + constantAlphaColorBlendFactors = copy_src.constantAlphaColorBlendFactors; + events = copy_src.events; + imageViewFormatReinterpretation = copy_src.imageViewFormatReinterpretation; + imageViewFormatSwizzle = copy_src.imageViewFormatSwizzle; + imageView2DOn3DImage = copy_src.imageView2DOn3DImage; + multisampleArrayImage = copy_src.multisampleArrayImage; + mutableComparisonSamplers = copy_src.mutableComparisonSamplers; + pointPolygons = copy_src.pointPolygons; + samplerMipLodBias = copy_src.samplerMipLodBias; + separateStencilMaskRef = copy_src.separateStencilMaskRef; + shaderSampleRateInterpolationFunctions = copy_src.shaderSampleRateInterpolationFunctions; + tessellationIsolines = copy_src.tessellationIsolines; + tessellationPointMode = copy_src.tessellationPointMode; + triangleFans = copy_src.triangleFans; + vertexAttributeAccessBeyondStride = copy_src.vertexAttributeAccessBeyondStride; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::~safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::initialize(const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + constantAlphaColorBlendFactors = in_struct->constantAlphaColorBlendFactors; + events = in_struct->events; + imageViewFormatReinterpretation = in_struct->imageViewFormatReinterpretation; + imageViewFormatSwizzle = in_struct->imageViewFormatSwizzle; + imageView2DOn3DImage = in_struct->imageView2DOn3DImage; + multisampleArrayImage = in_struct->multisampleArrayImage; + mutableComparisonSamplers = in_struct->mutableComparisonSamplers; + pointPolygons = in_struct->pointPolygons; + samplerMipLodBias = in_struct->samplerMipLodBias; + separateStencilMaskRef = in_struct->separateStencilMaskRef; + shaderSampleRateInterpolationFunctions = in_struct->shaderSampleRateInterpolationFunctions; + tessellationIsolines = in_struct->tessellationIsolines; + tessellationPointMode = in_struct->tessellationPointMode; + triangleFans = in_struct->triangleFans; + vertexAttributeAccessBeyondStride = in_struct->vertexAttributeAccessBeyondStride; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::initialize( + const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + constantAlphaColorBlendFactors = copy_src->constantAlphaColorBlendFactors; + events = copy_src->events; + imageViewFormatReinterpretation = copy_src->imageViewFormatReinterpretation; + imageViewFormatSwizzle = copy_src->imageViewFormatSwizzle; + imageView2DOn3DImage = copy_src->imageView2DOn3DImage; + multisampleArrayImage = copy_src->multisampleArrayImage; + mutableComparisonSamplers = copy_src->mutableComparisonSamplers; + pointPolygons = copy_src->pointPolygons; + samplerMipLodBias = copy_src->samplerMipLodBias; + separateStencilMaskRef = copy_src->separateStencilMaskRef; + shaderSampleRateInterpolationFunctions = copy_src->shaderSampleRateInterpolationFunctions; + tessellationIsolines = copy_src->tessellationIsolines; + tessellationPointMode = copy_src->tessellationPointMode; + triangleFans = copy_src->triangleFans; + vertexAttributeAccessBeyondStride = copy_src->vertexAttributeAccessBeyondStride; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR( + const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), minVertexInputBindingStrideAlignment(in_struct->minVertexInputBindingStrideAlignment) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR), + pNext(nullptr), + minVertexInputBindingStrideAlignment() {} + +safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR( + const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src) { + sType = copy_src.sType; + minVertexInputBindingStrideAlignment = copy_src.minVertexInputBindingStrideAlignment; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::operator=( + const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + minVertexInputBindingStrideAlignment = copy_src.minVertexInputBindingStrideAlignment; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::~safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::initialize( + const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + minVertexInputBindingStrideAlignment = in_struct->minVertexInputBindingStrideAlignment; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::initialize( + const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + minVertexInputBindingStrideAlignment = copy_src->minVertexInputBindingStrideAlignment; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_ENABLE_BETA_EXTENSIONS + +safe_VkPhysicalDeviceShaderClockFeaturesKHR::safe_VkPhysicalDeviceShaderClockFeaturesKHR( + const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shaderSubgroupClock(in_struct->shaderSubgroupClock), + shaderDeviceClock(in_struct->shaderDeviceClock) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderClockFeaturesKHR::safe_VkPhysicalDeviceShaderClockFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR), + pNext(nullptr), + shaderSubgroupClock(), + shaderDeviceClock() {} + +safe_VkPhysicalDeviceShaderClockFeaturesKHR::safe_VkPhysicalDeviceShaderClockFeaturesKHR( + const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src) { + sType = copy_src.sType; + shaderSubgroupClock = copy_src.shaderSubgroupClock; + shaderDeviceClock = copy_src.shaderDeviceClock; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderClockFeaturesKHR& safe_VkPhysicalDeviceShaderClockFeaturesKHR::operator=( + const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderSubgroupClock = copy_src.shaderSubgroupClock; + shaderDeviceClock = copy_src.shaderDeviceClock; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderClockFeaturesKHR::~safe_VkPhysicalDeviceShaderClockFeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderClockFeaturesKHR::initialize(const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderSubgroupClock = in_struct->shaderSubgroupClock; + shaderDeviceClock = in_struct->shaderDeviceClock; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderClockFeaturesKHR::initialize(const safe_VkPhysicalDeviceShaderClockFeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderSubgroupClock = copy_src->shaderSubgroupClock; + shaderDeviceClock = copy_src->shaderDeviceClock; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoDecodeH265ProfileInfoKHR::safe_VkVideoDecodeH265ProfileInfoKHR(const VkVideoDecodeH265ProfileInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), stdProfileIdc(in_struct->stdProfileIdc) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoDecodeH265ProfileInfoKHR::safe_VkVideoDecodeH265ProfileInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR), pNext(nullptr), stdProfileIdc() {} + +safe_VkVideoDecodeH265ProfileInfoKHR::safe_VkVideoDecodeH265ProfileInfoKHR(const safe_VkVideoDecodeH265ProfileInfoKHR& copy_src) { + sType = copy_src.sType; + stdProfileIdc = copy_src.stdProfileIdc; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoDecodeH265ProfileInfoKHR& safe_VkVideoDecodeH265ProfileInfoKHR::operator=( + const safe_VkVideoDecodeH265ProfileInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + stdProfileIdc = copy_src.stdProfileIdc; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoDecodeH265ProfileInfoKHR::~safe_VkVideoDecodeH265ProfileInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoDecodeH265ProfileInfoKHR::initialize(const VkVideoDecodeH265ProfileInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + stdProfileIdc = in_struct->stdProfileIdc; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoDecodeH265ProfileInfoKHR::initialize(const safe_VkVideoDecodeH265ProfileInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stdProfileIdc = copy_src->stdProfileIdc; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoDecodeH265CapabilitiesKHR::safe_VkVideoDecodeH265CapabilitiesKHR(const VkVideoDecodeH265CapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), maxLevelIdc(in_struct->maxLevelIdc) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoDecodeH265CapabilitiesKHR::safe_VkVideoDecodeH265CapabilitiesKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR), pNext(nullptr), maxLevelIdc() {} + +safe_VkVideoDecodeH265CapabilitiesKHR::safe_VkVideoDecodeH265CapabilitiesKHR( + const safe_VkVideoDecodeH265CapabilitiesKHR& copy_src) { + sType = copy_src.sType; + maxLevelIdc = copy_src.maxLevelIdc; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoDecodeH265CapabilitiesKHR& safe_VkVideoDecodeH265CapabilitiesKHR::operator=( + const safe_VkVideoDecodeH265CapabilitiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxLevelIdc = copy_src.maxLevelIdc; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoDecodeH265CapabilitiesKHR::~safe_VkVideoDecodeH265CapabilitiesKHR() { FreePnextChain(pNext); } + +void safe_VkVideoDecodeH265CapabilitiesKHR::initialize(const VkVideoDecodeH265CapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxLevelIdc = in_struct->maxLevelIdc; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoDecodeH265CapabilitiesKHR::initialize(const safe_VkVideoDecodeH265CapabilitiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxLevelIdc = copy_src->maxLevelIdc; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoDecodeH265SessionParametersAddInfoKHR::safe_VkVideoDecodeH265SessionParametersAddInfoKHR( + const VkVideoDecodeH265SessionParametersAddInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + stdVPSCount(in_struct->stdVPSCount), + pStdVPSs(nullptr), + stdSPSCount(in_struct->stdSPSCount), + pStdSPSs(nullptr), + stdPPSCount(in_struct->stdPPSCount), + pStdPPSs(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pStdVPSs) { + pStdVPSs = new StdVideoH265VideoParameterSet[in_struct->stdVPSCount]; + memcpy((void*)pStdVPSs, (void*)in_struct->pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * in_struct->stdVPSCount); + } + + if (in_struct->pStdSPSs) { + pStdSPSs = new StdVideoH265SequenceParameterSet[in_struct->stdSPSCount]; + memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * in_struct->stdSPSCount); + } + + if (in_struct->pStdPPSs) { + pStdPPSs = new StdVideoH265PictureParameterSet[in_struct->stdPPSCount]; + memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * in_struct->stdPPSCount); + } +} + +safe_VkVideoDecodeH265SessionParametersAddInfoKHR::safe_VkVideoDecodeH265SessionParametersAddInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR), + pNext(nullptr), + stdVPSCount(), + pStdVPSs(nullptr), + stdSPSCount(), + pStdSPSs(nullptr), + stdPPSCount(), + pStdPPSs(nullptr) {} + +safe_VkVideoDecodeH265SessionParametersAddInfoKHR::safe_VkVideoDecodeH265SessionParametersAddInfoKHR( + const safe_VkVideoDecodeH265SessionParametersAddInfoKHR& copy_src) { + sType = copy_src.sType; + stdVPSCount = copy_src.stdVPSCount; + pStdVPSs = nullptr; + stdSPSCount = copy_src.stdSPSCount; + pStdSPSs = nullptr; + stdPPSCount = copy_src.stdPPSCount; + pStdPPSs = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdVPSs) { + pStdVPSs = new StdVideoH265VideoParameterSet[copy_src.stdVPSCount]; + memcpy((void*)pStdVPSs, (void*)copy_src.pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * copy_src.stdVPSCount); + } + + if (copy_src.pStdSPSs) { + pStdSPSs = new StdVideoH265SequenceParameterSet[copy_src.stdSPSCount]; + memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * copy_src.stdSPSCount); + } + + if (copy_src.pStdPPSs) { + pStdPPSs = new StdVideoH265PictureParameterSet[copy_src.stdPPSCount]; + memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * copy_src.stdPPSCount); + } +} + +safe_VkVideoDecodeH265SessionParametersAddInfoKHR& safe_VkVideoDecodeH265SessionParametersAddInfoKHR::operator=( + const safe_VkVideoDecodeH265SessionParametersAddInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pStdVPSs) delete[] pStdVPSs; + if (pStdSPSs) delete[] pStdSPSs; + if (pStdPPSs) delete[] pStdPPSs; + FreePnextChain(pNext); + + sType = copy_src.sType; + stdVPSCount = copy_src.stdVPSCount; + pStdVPSs = nullptr; + stdSPSCount = copy_src.stdSPSCount; + pStdSPSs = nullptr; + stdPPSCount = copy_src.stdPPSCount; + pStdPPSs = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdVPSs) { + pStdVPSs = new StdVideoH265VideoParameterSet[copy_src.stdVPSCount]; + memcpy((void*)pStdVPSs, (void*)copy_src.pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * copy_src.stdVPSCount); + } + + if (copy_src.pStdSPSs) { + pStdSPSs = new StdVideoH265SequenceParameterSet[copy_src.stdSPSCount]; + memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * copy_src.stdSPSCount); + } + + if (copy_src.pStdPPSs) { + pStdPPSs = new StdVideoH265PictureParameterSet[copy_src.stdPPSCount]; + memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * copy_src.stdPPSCount); + } + + return *this; +} + +safe_VkVideoDecodeH265SessionParametersAddInfoKHR::~safe_VkVideoDecodeH265SessionParametersAddInfoKHR() { + if (pStdVPSs) delete[] pStdVPSs; + if (pStdSPSs) delete[] pStdSPSs; + if (pStdPPSs) delete[] pStdPPSs; + FreePnextChain(pNext); +} + +void safe_VkVideoDecodeH265SessionParametersAddInfoKHR::initialize(const VkVideoDecodeH265SessionParametersAddInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdVPSs) delete[] pStdVPSs; + if (pStdSPSs) delete[] pStdSPSs; + if (pStdPPSs) delete[] pStdPPSs; + FreePnextChain(pNext); + sType = in_struct->sType; + stdVPSCount = in_struct->stdVPSCount; + pStdVPSs = nullptr; + stdSPSCount = in_struct->stdSPSCount; + pStdSPSs = nullptr; + stdPPSCount = in_struct->stdPPSCount; + pStdPPSs = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pStdVPSs) { + pStdVPSs = new StdVideoH265VideoParameterSet[in_struct->stdVPSCount]; + memcpy((void*)pStdVPSs, (void*)in_struct->pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * in_struct->stdVPSCount); + } + + if (in_struct->pStdSPSs) { + pStdSPSs = new StdVideoH265SequenceParameterSet[in_struct->stdSPSCount]; + memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * in_struct->stdSPSCount); + } + + if (in_struct->pStdPPSs) { + pStdPPSs = new StdVideoH265PictureParameterSet[in_struct->stdPPSCount]; + memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * in_struct->stdPPSCount); + } +} + +void safe_VkVideoDecodeH265SessionParametersAddInfoKHR::initialize( + const safe_VkVideoDecodeH265SessionParametersAddInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stdVPSCount = copy_src->stdVPSCount; + pStdVPSs = nullptr; + stdSPSCount = copy_src->stdSPSCount; + pStdSPSs = nullptr; + stdPPSCount = copy_src->stdPPSCount; + pStdPPSs = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdVPSs) { + pStdVPSs = new StdVideoH265VideoParameterSet[copy_src->stdVPSCount]; + memcpy((void*)pStdVPSs, (void*)copy_src->pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * copy_src->stdVPSCount); + } + + if (copy_src->pStdSPSs) { + pStdSPSs = new StdVideoH265SequenceParameterSet[copy_src->stdSPSCount]; + memcpy((void*)pStdSPSs, (void*)copy_src->pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * copy_src->stdSPSCount); + } + + if (copy_src->pStdPPSs) { + pStdPPSs = new StdVideoH265PictureParameterSet[copy_src->stdPPSCount]; + memcpy((void*)pStdPPSs, (void*)copy_src->pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * copy_src->stdPPSCount); + } +} + +safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::safe_VkVideoDecodeH265SessionParametersCreateInfoKHR( + const VkVideoDecodeH265SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + maxStdVPSCount(in_struct->maxStdVPSCount), + maxStdSPSCount(in_struct->maxStdSPSCount), + maxStdPPSCount(in_struct->maxStdPPSCount), + pParametersAddInfo(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pParametersAddInfo) + pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoKHR(in_struct->pParametersAddInfo); +} + +safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::safe_VkVideoDecodeH265SessionParametersCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR), + pNext(nullptr), + maxStdVPSCount(), + maxStdSPSCount(), + maxStdPPSCount(), + pParametersAddInfo(nullptr) {} + +safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::safe_VkVideoDecodeH265SessionParametersCreateInfoKHR( + const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& copy_src) { + sType = copy_src.sType; + maxStdVPSCount = copy_src.maxStdVPSCount; + maxStdSPSCount = copy_src.maxStdSPSCount; + maxStdPPSCount = copy_src.maxStdPPSCount; + pParametersAddInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pParametersAddInfo) + pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo); +} + +safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::operator=( + const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pParametersAddInfo) delete pParametersAddInfo; + FreePnextChain(pNext); + + sType = copy_src.sType; + maxStdVPSCount = copy_src.maxStdVPSCount; + maxStdSPSCount = copy_src.maxStdSPSCount; + maxStdPPSCount = copy_src.maxStdPPSCount; + pParametersAddInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pParametersAddInfo) + pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo); + + return *this; +} + +safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::~safe_VkVideoDecodeH265SessionParametersCreateInfoKHR() { + if (pParametersAddInfo) delete pParametersAddInfo; + FreePnextChain(pNext); +} + +void safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::initialize( + const VkVideoDecodeH265SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pParametersAddInfo) delete pParametersAddInfo; + FreePnextChain(pNext); + sType = in_struct->sType; + maxStdVPSCount = in_struct->maxStdVPSCount; + maxStdSPSCount = in_struct->maxStdSPSCount; + maxStdPPSCount = in_struct->maxStdPPSCount; + pParametersAddInfo = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (in_struct->pParametersAddInfo) + pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoKHR(in_struct->pParametersAddInfo); +} + +void safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::initialize( + const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxStdVPSCount = copy_src->maxStdVPSCount; + maxStdSPSCount = copy_src->maxStdSPSCount; + maxStdPPSCount = copy_src->maxStdPPSCount; + pParametersAddInfo = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (copy_src->pParametersAddInfo) + pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoKHR(*copy_src->pParametersAddInfo); +} + +safe_VkVideoDecodeH265PictureInfoKHR::safe_VkVideoDecodeH265PictureInfoKHR(const VkVideoDecodeH265PictureInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + pStdPictureInfo(nullptr), + sliceSegmentCount(in_struct->sliceSegmentCount), + pSliceSegmentOffsets(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*in_struct->pStdPictureInfo); + } + + if (in_struct->pSliceSegmentOffsets) { + pSliceSegmentOffsets = new uint32_t[in_struct->sliceSegmentCount]; + memcpy((void*)pSliceSegmentOffsets, (void*)in_struct->pSliceSegmentOffsets, + sizeof(uint32_t) * in_struct->sliceSegmentCount); + } +} + +safe_VkVideoDecodeH265PictureInfoKHR::safe_VkVideoDecodeH265PictureInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR), + pNext(nullptr), + pStdPictureInfo(nullptr), + sliceSegmentCount(), + pSliceSegmentOffsets(nullptr) {} + +safe_VkVideoDecodeH265PictureInfoKHR::safe_VkVideoDecodeH265PictureInfoKHR(const safe_VkVideoDecodeH265PictureInfoKHR& copy_src) { + sType = copy_src.sType; + pStdPictureInfo = nullptr; + sliceSegmentCount = copy_src.sliceSegmentCount; + pSliceSegmentOffsets = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*copy_src.pStdPictureInfo); + } + + if (copy_src.pSliceSegmentOffsets) { + pSliceSegmentOffsets = new uint32_t[copy_src.sliceSegmentCount]; + memcpy((void*)pSliceSegmentOffsets, (void*)copy_src.pSliceSegmentOffsets, sizeof(uint32_t) * copy_src.sliceSegmentCount); + } +} + +safe_VkVideoDecodeH265PictureInfoKHR& safe_VkVideoDecodeH265PictureInfoKHR::operator=( + const safe_VkVideoDecodeH265PictureInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pStdPictureInfo) delete pStdPictureInfo; + if (pSliceSegmentOffsets) delete[] pSliceSegmentOffsets; + FreePnextChain(pNext); + + sType = copy_src.sType; + pStdPictureInfo = nullptr; + sliceSegmentCount = copy_src.sliceSegmentCount; + pSliceSegmentOffsets = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*copy_src.pStdPictureInfo); + } + + if (copy_src.pSliceSegmentOffsets) { + pSliceSegmentOffsets = new uint32_t[copy_src.sliceSegmentCount]; + memcpy((void*)pSliceSegmentOffsets, (void*)copy_src.pSliceSegmentOffsets, sizeof(uint32_t) * copy_src.sliceSegmentCount); + } + + return *this; +} + +safe_VkVideoDecodeH265PictureInfoKHR::~safe_VkVideoDecodeH265PictureInfoKHR() { + if (pStdPictureInfo) delete pStdPictureInfo; + if (pSliceSegmentOffsets) delete[] pSliceSegmentOffsets; + FreePnextChain(pNext); +} + +void safe_VkVideoDecodeH265PictureInfoKHR::initialize(const VkVideoDecodeH265PictureInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdPictureInfo) delete pStdPictureInfo; + if (pSliceSegmentOffsets) delete[] pSliceSegmentOffsets; + FreePnextChain(pNext); + sType = in_struct->sType; + pStdPictureInfo = nullptr; + sliceSegmentCount = in_struct->sliceSegmentCount; + pSliceSegmentOffsets = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*in_struct->pStdPictureInfo); + } + + if (in_struct->pSliceSegmentOffsets) { + pSliceSegmentOffsets = new uint32_t[in_struct->sliceSegmentCount]; + memcpy((void*)pSliceSegmentOffsets, (void*)in_struct->pSliceSegmentOffsets, + sizeof(uint32_t) * in_struct->sliceSegmentCount); + } +} + +void safe_VkVideoDecodeH265PictureInfoKHR::initialize(const safe_VkVideoDecodeH265PictureInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pStdPictureInfo = nullptr; + sliceSegmentCount = copy_src->sliceSegmentCount; + pSliceSegmentOffsets = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*copy_src->pStdPictureInfo); + } + + if (copy_src->pSliceSegmentOffsets) { + pSliceSegmentOffsets = new uint32_t[copy_src->sliceSegmentCount]; + memcpy((void*)pSliceSegmentOffsets, (void*)copy_src->pSliceSegmentOffsets, sizeof(uint32_t) * copy_src->sliceSegmentCount); + } +} + +safe_VkVideoDecodeH265DpbSlotInfoKHR::safe_VkVideoDecodeH265DpbSlotInfoKHR(const VkVideoDecodeH265DpbSlotInfoKHR* 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 StdVideoDecodeH265ReferenceInfo(*in_struct->pStdReferenceInfo); + } +} + +safe_VkVideoDecodeH265DpbSlotInfoKHR::safe_VkVideoDecodeH265DpbSlotInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {} + +safe_VkVideoDecodeH265DpbSlotInfoKHR::safe_VkVideoDecodeH265DpbSlotInfoKHR(const safe_VkVideoDecodeH265DpbSlotInfoKHR& copy_src) { + sType = copy_src.sType; + pStdReferenceInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoDecodeH265ReferenceInfo(*copy_src.pStdReferenceInfo); + } +} + +safe_VkVideoDecodeH265DpbSlotInfoKHR& safe_VkVideoDecodeH265DpbSlotInfoKHR::operator=( + const safe_VkVideoDecodeH265DpbSlotInfoKHR& 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 StdVideoDecodeH265ReferenceInfo(*copy_src.pStdReferenceInfo); + } + + return *this; +} + +safe_VkVideoDecodeH265DpbSlotInfoKHR::~safe_VkVideoDecodeH265DpbSlotInfoKHR() { + if (pStdReferenceInfo) delete pStdReferenceInfo; + FreePnextChain(pNext); +} + +void safe_VkVideoDecodeH265DpbSlotInfoKHR::initialize(const VkVideoDecodeH265DpbSlotInfoKHR* 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 StdVideoDecodeH265ReferenceInfo(*in_struct->pStdReferenceInfo); + } +} + +void safe_VkVideoDecodeH265DpbSlotInfoKHR::initialize(const safe_VkVideoDecodeH265DpbSlotInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pStdReferenceInfo = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoDecodeH265ReferenceInfo(*copy_src->pStdReferenceInfo); + } +} + +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), + pFragmentShadingRateAttachment(nullptr), + shadingRateAttachmentTexelSize(in_struct->shadingRateAttachmentTexelSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pFragmentShadingRateAttachment) + pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(in_struct->pFragmentShadingRateAttachment); +} + +safe_VkFragmentShadingRateAttachmentInfoKHR::safe_VkFragmentShadingRateAttachmentInfoKHR() + : sType(VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR), + pNext(nullptr), + pFragmentShadingRateAttachment(nullptr), + shadingRateAttachmentTexelSize() {} + +safe_VkFragmentShadingRateAttachmentInfoKHR::safe_VkFragmentShadingRateAttachmentInfoKHR( + const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src) { + sType = copy_src.sType; + pFragmentShadingRateAttachment = nullptr; + shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pFragmentShadingRateAttachment) + pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(*copy_src.pFragmentShadingRateAttachment); +} + +safe_VkFragmentShadingRateAttachmentInfoKHR& safe_VkFragmentShadingRateAttachmentInfoKHR::operator=( + const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pFragmentShadingRateAttachment) delete pFragmentShadingRateAttachment; + FreePnextChain(pNext); + + sType = copy_src.sType; + pFragmentShadingRateAttachment = nullptr; + shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pFragmentShadingRateAttachment) + pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(*copy_src.pFragmentShadingRateAttachment); + + return *this; +} + +safe_VkFragmentShadingRateAttachmentInfoKHR::~safe_VkFragmentShadingRateAttachmentInfoKHR() { + if (pFragmentShadingRateAttachment) delete pFragmentShadingRateAttachment; + FreePnextChain(pNext); +} + +void safe_VkFragmentShadingRateAttachmentInfoKHR::initialize(const VkFragmentShadingRateAttachmentInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pFragmentShadingRateAttachment) delete pFragmentShadingRateAttachment; + FreePnextChain(pNext); + sType = in_struct->sType; + pFragmentShadingRateAttachment = nullptr; + shadingRateAttachmentTexelSize = in_struct->shadingRateAttachmentTexelSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (in_struct->pFragmentShadingRateAttachment) + pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(in_struct->pFragmentShadingRateAttachment); +} + +void safe_VkFragmentShadingRateAttachmentInfoKHR::initialize(const safe_VkFragmentShadingRateAttachmentInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pFragmentShadingRateAttachment = nullptr; + shadingRateAttachmentTexelSize = copy_src->shadingRateAttachmentTexelSize; + pNext = SafePnextCopy(copy_src->pNext); + if (copy_src->pFragmentShadingRateAttachment) + pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(*copy_src->pFragmentShadingRateAttachment); +} + +safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::safe_VkPipelineFragmentShadingRateStateCreateInfoKHR( + const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), fragmentSize(in_struct->fragmentSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < 2; ++i) { + combinerOps[i] = in_struct->combinerOps[i]; + } +} + +safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::safe_VkPipelineFragmentShadingRateStateCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR), pNext(nullptr), fragmentSize() {} + +safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::safe_VkPipelineFragmentShadingRateStateCreateInfoKHR( + const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src) { + sType = copy_src.sType; + fragmentSize = copy_src.fragmentSize; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < 2; ++i) { + combinerOps[i] = copy_src.combinerOps[i]; + } +} + +safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::operator=( + const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + fragmentSize = copy_src.fragmentSize; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < 2; ++i) { + combinerOps[i] = copy_src.combinerOps[i]; + } + + return *this; +} + +safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::~safe_VkPipelineFragmentShadingRateStateCreateInfoKHR() { + FreePnextChain(pNext); +} + +void safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::initialize( + const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + fragmentSize = in_struct->fragmentSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < 2; ++i) { + combinerOps[i] = in_struct->combinerOps[i]; + } +} + +void safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::initialize( + const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + fragmentSize = copy_src->fragmentSize; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < 2; ++i) { + combinerOps[i] = copy_src->combinerOps[i]; + } +} + +safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR( + const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + pipelineFragmentShadingRate(in_struct->pipelineFragmentShadingRate), + primitiveFragmentShadingRate(in_struct->primitiveFragmentShadingRate), + attachmentFragmentShadingRate(in_struct->attachmentFragmentShadingRate) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR), + pNext(nullptr), + pipelineFragmentShadingRate(), + primitiveFragmentShadingRate(), + attachmentFragmentShadingRate() {} + +safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR( + const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src) { + sType = copy_src.sType; + pipelineFragmentShadingRate = copy_src.pipelineFragmentShadingRate; + primitiveFragmentShadingRate = copy_src.primitiveFragmentShadingRate; + attachmentFragmentShadingRate = copy_src.attachmentFragmentShadingRate; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::operator=( + const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pipelineFragmentShadingRate = copy_src.pipelineFragmentShadingRate; + primitiveFragmentShadingRate = copy_src.primitiveFragmentShadingRate; + attachmentFragmentShadingRate = copy_src.attachmentFragmentShadingRate; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::~safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::initialize( + const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pipelineFragmentShadingRate = in_struct->pipelineFragmentShadingRate; + primitiveFragmentShadingRate = in_struct->primitiveFragmentShadingRate; + attachmentFragmentShadingRate = in_struct->attachmentFragmentShadingRate; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::initialize( + const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipelineFragmentShadingRate = copy_src->pipelineFragmentShadingRate; + primitiveFragmentShadingRate = copy_src->primitiveFragmentShadingRate; + attachmentFragmentShadingRate = copy_src->attachmentFragmentShadingRate; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR( + const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + minFragmentShadingRateAttachmentTexelSize(in_struct->minFragmentShadingRateAttachmentTexelSize), + maxFragmentShadingRateAttachmentTexelSize(in_struct->maxFragmentShadingRateAttachmentTexelSize), + maxFragmentShadingRateAttachmentTexelSizeAspectRatio(in_struct->maxFragmentShadingRateAttachmentTexelSizeAspectRatio), + primitiveFragmentShadingRateWithMultipleViewports(in_struct->primitiveFragmentShadingRateWithMultipleViewports), + layeredShadingRateAttachments(in_struct->layeredShadingRateAttachments), + fragmentShadingRateNonTrivialCombinerOps(in_struct->fragmentShadingRateNonTrivialCombinerOps), + maxFragmentSize(in_struct->maxFragmentSize), + maxFragmentSizeAspectRatio(in_struct->maxFragmentSizeAspectRatio), + maxFragmentShadingRateCoverageSamples(in_struct->maxFragmentShadingRateCoverageSamples), + maxFragmentShadingRateRasterizationSamples(in_struct->maxFragmentShadingRateRasterizationSamples), + fragmentShadingRateWithShaderDepthStencilWrites(in_struct->fragmentShadingRateWithShaderDepthStencilWrites), + fragmentShadingRateWithSampleMask(in_struct->fragmentShadingRateWithSampleMask), + fragmentShadingRateWithShaderSampleMask(in_struct->fragmentShadingRateWithShaderSampleMask), + fragmentShadingRateWithConservativeRasterization(in_struct->fragmentShadingRateWithConservativeRasterization), + fragmentShadingRateWithFragmentShaderInterlock(in_struct->fragmentShadingRateWithFragmentShaderInterlock), + fragmentShadingRateWithCustomSampleLocations(in_struct->fragmentShadingRateWithCustomSampleLocations), + fragmentShadingRateStrictMultiplyCombiner(in_struct->fragmentShadingRateStrictMultiplyCombiner) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR), + pNext(nullptr), + minFragmentShadingRateAttachmentTexelSize(), + maxFragmentShadingRateAttachmentTexelSize(), + maxFragmentShadingRateAttachmentTexelSizeAspectRatio(), + primitiveFragmentShadingRateWithMultipleViewports(), + layeredShadingRateAttachments(), + fragmentShadingRateNonTrivialCombinerOps(), + maxFragmentSize(), + maxFragmentSizeAspectRatio(), + maxFragmentShadingRateCoverageSamples(), + maxFragmentShadingRateRasterizationSamples(), + fragmentShadingRateWithShaderDepthStencilWrites(), + fragmentShadingRateWithSampleMask(), + fragmentShadingRateWithShaderSampleMask(), + fragmentShadingRateWithConservativeRasterization(), + fragmentShadingRateWithFragmentShaderInterlock(), + fragmentShadingRateWithCustomSampleLocations(), + fragmentShadingRateStrictMultiplyCombiner() {} + +safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR( + const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src) { + sType = copy_src.sType; + minFragmentShadingRateAttachmentTexelSize = copy_src.minFragmentShadingRateAttachmentTexelSize; + maxFragmentShadingRateAttachmentTexelSize = copy_src.maxFragmentShadingRateAttachmentTexelSize; + maxFragmentShadingRateAttachmentTexelSizeAspectRatio = copy_src.maxFragmentShadingRateAttachmentTexelSizeAspectRatio; + primitiveFragmentShadingRateWithMultipleViewports = copy_src.primitiveFragmentShadingRateWithMultipleViewports; + layeredShadingRateAttachments = copy_src.layeredShadingRateAttachments; + fragmentShadingRateNonTrivialCombinerOps = copy_src.fragmentShadingRateNonTrivialCombinerOps; + maxFragmentSize = copy_src.maxFragmentSize; + maxFragmentSizeAspectRatio = copy_src.maxFragmentSizeAspectRatio; + maxFragmentShadingRateCoverageSamples = copy_src.maxFragmentShadingRateCoverageSamples; + maxFragmentShadingRateRasterizationSamples = copy_src.maxFragmentShadingRateRasterizationSamples; + fragmentShadingRateWithShaderDepthStencilWrites = copy_src.fragmentShadingRateWithShaderDepthStencilWrites; + fragmentShadingRateWithSampleMask = copy_src.fragmentShadingRateWithSampleMask; + fragmentShadingRateWithShaderSampleMask = copy_src.fragmentShadingRateWithShaderSampleMask; + fragmentShadingRateWithConservativeRasterization = copy_src.fragmentShadingRateWithConservativeRasterization; + fragmentShadingRateWithFragmentShaderInterlock = copy_src.fragmentShadingRateWithFragmentShaderInterlock; + fragmentShadingRateWithCustomSampleLocations = copy_src.fragmentShadingRateWithCustomSampleLocations; + fragmentShadingRateStrictMultiplyCombiner = copy_src.fragmentShadingRateStrictMultiplyCombiner; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::operator=( + const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + minFragmentShadingRateAttachmentTexelSize = copy_src.minFragmentShadingRateAttachmentTexelSize; + maxFragmentShadingRateAttachmentTexelSize = copy_src.maxFragmentShadingRateAttachmentTexelSize; + maxFragmentShadingRateAttachmentTexelSizeAspectRatio = copy_src.maxFragmentShadingRateAttachmentTexelSizeAspectRatio; + primitiveFragmentShadingRateWithMultipleViewports = copy_src.primitiveFragmentShadingRateWithMultipleViewports; + layeredShadingRateAttachments = copy_src.layeredShadingRateAttachments; + fragmentShadingRateNonTrivialCombinerOps = copy_src.fragmentShadingRateNonTrivialCombinerOps; + maxFragmentSize = copy_src.maxFragmentSize; + maxFragmentSizeAspectRatio = copy_src.maxFragmentSizeAspectRatio; + maxFragmentShadingRateCoverageSamples = copy_src.maxFragmentShadingRateCoverageSamples; + maxFragmentShadingRateRasterizationSamples = copy_src.maxFragmentShadingRateRasterizationSamples; + fragmentShadingRateWithShaderDepthStencilWrites = copy_src.fragmentShadingRateWithShaderDepthStencilWrites; + fragmentShadingRateWithSampleMask = copy_src.fragmentShadingRateWithSampleMask; + fragmentShadingRateWithShaderSampleMask = copy_src.fragmentShadingRateWithShaderSampleMask; + fragmentShadingRateWithConservativeRasterization = copy_src.fragmentShadingRateWithConservativeRasterization; + fragmentShadingRateWithFragmentShaderInterlock = copy_src.fragmentShadingRateWithFragmentShaderInterlock; + fragmentShadingRateWithCustomSampleLocations = copy_src.fragmentShadingRateWithCustomSampleLocations; + fragmentShadingRateStrictMultiplyCombiner = copy_src.fragmentShadingRateStrictMultiplyCombiner; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::~safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::initialize( + const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + minFragmentShadingRateAttachmentTexelSize = in_struct->minFragmentShadingRateAttachmentTexelSize; + maxFragmentShadingRateAttachmentTexelSize = in_struct->maxFragmentShadingRateAttachmentTexelSize; + maxFragmentShadingRateAttachmentTexelSizeAspectRatio = in_struct->maxFragmentShadingRateAttachmentTexelSizeAspectRatio; + primitiveFragmentShadingRateWithMultipleViewports = in_struct->primitiveFragmentShadingRateWithMultipleViewports; + layeredShadingRateAttachments = in_struct->layeredShadingRateAttachments; + fragmentShadingRateNonTrivialCombinerOps = in_struct->fragmentShadingRateNonTrivialCombinerOps; + maxFragmentSize = in_struct->maxFragmentSize; + maxFragmentSizeAspectRatio = in_struct->maxFragmentSizeAspectRatio; + maxFragmentShadingRateCoverageSamples = in_struct->maxFragmentShadingRateCoverageSamples; + maxFragmentShadingRateRasterizationSamples = in_struct->maxFragmentShadingRateRasterizationSamples; + fragmentShadingRateWithShaderDepthStencilWrites = in_struct->fragmentShadingRateWithShaderDepthStencilWrites; + fragmentShadingRateWithSampleMask = in_struct->fragmentShadingRateWithSampleMask; + fragmentShadingRateWithShaderSampleMask = in_struct->fragmentShadingRateWithShaderSampleMask; + fragmentShadingRateWithConservativeRasterization = in_struct->fragmentShadingRateWithConservativeRasterization; + fragmentShadingRateWithFragmentShaderInterlock = in_struct->fragmentShadingRateWithFragmentShaderInterlock; + fragmentShadingRateWithCustomSampleLocations = in_struct->fragmentShadingRateWithCustomSampleLocations; + fragmentShadingRateStrictMultiplyCombiner = in_struct->fragmentShadingRateStrictMultiplyCombiner; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::initialize( + const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + minFragmentShadingRateAttachmentTexelSize = copy_src->minFragmentShadingRateAttachmentTexelSize; + maxFragmentShadingRateAttachmentTexelSize = copy_src->maxFragmentShadingRateAttachmentTexelSize; + maxFragmentShadingRateAttachmentTexelSizeAspectRatio = copy_src->maxFragmentShadingRateAttachmentTexelSizeAspectRatio; + primitiveFragmentShadingRateWithMultipleViewports = copy_src->primitiveFragmentShadingRateWithMultipleViewports; + layeredShadingRateAttachments = copy_src->layeredShadingRateAttachments; + fragmentShadingRateNonTrivialCombinerOps = copy_src->fragmentShadingRateNonTrivialCombinerOps; + maxFragmentSize = copy_src->maxFragmentSize; + maxFragmentSizeAspectRatio = copy_src->maxFragmentSizeAspectRatio; + maxFragmentShadingRateCoverageSamples = copy_src->maxFragmentShadingRateCoverageSamples; + maxFragmentShadingRateRasterizationSamples = copy_src->maxFragmentShadingRateRasterizationSamples; + fragmentShadingRateWithShaderDepthStencilWrites = copy_src->fragmentShadingRateWithShaderDepthStencilWrites; + fragmentShadingRateWithSampleMask = copy_src->fragmentShadingRateWithSampleMask; + fragmentShadingRateWithShaderSampleMask = copy_src->fragmentShadingRateWithShaderSampleMask; + fragmentShadingRateWithConservativeRasterization = copy_src->fragmentShadingRateWithConservativeRasterization; + fragmentShadingRateWithFragmentShaderInterlock = copy_src->fragmentShadingRateWithFragmentShaderInterlock; + fragmentShadingRateWithCustomSampleLocations = copy_src->fragmentShadingRateWithCustomSampleLocations; + fragmentShadingRateStrictMultiplyCombiner = copy_src->fragmentShadingRateStrictMultiplyCombiner; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceFragmentShadingRateKHR::safe_VkPhysicalDeviceFragmentShadingRateKHR( + const VkPhysicalDeviceFragmentShadingRateKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), sampleCounts(in_struct->sampleCounts), fragmentSize(in_struct->fragmentSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceFragmentShadingRateKHR::safe_VkPhysicalDeviceFragmentShadingRateKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR), pNext(nullptr), sampleCounts(), fragmentSize() {} + +safe_VkPhysicalDeviceFragmentShadingRateKHR::safe_VkPhysicalDeviceFragmentShadingRateKHR( + const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src) { + sType = copy_src.sType; + sampleCounts = copy_src.sampleCounts; + fragmentSize = copy_src.fragmentSize; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceFragmentShadingRateKHR& safe_VkPhysicalDeviceFragmentShadingRateKHR::operator=( + const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + sampleCounts = copy_src.sampleCounts; + fragmentSize = copy_src.fragmentSize; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceFragmentShadingRateKHR::~safe_VkPhysicalDeviceFragmentShadingRateKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceFragmentShadingRateKHR::initialize(const VkPhysicalDeviceFragmentShadingRateKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + sampleCounts = in_struct->sampleCounts; + fragmentSize = in_struct->fragmentSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceFragmentShadingRateKHR::initialize(const safe_VkPhysicalDeviceFragmentShadingRateKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + sampleCounts = copy_src->sampleCounts; + fragmentSize = copy_src->fragmentSize; + 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( + const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src) { + sType = copy_src.sType; + pipelineExecutableInfo = copy_src.pipelineExecutableInfo; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& +safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::operator=( + const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pipelineExecutableInfo = copy_src.pipelineExecutableInfo; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::~safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::initialize( + const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pipelineExecutableInfo = in_struct->pipelineExecutableInfo; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::initialize( + const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipelineExecutableInfo = copy_src->pipelineExecutableInfo; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineInfoKHR::safe_VkPipelineInfoKHR(const VkPipelineInfoKHR* 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_VkPipelineInfoKHR::safe_VkPipelineInfoKHR() : sType(VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR), pNext(nullptr), pipeline() {} + +safe_VkPipelineInfoKHR::safe_VkPipelineInfoKHR(const safe_VkPipelineInfoKHR& copy_src) { + sType = copy_src.sType; + pipeline = copy_src.pipeline; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineInfoKHR& safe_VkPipelineInfoKHR::operator=(const safe_VkPipelineInfoKHR& 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_VkPipelineInfoKHR::~safe_VkPipelineInfoKHR() { FreePnextChain(pNext); } + +void safe_VkPipelineInfoKHR::initialize(const VkPipelineInfoKHR* 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_VkPipelineInfoKHR::initialize(const safe_VkPipelineInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipeline = copy_src->pipeline; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineExecutablePropertiesKHR::safe_VkPipelineExecutablePropertiesKHR(const VkPipelineExecutablePropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), stages(in_struct->stages), subgroupSize(in_struct->subgroupSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = in_struct->name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = in_struct->description[i]; + } +} + +safe_VkPipelineExecutablePropertiesKHR::safe_VkPipelineExecutablePropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR), pNext(nullptr), stages(), subgroupSize() {} + +safe_VkPipelineExecutablePropertiesKHR::safe_VkPipelineExecutablePropertiesKHR( + const safe_VkPipelineExecutablePropertiesKHR& copy_src) { + sType = copy_src.sType; + stages = copy_src.stages; + subgroupSize = copy_src.subgroupSize; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = copy_src.name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = copy_src.description[i]; + } +} + +safe_VkPipelineExecutablePropertiesKHR& safe_VkPipelineExecutablePropertiesKHR::operator=( + const safe_VkPipelineExecutablePropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + stages = copy_src.stages; + subgroupSize = copy_src.subgroupSize; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = copy_src.name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = copy_src.description[i]; + } + + return *this; +} + +safe_VkPipelineExecutablePropertiesKHR::~safe_VkPipelineExecutablePropertiesKHR() { FreePnextChain(pNext); } + +void safe_VkPipelineExecutablePropertiesKHR::initialize(const VkPipelineExecutablePropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + stages = in_struct->stages; + subgroupSize = in_struct->subgroupSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = in_struct->name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = in_struct->description[i]; + } +} + +void safe_VkPipelineExecutablePropertiesKHR::initialize(const safe_VkPipelineExecutablePropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stages = copy_src->stages; + subgroupSize = copy_src->subgroupSize; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = copy_src->name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = copy_src->description[i]; + } +} + +safe_VkPipelineExecutableInfoKHR::safe_VkPipelineExecutableInfoKHR(const VkPipelineExecutableInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pipeline(in_struct->pipeline), executableIndex(in_struct->executableIndex) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineExecutableInfoKHR::safe_VkPipelineExecutableInfoKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR), pNext(nullptr), pipeline(), executableIndex() {} + +safe_VkPipelineExecutableInfoKHR::safe_VkPipelineExecutableInfoKHR(const safe_VkPipelineExecutableInfoKHR& copy_src) { + sType = copy_src.sType; + pipeline = copy_src.pipeline; + executableIndex = copy_src.executableIndex; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineExecutableInfoKHR& safe_VkPipelineExecutableInfoKHR::operator=(const safe_VkPipelineExecutableInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pipeline = copy_src.pipeline; + executableIndex = copy_src.executableIndex; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineExecutableInfoKHR::~safe_VkPipelineExecutableInfoKHR() { FreePnextChain(pNext); } + +void safe_VkPipelineExecutableInfoKHR::initialize(const VkPipelineExecutableInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pipeline = in_struct->pipeline; + executableIndex = in_struct->executableIndex; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineExecutableInfoKHR::initialize(const safe_VkPipelineExecutableInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipeline = copy_src->pipeline; + executableIndex = copy_src->executableIndex; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineExecutableStatisticKHR::safe_VkPipelineExecutableStatisticKHR(const VkPipelineExecutableStatisticKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), format(in_struct->format), value(in_struct->value) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = in_struct->name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = in_struct->description[i]; + } +} + +safe_VkPipelineExecutableStatisticKHR::safe_VkPipelineExecutableStatisticKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR), pNext(nullptr), format(), value() {} + +safe_VkPipelineExecutableStatisticKHR::safe_VkPipelineExecutableStatisticKHR( + const safe_VkPipelineExecutableStatisticKHR& copy_src) { + sType = copy_src.sType; + format = copy_src.format; + value = copy_src.value; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = copy_src.name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = copy_src.description[i]; + } +} + +safe_VkPipelineExecutableStatisticKHR& safe_VkPipelineExecutableStatisticKHR::operator=( + const safe_VkPipelineExecutableStatisticKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + format = copy_src.format; + value = copy_src.value; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = copy_src.name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = copy_src.description[i]; + } + + return *this; +} + +safe_VkPipelineExecutableStatisticKHR::~safe_VkPipelineExecutableStatisticKHR() { FreePnextChain(pNext); } + +void safe_VkPipelineExecutableStatisticKHR::initialize(const VkPipelineExecutableStatisticKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + format = in_struct->format; + value = in_struct->value; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = in_struct->name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = in_struct->description[i]; + } +} + +void safe_VkPipelineExecutableStatisticKHR::initialize(const safe_VkPipelineExecutableStatisticKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + format = copy_src->format; + value = copy_src->value; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = copy_src->name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = copy_src->description[i]; + } +} + +safe_VkPipelineExecutableInternalRepresentationKHR::safe_VkPipelineExecutableInternalRepresentationKHR( + const VkPipelineExecutableInternalRepresentationKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), isText(in_struct->isText), dataSize(in_struct->dataSize), pData(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = in_struct->name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = in_struct->description[i]; + } + + 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_VkPipelineExecutableInternalRepresentationKHR::safe_VkPipelineExecutableInternalRepresentationKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR), + pNext(nullptr), + isText(), + dataSize(), + pData(nullptr) {} + +safe_VkPipelineExecutableInternalRepresentationKHR::safe_VkPipelineExecutableInternalRepresentationKHR( + const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src) { + sType = copy_src.sType; + isText = copy_src.isText; + dataSize = copy_src.dataSize; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = copy_src.name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = copy_src.description[i]; + } + + 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_VkPipelineExecutableInternalRepresentationKHR& safe_VkPipelineExecutableInternalRepresentationKHR::operator=( + const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src) { + if (©_src == this) return *this; + + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + FreePnextChain(pNext); + + sType = copy_src.sType; + isText = copy_src.isText; + dataSize = copy_src.dataSize; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = copy_src.name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = copy_src.description[i]; + } + + 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_VkPipelineExecutableInternalRepresentationKHR::~safe_VkPipelineExecutableInternalRepresentationKHR() { + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + FreePnextChain(pNext); +} + +void safe_VkPipelineExecutableInternalRepresentationKHR::initialize(const VkPipelineExecutableInternalRepresentationKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } FreePnextChain(pNext); sType = in_struct->sType; - minFragmentShadingRateAttachmentTexelSize = in_struct->minFragmentShadingRateAttachmentTexelSize; - maxFragmentShadingRateAttachmentTexelSize = in_struct->maxFragmentShadingRateAttachmentTexelSize; - maxFragmentShadingRateAttachmentTexelSizeAspectRatio = in_struct->maxFragmentShadingRateAttachmentTexelSizeAspectRatio; - primitiveFragmentShadingRateWithMultipleViewports = in_struct->primitiveFragmentShadingRateWithMultipleViewports; - layeredShadingRateAttachments = in_struct->layeredShadingRateAttachments; - fragmentShadingRateNonTrivialCombinerOps = in_struct->fragmentShadingRateNonTrivialCombinerOps; - maxFragmentSize = in_struct->maxFragmentSize; - maxFragmentSizeAspectRatio = in_struct->maxFragmentSizeAspectRatio; - maxFragmentShadingRateCoverageSamples = in_struct->maxFragmentShadingRateCoverageSamples; - maxFragmentShadingRateRasterizationSamples = in_struct->maxFragmentShadingRateRasterizationSamples; - fragmentShadingRateWithShaderDepthStencilWrites = in_struct->fragmentShadingRateWithShaderDepthStencilWrites; - fragmentShadingRateWithSampleMask = in_struct->fragmentShadingRateWithSampleMask; - fragmentShadingRateWithShaderSampleMask = in_struct->fragmentShadingRateWithShaderSampleMask; - fragmentShadingRateWithConservativeRasterization = in_struct->fragmentShadingRateWithConservativeRasterization; - fragmentShadingRateWithFragmentShaderInterlock = in_struct->fragmentShadingRateWithFragmentShaderInterlock; - fragmentShadingRateWithCustomSampleLocations = in_struct->fragmentShadingRateWithCustomSampleLocations; - fragmentShadingRateStrictMultiplyCombiner = in_struct->fragmentShadingRateStrictMultiplyCombiner; + isText = in_struct->isText; + dataSize = in_struct->dataSize; pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = in_struct->name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = in_struct->description[i]; + } + + 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_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::initialize( - const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPipelineExecutableInternalRepresentationKHR::initialize( + const safe_VkPipelineExecutableInternalRepresentationKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - minFragmentShadingRateAttachmentTexelSize = copy_src->minFragmentShadingRateAttachmentTexelSize; - maxFragmentShadingRateAttachmentTexelSize = copy_src->maxFragmentShadingRateAttachmentTexelSize; - maxFragmentShadingRateAttachmentTexelSizeAspectRatio = copy_src->maxFragmentShadingRateAttachmentTexelSizeAspectRatio; - primitiveFragmentShadingRateWithMultipleViewports = copy_src->primitiveFragmentShadingRateWithMultipleViewports; - layeredShadingRateAttachments = copy_src->layeredShadingRateAttachments; - fragmentShadingRateNonTrivialCombinerOps = copy_src->fragmentShadingRateNonTrivialCombinerOps; - maxFragmentSize = copy_src->maxFragmentSize; - maxFragmentSizeAspectRatio = copy_src->maxFragmentSizeAspectRatio; - maxFragmentShadingRateCoverageSamples = copy_src->maxFragmentShadingRateCoverageSamples; - maxFragmentShadingRateRasterizationSamples = copy_src->maxFragmentShadingRateRasterizationSamples; - fragmentShadingRateWithShaderDepthStencilWrites = copy_src->fragmentShadingRateWithShaderDepthStencilWrites; - fragmentShadingRateWithSampleMask = copy_src->fragmentShadingRateWithSampleMask; - fragmentShadingRateWithShaderSampleMask = copy_src->fragmentShadingRateWithShaderSampleMask; - fragmentShadingRateWithConservativeRasterization = copy_src->fragmentShadingRateWithConservativeRasterization; - fragmentShadingRateWithFragmentShaderInterlock = copy_src->fragmentShadingRateWithFragmentShaderInterlock; - fragmentShadingRateWithCustomSampleLocations = copy_src->fragmentShadingRateWithCustomSampleLocations; - fragmentShadingRateStrictMultiplyCombiner = copy_src->fragmentShadingRateStrictMultiplyCombiner; + isText = copy_src->isText; + dataSize = copy_src->dataSize; pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + name[i] = copy_src->name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = copy_src->description[i]; + } + + 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_VkPhysicalDeviceFragmentShadingRateKHR::safe_VkPhysicalDeviceFragmentShadingRateKHR( - const VkPhysicalDeviceFragmentShadingRateKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), sampleCounts(in_struct->sampleCounts), fragmentSize(in_struct->fragmentSize) { +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_VkPhysicalDeviceFragmentShadingRateKHR::safe_VkPhysicalDeviceFragmentShadingRateKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR), pNext(nullptr), sampleCounts(), fragmentSize() {} +safe_VkMemoryMapInfoKHR::safe_VkMemoryMapInfoKHR() + : sType(VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR), pNext(nullptr), flags(), memory(), offset(), size() {} -safe_VkPhysicalDeviceFragmentShadingRateKHR::safe_VkPhysicalDeviceFragmentShadingRateKHR( - const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src) { +safe_VkMemoryMapInfoKHR::safe_VkMemoryMapInfoKHR(const safe_VkMemoryMapInfoKHR& copy_src) { sType = copy_src.sType; - sampleCounts = copy_src.sampleCounts; - fragmentSize = copy_src.fragmentSize; + flags = copy_src.flags; + memory = copy_src.memory; + offset = copy_src.offset; + size = copy_src.size; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceFragmentShadingRateKHR& safe_VkPhysicalDeviceFragmentShadingRateKHR::operator=( - const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src) { +safe_VkMemoryMapInfoKHR& safe_VkMemoryMapInfoKHR::operator=(const safe_VkMemoryMapInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - sampleCounts = copy_src.sampleCounts; - fragmentSize = copy_src.fragmentSize; + flags = copy_src.flags; + memory = copy_src.memory; + offset = copy_src.offset; + size = copy_src.size; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceFragmentShadingRateKHR::~safe_VkPhysicalDeviceFragmentShadingRateKHR() { FreePnextChain(pNext); } +safe_VkMemoryMapInfoKHR::~safe_VkMemoryMapInfoKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceFragmentShadingRateKHR::initialize(const VkPhysicalDeviceFragmentShadingRateKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkMemoryMapInfoKHR::initialize(const VkMemoryMapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - sampleCounts = in_struct->sampleCounts; - fragmentSize = in_struct->fragmentSize; + 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_VkPhysicalDeviceFragmentShadingRateKHR::initialize(const safe_VkPhysicalDeviceFragmentShadingRateKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkMemoryMapInfoKHR::initialize(const safe_VkMemoryMapInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - sampleCounts = copy_src->sampleCounts; - fragmentSize = copy_src->fragmentSize; + flags = copy_src->flags; + memory = copy_src->memory; + offset = copy_src->offset; + size = copy_src->size; 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) { +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_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR() - : sType(VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR), pNext(nullptr), supportsProtected() {} +safe_VkMemoryUnmapInfoKHR::safe_VkMemoryUnmapInfoKHR() + : sType(VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR), pNext(nullptr), flags(), memory() {} -safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR( - const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src) { +safe_VkMemoryUnmapInfoKHR::safe_VkMemoryUnmapInfoKHR(const safe_VkMemoryUnmapInfoKHR& copy_src) { sType = copy_src.sType; - supportsProtected = copy_src.supportsProtected; + flags = copy_src.flags; + memory = copy_src.memory; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkSurfaceProtectedCapabilitiesKHR& safe_VkSurfaceProtectedCapabilitiesKHR::operator=( - const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src) { +safe_VkMemoryUnmapInfoKHR& safe_VkMemoryUnmapInfoKHR::operator=(const safe_VkMemoryUnmapInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - supportsProtected = copy_src.supportsProtected; + flags = copy_src.flags; + memory = copy_src.memory; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkSurfaceProtectedCapabilitiesKHR::~safe_VkSurfaceProtectedCapabilitiesKHR() { FreePnextChain(pNext); } +safe_VkMemoryUnmapInfoKHR::~safe_VkMemoryUnmapInfoKHR() { FreePnextChain(pNext); } -void safe_VkSurfaceProtectedCapabilitiesKHR::initialize(const VkSurfaceProtectedCapabilitiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkMemoryUnmapInfoKHR::initialize(const VkMemoryUnmapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - supportsProtected = in_struct->supportsProtected; + flags = in_struct->flags; + memory = in_struct->memory; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkSurfaceProtectedCapabilitiesKHR::initialize(const safe_VkSurfaceProtectedCapabilitiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkMemoryUnmapInfoKHR::initialize(const safe_VkMemoryUnmapInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - supportsProtected = copy_src->supportsProtected; + flags = copy_src->flags; + memory = copy_src->memory; 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) { +safe_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), libraryCount(in_struct->libraryCount), pLibraries(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + if (libraryCount && in_struct->pLibraries) { + pLibraries = new VkPipeline[libraryCount]; + for (uint32_t i = 0; i < libraryCount; ++i) { + pLibraries[i] = in_struct->pLibraries[i]; + } + } } -safe_VkPhysicalDevicePresentWaitFeaturesKHR::safe_VkPhysicalDevicePresentWaitFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR), pNext(nullptr), presentWait() {} +safe_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR), pNext(nullptr), libraryCount(), pLibraries(nullptr) {} -safe_VkPhysicalDevicePresentWaitFeaturesKHR::safe_VkPhysicalDevicePresentWaitFeaturesKHR( - const safe_VkPhysicalDevicePresentWaitFeaturesKHR& copy_src) { +safe_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR(const safe_VkPipelineLibraryCreateInfoKHR& copy_src) { sType = copy_src.sType; - presentWait = copy_src.presentWait; + libraryCount = copy_src.libraryCount; + pLibraries = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (libraryCount && copy_src.pLibraries) { + pLibraries = new VkPipeline[libraryCount]; + for (uint32_t i = 0; i < libraryCount; ++i) { + pLibraries[i] = copy_src.pLibraries[i]; + } + } } -safe_VkPhysicalDevicePresentWaitFeaturesKHR& safe_VkPhysicalDevicePresentWaitFeaturesKHR::operator=( - const safe_VkPhysicalDevicePresentWaitFeaturesKHR& copy_src) { +safe_VkPipelineLibraryCreateInfoKHR& safe_VkPipelineLibraryCreateInfoKHR::operator=( + const safe_VkPipelineLibraryCreateInfoKHR& copy_src) { if (©_src == this) return *this; + if (pLibraries) delete[] pLibraries; FreePnextChain(pNext); sType = copy_src.sType; - presentWait = copy_src.presentWait; + libraryCount = copy_src.libraryCount; + pLibraries = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (libraryCount && copy_src.pLibraries) { + pLibraries = new VkPipeline[libraryCount]; + for (uint32_t i = 0; i < libraryCount; ++i) { + pLibraries[i] = copy_src.pLibraries[i]; + } + } return *this; } -safe_VkPhysicalDevicePresentWaitFeaturesKHR::~safe_VkPhysicalDevicePresentWaitFeaturesKHR() { FreePnextChain(pNext); } +safe_VkPipelineLibraryCreateInfoKHR::~safe_VkPipelineLibraryCreateInfoKHR() { + if (pLibraries) delete[] pLibraries; + FreePnextChain(pNext); +} -void safe_VkPhysicalDevicePresentWaitFeaturesKHR::initialize(const VkPhysicalDevicePresentWaitFeaturesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPipelineLibraryCreateInfoKHR::initialize(const VkPipelineLibraryCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pLibraries) delete[] pLibraries; FreePnextChain(pNext); sType = in_struct->sType; - presentWait = in_struct->presentWait; + libraryCount = in_struct->libraryCount; + pLibraries = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (libraryCount && in_struct->pLibraries) { + pLibraries = new VkPipeline[libraryCount]; + for (uint32_t i = 0; i < libraryCount; ++i) { + pLibraries[i] = in_struct->pLibraries[i]; + } + } } -void safe_VkPhysicalDevicePresentWaitFeaturesKHR::initialize(const safe_VkPhysicalDevicePresentWaitFeaturesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPipelineLibraryCreateInfoKHR::initialize(const safe_VkPipelineLibraryCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - presentWait = copy_src->presentWait; + libraryCount = copy_src->libraryCount; + pLibraries = nullptr; pNext = SafePnextCopy(copy_src->pNext); + if (libraryCount && copy_src->pLibraries) { + pLibraries = new VkPipeline[libraryCount]; + for (uint32_t i = 0; i < libraryCount; ++i) { + pLibraries[i] = copy_src->pLibraries[i]; + } + } } -safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR( - const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), pipelineExecutableInfo(in_struct->pipelineExecutableInfo) { +safe_VkPresentIdKHR::safe_VkPresentIdKHR(const VkPresentIdKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pPresentIds(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + if (in_struct->pPresentIds) { + pPresentIds = new uint64_t[in_struct->swapchainCount]; + memcpy((void*)pPresentIds, (void*)in_struct->pPresentIds, sizeof(uint64_t) * in_struct->swapchainCount); + } } -safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR), - pNext(nullptr), - pipelineExecutableInfo() {} +safe_VkPresentIdKHR::safe_VkPresentIdKHR() + : sType(VK_STRUCTURE_TYPE_PRESENT_ID_KHR), pNext(nullptr), swapchainCount(), pPresentIds(nullptr) {} -safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR( - const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src) { +safe_VkPresentIdKHR::safe_VkPresentIdKHR(const safe_VkPresentIdKHR& copy_src) { sType = copy_src.sType; - pipelineExecutableInfo = copy_src.pipelineExecutableInfo; + swapchainCount = copy_src.swapchainCount; + pPresentIds = nullptr; pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPresentIds) { + pPresentIds = new uint64_t[copy_src.swapchainCount]; + memcpy((void*)pPresentIds, (void*)copy_src.pPresentIds, sizeof(uint64_t) * copy_src.swapchainCount); + } } -safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& -safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::operator=( - const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src) { +safe_VkPresentIdKHR& safe_VkPresentIdKHR::operator=(const safe_VkPresentIdKHR& copy_src) { if (©_src == this) return *this; + if (pPresentIds) delete[] pPresentIds; FreePnextChain(pNext); sType = copy_src.sType; - pipelineExecutableInfo = copy_src.pipelineExecutableInfo; + swapchainCount = copy_src.swapchainCount; + pPresentIds = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pPresentIds) { + pPresentIds = new uint64_t[copy_src.swapchainCount]; + memcpy((void*)pPresentIds, (void*)copy_src.pPresentIds, sizeof(uint64_t) * copy_src.swapchainCount); + } + return *this; } -safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::~safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR() { +safe_VkPresentIdKHR::~safe_VkPresentIdKHR() { + if (pPresentIds) delete[] pPresentIds; FreePnextChain(pNext); } -void safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::initialize( - const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPresentIdKHR::initialize(const VkPresentIdKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pPresentIds) delete[] pPresentIds; FreePnextChain(pNext); sType = in_struct->sType; - pipelineExecutableInfo = in_struct->pipelineExecutableInfo; + swapchainCount = in_struct->swapchainCount; + pPresentIds = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pPresentIds) { + pPresentIds = new uint64_t[in_struct->swapchainCount]; + memcpy((void*)pPresentIds, (void*)in_struct->pPresentIds, sizeof(uint64_t) * in_struct->swapchainCount); + } } -void safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::initialize( - const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPresentIdKHR::initialize(const safe_VkPresentIdKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - pipelineExecutableInfo = copy_src->pipelineExecutableInfo; + swapchainCount = copy_src->swapchainCount; + pPresentIds = nullptr; pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pPresentIds) { + pPresentIds = new uint64_t[copy_src->swapchainCount]; + memcpy((void*)pPresentIds, (void*)copy_src->pPresentIds, sizeof(uint64_t) * copy_src->swapchainCount); + } } -safe_VkPipelineInfoKHR::safe_VkPipelineInfoKHR(const VkPipelineInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), pipeline(in_struct->pipeline) { +safe_VkPhysicalDevicePresentIdFeaturesKHR::safe_VkPhysicalDevicePresentIdFeaturesKHR( + const VkPhysicalDevicePresentIdFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), presentId(in_struct->presentId) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPipelineInfoKHR::safe_VkPipelineInfoKHR() : sType(VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR), pNext(nullptr), pipeline() {} +safe_VkPhysicalDevicePresentIdFeaturesKHR::safe_VkPhysicalDevicePresentIdFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR), pNext(nullptr), presentId() {} -safe_VkPipelineInfoKHR::safe_VkPipelineInfoKHR(const safe_VkPipelineInfoKHR& copy_src) { +safe_VkPhysicalDevicePresentIdFeaturesKHR::safe_VkPhysicalDevicePresentIdFeaturesKHR( + const safe_VkPhysicalDevicePresentIdFeaturesKHR& copy_src) { sType = copy_src.sType; - pipeline = copy_src.pipeline; + presentId = copy_src.presentId; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPipelineInfoKHR& safe_VkPipelineInfoKHR::operator=(const safe_VkPipelineInfoKHR& copy_src) { +safe_VkPhysicalDevicePresentIdFeaturesKHR& safe_VkPhysicalDevicePresentIdFeaturesKHR::operator=( + const safe_VkPhysicalDevicePresentIdFeaturesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - pipeline = copy_src.pipeline; + presentId = copy_src.presentId; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPipelineInfoKHR::~safe_VkPipelineInfoKHR() { FreePnextChain(pNext); } +safe_VkPhysicalDevicePresentIdFeaturesKHR::~safe_VkPhysicalDevicePresentIdFeaturesKHR() { FreePnextChain(pNext); } -void safe_VkPipelineInfoKHR::initialize(const VkPipelineInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDevicePresentIdFeaturesKHR::initialize(const VkPhysicalDevicePresentIdFeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - pipeline = in_struct->pipeline; + presentId = in_struct->presentId; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPipelineInfoKHR::initialize(const safe_VkPipelineInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDevicePresentIdFeaturesKHR::initialize(const safe_VkPhysicalDevicePresentIdFeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - pipeline = copy_src->pipeline; + presentId = copy_src->presentId; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPipelineExecutablePropertiesKHR::safe_VkPipelineExecutablePropertiesKHR(const VkPipelineExecutablePropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), stages(in_struct->stages), subgroupSize(in_struct->subgroupSize) { +safe_VkVideoEncodeInfoKHR::safe_VkVideoEncodeInfoKHR(const VkVideoEncodeInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + dstBuffer(in_struct->dstBuffer), + dstBufferOffset(in_struct->dstBufferOffset), + dstBufferRange(in_struct->dstBufferRange), + srcPictureResource(&in_struct->srcPictureResource), + pSetupReferenceSlot(nullptr), + referenceSlotCount(in_struct->referenceSlotCount), + pReferenceSlots(nullptr), + precedingExternallyEncodedBytes(in_struct->precedingExternallyEncodedBytes) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = in_struct->name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = in_struct->description[i]; + if (in_struct->pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(in_struct->pSetupReferenceSlot); + if (referenceSlotCount && in_struct->pReferenceSlots) { + pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount]; + for (uint32_t i = 0; i < referenceSlotCount; ++i) { + pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]); + } } } -safe_VkPipelineExecutablePropertiesKHR::safe_VkPipelineExecutablePropertiesKHR() - : sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR), pNext(nullptr), stages(), subgroupSize() {} +safe_VkVideoEncodeInfoKHR::safe_VkVideoEncodeInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR), + pNext(nullptr), + flags(), + dstBuffer(), + dstBufferOffset(), + dstBufferRange(), + pSetupReferenceSlot(nullptr), + referenceSlotCount(), + pReferenceSlots(nullptr), + precedingExternallyEncodedBytes() {} -safe_VkPipelineExecutablePropertiesKHR::safe_VkPipelineExecutablePropertiesKHR( - const safe_VkPipelineExecutablePropertiesKHR& copy_src) { +safe_VkVideoEncodeInfoKHR::safe_VkVideoEncodeInfoKHR(const safe_VkVideoEncodeInfoKHR& copy_src) { sType = copy_src.sType; - stages = copy_src.stages; - subgroupSize = copy_src.subgroupSize; + flags = copy_src.flags; + dstBuffer = copy_src.dstBuffer; + dstBufferOffset = copy_src.dstBufferOffset; + dstBufferRange = copy_src.dstBufferRange; + srcPictureResource.initialize(©_src.srcPictureResource); + pSetupReferenceSlot = nullptr; + referenceSlotCount = copy_src.referenceSlotCount; + pReferenceSlots = nullptr; + precedingExternallyEncodedBytes = copy_src.precedingExternallyEncodedBytes; pNext = SafePnextCopy(copy_src.pNext); - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = copy_src.name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = copy_src.description[i]; + if (copy_src.pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(*copy_src.pSetupReferenceSlot); + if (referenceSlotCount && copy_src.pReferenceSlots) { + pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount]; + for (uint32_t i = 0; i < referenceSlotCount; ++i) { + pReferenceSlots[i].initialize(©_src.pReferenceSlots[i]); + } } } -safe_VkPipelineExecutablePropertiesKHR& safe_VkPipelineExecutablePropertiesKHR::operator=( - const safe_VkPipelineExecutablePropertiesKHR& copy_src) { +safe_VkVideoEncodeInfoKHR& safe_VkVideoEncodeInfoKHR::operator=(const safe_VkVideoEncodeInfoKHR& copy_src) { if (©_src == this) return *this; + if (pSetupReferenceSlot) delete pSetupReferenceSlot; + if (pReferenceSlots) delete[] pReferenceSlots; FreePnextChain(pNext); sType = copy_src.sType; - stages = copy_src.stages; - subgroupSize = copy_src.subgroupSize; + flags = copy_src.flags; + dstBuffer = copy_src.dstBuffer; + dstBufferOffset = copy_src.dstBufferOffset; + dstBufferRange = copy_src.dstBufferRange; + srcPictureResource.initialize(©_src.srcPictureResource); + pSetupReferenceSlot = nullptr; + referenceSlotCount = copy_src.referenceSlotCount; + pReferenceSlots = nullptr; + precedingExternallyEncodedBytes = copy_src.precedingExternallyEncodedBytes; pNext = SafePnextCopy(copy_src.pNext); - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = copy_src.name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = copy_src.description[i]; + if (copy_src.pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(*copy_src.pSetupReferenceSlot); + if (referenceSlotCount && copy_src.pReferenceSlots) { + pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount]; + for (uint32_t i = 0; i < referenceSlotCount; ++i) { + pReferenceSlots[i].initialize(©_src.pReferenceSlots[i]); + } } return *this; } -safe_VkPipelineExecutablePropertiesKHR::~safe_VkPipelineExecutablePropertiesKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeInfoKHR::~safe_VkVideoEncodeInfoKHR() { + if (pSetupReferenceSlot) delete pSetupReferenceSlot; + if (pReferenceSlots) delete[] pReferenceSlots; + FreePnextChain(pNext); +} -void safe_VkPipelineExecutablePropertiesKHR::initialize(const VkPipelineExecutablePropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeInfoKHR::initialize(const VkVideoEncodeInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pSetupReferenceSlot) delete pSetupReferenceSlot; + if (pReferenceSlots) delete[] pReferenceSlots; FreePnextChain(pNext); sType = in_struct->sType; - stages = in_struct->stages; - subgroupSize = in_struct->subgroupSize; + flags = in_struct->flags; + dstBuffer = in_struct->dstBuffer; + dstBufferOffset = in_struct->dstBufferOffset; + dstBufferRange = in_struct->dstBufferRange; + srcPictureResource.initialize(&in_struct->srcPictureResource); + pSetupReferenceSlot = nullptr; + referenceSlotCount = in_struct->referenceSlotCount; + pReferenceSlots = nullptr; + precedingExternallyEncodedBytes = in_struct->precedingExternallyEncodedBytes; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = in_struct->name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = in_struct->description[i]; + if (in_struct->pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(in_struct->pSetupReferenceSlot); + if (referenceSlotCount && in_struct->pReferenceSlots) { + pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount]; + for (uint32_t i = 0; i < referenceSlotCount; ++i) { + pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]); + } } } -void safe_VkPipelineExecutablePropertiesKHR::initialize(const safe_VkPipelineExecutablePropertiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeInfoKHR::initialize(const safe_VkVideoEncodeInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - stages = copy_src->stages; - subgroupSize = copy_src->subgroupSize; + flags = copy_src->flags; + dstBuffer = copy_src->dstBuffer; + dstBufferOffset = copy_src->dstBufferOffset; + dstBufferRange = copy_src->dstBufferRange; + srcPictureResource.initialize(©_src->srcPictureResource); + pSetupReferenceSlot = nullptr; + referenceSlotCount = copy_src->referenceSlotCount; + pReferenceSlots = nullptr; + precedingExternallyEncodedBytes = copy_src->precedingExternallyEncodedBytes; pNext = SafePnextCopy(copy_src->pNext); - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = copy_src->name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = copy_src->description[i]; + if (copy_src->pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(*copy_src->pSetupReferenceSlot); + if (referenceSlotCount && copy_src->pReferenceSlots) { + pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount]; + for (uint32_t i = 0; i < referenceSlotCount; ++i) { + pReferenceSlots[i].initialize(©_src->pReferenceSlots[i]); + } } } -safe_VkPipelineExecutableInfoKHR::safe_VkPipelineExecutableInfoKHR(const VkPipelineExecutableInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), pipeline(in_struct->pipeline), executableIndex(in_struct->executableIndex) { +safe_VkVideoEncodeCapabilitiesKHR::safe_VkVideoEncodeCapabilitiesKHR(const VkVideoEncodeCapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + rateControlModes(in_struct->rateControlModes), + maxRateControlLayers(in_struct->maxRateControlLayers), + maxBitrate(in_struct->maxBitrate), + maxQualityLevels(in_struct->maxQualityLevels), + encodeInputPictureGranularity(in_struct->encodeInputPictureGranularity), + supportedEncodeFeedbackFlags(in_struct->supportedEncodeFeedbackFlags) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPipelineExecutableInfoKHR::safe_VkPipelineExecutableInfoKHR() - : sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR), pNext(nullptr), pipeline(), executableIndex() {} +safe_VkVideoEncodeCapabilitiesKHR::safe_VkVideoEncodeCapabilitiesKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR), + pNext(nullptr), + flags(), + rateControlModes(), + maxRateControlLayers(), + maxBitrate(), + maxQualityLevels(), + encodeInputPictureGranularity(), + supportedEncodeFeedbackFlags() {} -safe_VkPipelineExecutableInfoKHR::safe_VkPipelineExecutableInfoKHR(const safe_VkPipelineExecutableInfoKHR& copy_src) { +safe_VkVideoEncodeCapabilitiesKHR::safe_VkVideoEncodeCapabilitiesKHR(const safe_VkVideoEncodeCapabilitiesKHR& copy_src) { sType = copy_src.sType; - pipeline = copy_src.pipeline; - executableIndex = copy_src.executableIndex; + flags = copy_src.flags; + rateControlModes = copy_src.rateControlModes; + maxRateControlLayers = copy_src.maxRateControlLayers; + maxBitrate = copy_src.maxBitrate; + maxQualityLevels = copy_src.maxQualityLevels; + encodeInputPictureGranularity = copy_src.encodeInputPictureGranularity; + supportedEncodeFeedbackFlags = copy_src.supportedEncodeFeedbackFlags; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPipelineExecutableInfoKHR& safe_VkPipelineExecutableInfoKHR::operator=(const safe_VkPipelineExecutableInfoKHR& copy_src) { +safe_VkVideoEncodeCapabilitiesKHR& safe_VkVideoEncodeCapabilitiesKHR::operator=(const safe_VkVideoEncodeCapabilitiesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - pipeline = copy_src.pipeline; - executableIndex = copy_src.executableIndex; + flags = copy_src.flags; + rateControlModes = copy_src.rateControlModes; + maxRateControlLayers = copy_src.maxRateControlLayers; + maxBitrate = copy_src.maxBitrate; + maxQualityLevels = copy_src.maxQualityLevels; + encodeInputPictureGranularity = copy_src.encodeInputPictureGranularity; + supportedEncodeFeedbackFlags = copy_src.supportedEncodeFeedbackFlags; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPipelineExecutableInfoKHR::~safe_VkPipelineExecutableInfoKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeCapabilitiesKHR::~safe_VkVideoEncodeCapabilitiesKHR() { FreePnextChain(pNext); } -void safe_VkPipelineExecutableInfoKHR::initialize(const VkPipelineExecutableInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeCapabilitiesKHR::initialize(const VkVideoEncodeCapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - pipeline = in_struct->pipeline; - executableIndex = in_struct->executableIndex; + flags = in_struct->flags; + rateControlModes = in_struct->rateControlModes; + maxRateControlLayers = in_struct->maxRateControlLayers; + maxBitrate = in_struct->maxBitrate; + maxQualityLevels = in_struct->maxQualityLevels; + encodeInputPictureGranularity = in_struct->encodeInputPictureGranularity; + supportedEncodeFeedbackFlags = in_struct->supportedEncodeFeedbackFlags; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPipelineExecutableInfoKHR::initialize(const safe_VkPipelineExecutableInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeCapabilitiesKHR::initialize(const safe_VkVideoEncodeCapabilitiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - pipeline = copy_src->pipeline; - executableIndex = copy_src->executableIndex; + flags = copy_src->flags; + rateControlModes = copy_src->rateControlModes; + maxRateControlLayers = copy_src->maxRateControlLayers; + maxBitrate = copy_src->maxBitrate; + maxQualityLevels = copy_src->maxQualityLevels; + encodeInputPictureGranularity = copy_src->encodeInputPictureGranularity; + supportedEncodeFeedbackFlags = copy_src->supportedEncodeFeedbackFlags; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPipelineExecutableStatisticKHR::safe_VkPipelineExecutableStatisticKHR(const VkPipelineExecutableStatisticKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), format(in_struct->format), value(in_struct->value) { +safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR( + const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), encodeFeedbackFlags(in_struct->encodeFeedbackFlags) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = in_struct->name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = in_struct->description[i]; - } } -safe_VkPipelineExecutableStatisticKHR::safe_VkPipelineExecutableStatisticKHR() - : sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR), pNext(nullptr), format(), value() {} +safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR), pNext(nullptr), encodeFeedbackFlags() {} -safe_VkPipelineExecutableStatisticKHR::safe_VkPipelineExecutableStatisticKHR( - const safe_VkPipelineExecutableStatisticKHR& copy_src) { +safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR( + const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& copy_src) { sType = copy_src.sType; - format = copy_src.format; - value = copy_src.value; + encodeFeedbackFlags = copy_src.encodeFeedbackFlags; pNext = SafePnextCopy(copy_src.pNext); - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = copy_src.name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = copy_src.description[i]; - } } -safe_VkPipelineExecutableStatisticKHR& safe_VkPipelineExecutableStatisticKHR::operator=( - const safe_VkPipelineExecutableStatisticKHR& copy_src) { +safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::operator=( + const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - format = copy_src.format; - value = copy_src.value; + encodeFeedbackFlags = copy_src.encodeFeedbackFlags; pNext = SafePnextCopy(copy_src.pNext); - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = copy_src.name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = copy_src.description[i]; - } - return *this; } -safe_VkPipelineExecutableStatisticKHR::~safe_VkPipelineExecutableStatisticKHR() { FreePnextChain(pNext); } +safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::~safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR() { FreePnextChain(pNext); } -void safe_VkPipelineExecutableStatisticKHR::initialize(const VkPipelineExecutableStatisticKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::initialize(const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - format = in_struct->format; - value = in_struct->value; + encodeFeedbackFlags = in_struct->encodeFeedbackFlags; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = in_struct->name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = in_struct->description[i]; - } } -void safe_VkPipelineExecutableStatisticKHR::initialize(const safe_VkPipelineExecutableStatisticKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::initialize(const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - format = copy_src->format; - value = copy_src->value; + encodeFeedbackFlags = copy_src->encodeFeedbackFlags; pNext = SafePnextCopy(copy_src->pNext); - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = copy_src->name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = copy_src->description[i]; - } } -safe_VkPipelineExecutableInternalRepresentationKHR::safe_VkPipelineExecutableInternalRepresentationKHR( - const VkPipelineExecutableInternalRepresentationKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), isText(in_struct->isText), dataSize(in_struct->dataSize), pData(nullptr) { +safe_VkVideoEncodeUsageInfoKHR::safe_VkVideoEncodeUsageInfoKHR(const VkVideoEncodeUsageInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + videoUsageHints(in_struct->videoUsageHints), + videoContentHints(in_struct->videoContentHints), + tuningMode(in_struct->tuningMode) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = in_struct->name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = in_struct->description[i]; - } - - 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_VkPipelineExecutableInternalRepresentationKHR::safe_VkPipelineExecutableInternalRepresentationKHR() - : sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR), - pNext(nullptr), - isText(), - dataSize(), - pData(nullptr) {} +safe_VkVideoEncodeUsageInfoKHR::safe_VkVideoEncodeUsageInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR), pNext(nullptr), videoUsageHints(), videoContentHints(), tuningMode() {} -safe_VkPipelineExecutableInternalRepresentationKHR::safe_VkPipelineExecutableInternalRepresentationKHR( - const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src) { +safe_VkVideoEncodeUsageInfoKHR::safe_VkVideoEncodeUsageInfoKHR(const safe_VkVideoEncodeUsageInfoKHR& copy_src) { sType = copy_src.sType; - isText = copy_src.isText; - dataSize = copy_src.dataSize; + videoUsageHints = copy_src.videoUsageHints; + videoContentHints = copy_src.videoContentHints; + tuningMode = copy_src.tuningMode; pNext = SafePnextCopy(copy_src.pNext); - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = copy_src.name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = copy_src.description[i]; - } - - 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_VkPipelineExecutableInternalRepresentationKHR& safe_VkPipelineExecutableInternalRepresentationKHR::operator=( - const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src) { +safe_VkVideoEncodeUsageInfoKHR& safe_VkVideoEncodeUsageInfoKHR::operator=(const safe_VkVideoEncodeUsageInfoKHR& copy_src) { if (©_src == this) return *this; - if (pData != nullptr) { - auto temp = reinterpret_cast(pData); - delete[] temp; - } FreePnextChain(pNext); sType = copy_src.sType; - isText = copy_src.isText; - dataSize = copy_src.dataSize; + videoUsageHints = copy_src.videoUsageHints; + videoContentHints = copy_src.videoContentHints; + tuningMode = copy_src.tuningMode; pNext = SafePnextCopy(copy_src.pNext); - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = copy_src.name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = copy_src.description[i]; - } - - 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_VkPipelineExecutableInternalRepresentationKHR::~safe_VkPipelineExecutableInternalRepresentationKHR() { - if (pData != nullptr) { - auto temp = reinterpret_cast(pData); - delete[] temp; - } - FreePnextChain(pNext); -} +safe_VkVideoEncodeUsageInfoKHR::~safe_VkVideoEncodeUsageInfoKHR() { FreePnextChain(pNext); } -void safe_VkPipelineExecutableInternalRepresentationKHR::initialize(const VkPipelineExecutableInternalRepresentationKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pData != nullptr) { - auto temp = reinterpret_cast(pData); - delete[] temp; - } +void safe_VkVideoEncodeUsageInfoKHR::initialize(const VkVideoEncodeUsageInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - isText = in_struct->isText; - dataSize = in_struct->dataSize; + videoUsageHints = in_struct->videoUsageHints; + videoContentHints = in_struct->videoContentHints; + tuningMode = in_struct->tuningMode; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = in_struct->name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = in_struct->description[i]; - } - - 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_VkPipelineExecutableInternalRepresentationKHR::initialize( - const safe_VkPipelineExecutableInternalRepresentationKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + +void safe_VkVideoEncodeUsageInfoKHR::initialize(const safe_VkVideoEncodeUsageInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - isText = copy_src->isText; - dataSize = copy_src->dataSize; + videoUsageHints = copy_src->videoUsageHints; + videoContentHints = copy_src->videoContentHints; + tuningMode = copy_src->tuningMode; pNext = SafePnextCopy(copy_src->pNext); - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - name[i] = copy_src->name[i]; - } - - for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { - description[i] = copy_src->description[i]; - } - - 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_VkMemoryMapInfoKHR::safe_VkMemoryMapInfoKHR(const VkMemoryMapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) +safe_VkVideoEncodeRateControlLayerInfoKHR::safe_VkVideoEncodeRateControlLayerInfoKHR( + const VkVideoEncodeRateControlLayerInfoKHR* 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) { + averageBitrate(in_struct->averageBitrate), + maxBitrate(in_struct->maxBitrate), + frameRateNumerator(in_struct->frameRateNumerator), + frameRateDenominator(in_struct->frameRateDenominator) { 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_VkVideoEncodeRateControlLayerInfoKHR::safe_VkVideoEncodeRateControlLayerInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR), + pNext(nullptr), + averageBitrate(), + maxBitrate(), + frameRateNumerator(), + frameRateDenominator() {} -safe_VkMemoryMapInfoKHR::safe_VkMemoryMapInfoKHR(const safe_VkMemoryMapInfoKHR& copy_src) { +safe_VkVideoEncodeRateControlLayerInfoKHR::safe_VkVideoEncodeRateControlLayerInfoKHR( + const safe_VkVideoEncodeRateControlLayerInfoKHR& copy_src) { sType = copy_src.sType; - flags = copy_src.flags; - memory = copy_src.memory; - offset = copy_src.offset; - size = copy_src.size; + averageBitrate = copy_src.averageBitrate; + maxBitrate = copy_src.maxBitrate; + frameRateNumerator = copy_src.frameRateNumerator; + frameRateDenominator = copy_src.frameRateDenominator; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkMemoryMapInfoKHR& safe_VkMemoryMapInfoKHR::operator=(const safe_VkMemoryMapInfoKHR& copy_src) { +safe_VkVideoEncodeRateControlLayerInfoKHR& safe_VkVideoEncodeRateControlLayerInfoKHR::operator=( + const safe_VkVideoEncodeRateControlLayerInfoKHR& 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; + averageBitrate = copy_src.averageBitrate; + maxBitrate = copy_src.maxBitrate; + frameRateNumerator = copy_src.frameRateNumerator; + frameRateDenominator = copy_src.frameRateDenominator; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkMemoryMapInfoKHR::~safe_VkMemoryMapInfoKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeRateControlLayerInfoKHR::~safe_VkVideoEncodeRateControlLayerInfoKHR() { FreePnextChain(pNext); } -void safe_VkMemoryMapInfoKHR::initialize(const VkMemoryMapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeRateControlLayerInfoKHR::initialize(const VkVideoEncodeRateControlLayerInfoKHR* 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; + averageBitrate = in_struct->averageBitrate; + maxBitrate = in_struct->maxBitrate; + frameRateNumerator = in_struct->frameRateNumerator; + frameRateDenominator = in_struct->frameRateDenominator; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkMemoryMapInfoKHR::initialize(const safe_VkMemoryMapInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeRateControlLayerInfoKHR::initialize(const safe_VkVideoEncodeRateControlLayerInfoKHR* 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; + averageBitrate = copy_src->averageBitrate; + maxBitrate = copy_src->maxBitrate; + frameRateNumerator = copy_src->frameRateNumerator; + frameRateDenominator = copy_src->frameRateDenominator; 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) { +safe_VkVideoEncodeRateControlInfoKHR::safe_VkVideoEncodeRateControlInfoKHR(const VkVideoEncodeRateControlInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + rateControlMode(in_struct->rateControlMode), + layerCount(in_struct->layerCount), + pLayers(nullptr), + virtualBufferSizeInMs(in_struct->virtualBufferSizeInMs), + initialVirtualBufferSizeInMs(in_struct->initialVirtualBufferSizeInMs) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } + if (layerCount && in_struct->pLayers) { + pLayers = new safe_VkVideoEncodeRateControlLayerInfoKHR[layerCount]; + for (uint32_t i = 0; i < layerCount; ++i) { + pLayers[i].initialize(&in_struct->pLayers[i]); + } + } } -safe_VkMemoryUnmapInfoKHR::safe_VkMemoryUnmapInfoKHR() - : sType(VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR), pNext(nullptr), flags(), memory() {} +safe_VkVideoEncodeRateControlInfoKHR::safe_VkVideoEncodeRateControlInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR), + pNext(nullptr), + flags(), + rateControlMode(), + layerCount(), + pLayers(nullptr), + virtualBufferSizeInMs(), + initialVirtualBufferSizeInMs() {} -safe_VkMemoryUnmapInfoKHR::safe_VkMemoryUnmapInfoKHR(const safe_VkMemoryUnmapInfoKHR& copy_src) { +safe_VkVideoEncodeRateControlInfoKHR::safe_VkVideoEncodeRateControlInfoKHR(const safe_VkVideoEncodeRateControlInfoKHR& copy_src) { sType = copy_src.sType; flags = copy_src.flags; - memory = copy_src.memory; + rateControlMode = copy_src.rateControlMode; + layerCount = copy_src.layerCount; + pLayers = nullptr; + virtualBufferSizeInMs = copy_src.virtualBufferSizeInMs; + initialVirtualBufferSizeInMs = copy_src.initialVirtualBufferSizeInMs; pNext = SafePnextCopy(copy_src.pNext); + if (layerCount && copy_src.pLayers) { + pLayers = new safe_VkVideoEncodeRateControlLayerInfoKHR[layerCount]; + for (uint32_t i = 0; i < layerCount; ++i) { + pLayers[i].initialize(©_src.pLayers[i]); + } + } } -safe_VkMemoryUnmapInfoKHR& safe_VkMemoryUnmapInfoKHR::operator=(const safe_VkMemoryUnmapInfoKHR& copy_src) { +safe_VkVideoEncodeRateControlInfoKHR& safe_VkVideoEncodeRateControlInfoKHR::operator=( + const safe_VkVideoEncodeRateControlInfoKHR& copy_src) { if (©_src == this) return *this; + if (pLayers) delete[] pLayers; FreePnextChain(pNext); sType = copy_src.sType; flags = copy_src.flags; - memory = copy_src.memory; + rateControlMode = copy_src.rateControlMode; + layerCount = copy_src.layerCount; + pLayers = nullptr; + virtualBufferSizeInMs = copy_src.virtualBufferSizeInMs; + initialVirtualBufferSizeInMs = copy_src.initialVirtualBufferSizeInMs; pNext = SafePnextCopy(copy_src.pNext); + if (layerCount && copy_src.pLayers) { + pLayers = new safe_VkVideoEncodeRateControlLayerInfoKHR[layerCount]; + for (uint32_t i = 0; i < layerCount; ++i) { + pLayers[i].initialize(©_src.pLayers[i]); + } + } return *this; } -safe_VkMemoryUnmapInfoKHR::~safe_VkMemoryUnmapInfoKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeRateControlInfoKHR::~safe_VkVideoEncodeRateControlInfoKHR() { + if (pLayers) delete[] pLayers; + FreePnextChain(pNext); +} -void safe_VkMemoryUnmapInfoKHR::initialize(const VkMemoryUnmapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeRateControlInfoKHR::initialize(const VkVideoEncodeRateControlInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pLayers) delete[] pLayers; FreePnextChain(pNext); sType = in_struct->sType; flags = in_struct->flags; - memory = in_struct->memory; + rateControlMode = in_struct->rateControlMode; + layerCount = in_struct->layerCount; + pLayers = nullptr; + virtualBufferSizeInMs = in_struct->virtualBufferSizeInMs; + initialVirtualBufferSizeInMs = in_struct->initialVirtualBufferSizeInMs; pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (layerCount && in_struct->pLayers) { + pLayers = new safe_VkVideoEncodeRateControlLayerInfoKHR[layerCount]; + for (uint32_t i = 0; i < layerCount; ++i) { + pLayers[i].initialize(&in_struct->pLayers[i]); + } + } } -void safe_VkMemoryUnmapInfoKHR::initialize(const safe_VkMemoryUnmapInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeRateControlInfoKHR::initialize(const safe_VkVideoEncodeRateControlInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; flags = copy_src->flags; - memory = copy_src->memory; + rateControlMode = copy_src->rateControlMode; + layerCount = copy_src->layerCount; + pLayers = nullptr; + virtualBufferSizeInMs = copy_src->virtualBufferSizeInMs; + initialVirtualBufferSizeInMs = copy_src->initialVirtualBufferSizeInMs; pNext = SafePnextCopy(copy_src->pNext); + if (layerCount && copy_src->pLayers) { + pLayers = new safe_VkVideoEncodeRateControlLayerInfoKHR[layerCount]; + for (uint32_t i = 0; i < layerCount; ++i) { + pLayers[i].initialize(©_src->pLayers[i]); + } + } } -safe_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), libraryCount(in_struct->libraryCount), pLibraries(nullptr) { +safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR( + const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pVideoProfile(nullptr), qualityLevel(in_struct->qualityLevel) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (libraryCount && in_struct->pLibraries) { - pLibraries = new VkPipeline[libraryCount]; - for (uint32_t i = 0; i < libraryCount; ++i) { - pLibraries[i] = in_struct->pLibraries[i]; - } - } + if (in_struct->pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(in_struct->pVideoProfile); } -safe_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR() - : sType(VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR), pNext(nullptr), libraryCount(), pLibraries(nullptr) {} +safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR), + pNext(nullptr), + pVideoProfile(nullptr), + qualityLevel() {} -safe_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR(const safe_VkPipelineLibraryCreateInfoKHR& copy_src) { +safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR( + const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& copy_src) { sType = copy_src.sType; - libraryCount = copy_src.libraryCount; - pLibraries = nullptr; + pVideoProfile = nullptr; + qualityLevel = copy_src.qualityLevel; pNext = SafePnextCopy(copy_src.pNext); - if (libraryCount && copy_src.pLibraries) { - pLibraries = new VkPipeline[libraryCount]; - for (uint32_t i = 0; i < libraryCount; ++i) { - pLibraries[i] = copy_src.pLibraries[i]; - } - } + if (copy_src.pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(*copy_src.pVideoProfile); } -safe_VkPipelineLibraryCreateInfoKHR& safe_VkPipelineLibraryCreateInfoKHR::operator=( - const safe_VkPipelineLibraryCreateInfoKHR& copy_src) { +safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::operator=( + const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& copy_src) { if (©_src == this) return *this; - if (pLibraries) delete[] pLibraries; + if (pVideoProfile) delete pVideoProfile; FreePnextChain(pNext); sType = copy_src.sType; - libraryCount = copy_src.libraryCount; - pLibraries = nullptr; + pVideoProfile = nullptr; + qualityLevel = copy_src.qualityLevel; pNext = SafePnextCopy(copy_src.pNext); - if (libraryCount && copy_src.pLibraries) { - pLibraries = new VkPipeline[libraryCount]; - for (uint32_t i = 0; i < libraryCount; ++i) { - pLibraries[i] = copy_src.pLibraries[i]; - } - } + if (copy_src.pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(*copy_src.pVideoProfile); return *this; } -safe_VkPipelineLibraryCreateInfoKHR::~safe_VkPipelineLibraryCreateInfoKHR() { - if (pLibraries) delete[] pLibraries; +safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::~safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR() { + if (pVideoProfile) delete pVideoProfile; FreePnextChain(pNext); } -void safe_VkPipelineLibraryCreateInfoKHR::initialize(const VkPipelineLibraryCreateInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pLibraries) delete[] pLibraries; +void safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::initialize( + const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pVideoProfile) delete pVideoProfile; FreePnextChain(pNext); sType = in_struct->sType; - libraryCount = in_struct->libraryCount; - pLibraries = nullptr; - pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (libraryCount && in_struct->pLibraries) { - pLibraries = new VkPipeline[libraryCount]; - for (uint32_t i = 0; i < libraryCount; ++i) { - pLibraries[i] = in_struct->pLibraries[i]; - } - } + pVideoProfile = nullptr; + qualityLevel = in_struct->qualityLevel; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (in_struct->pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(in_struct->pVideoProfile); } -void safe_VkPipelineLibraryCreateInfoKHR::initialize(const safe_VkPipelineLibraryCreateInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::initialize( + const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - libraryCount = copy_src->libraryCount; - pLibraries = nullptr; + pVideoProfile = nullptr; + qualityLevel = copy_src->qualityLevel; pNext = SafePnextCopy(copy_src->pNext); - if (libraryCount && copy_src->pLibraries) { - pLibraries = new VkPipeline[libraryCount]; - for (uint32_t i = 0; i < libraryCount; ++i) { - pLibraries[i] = copy_src->pLibraries[i]; - } - } + if (copy_src->pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(*copy_src->pVideoProfile); } -safe_VkPresentIdKHR::safe_VkPresentIdKHR(const VkPresentIdKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pPresentIds(nullptr) { +safe_VkVideoEncodeQualityLevelPropertiesKHR::safe_VkVideoEncodeQualityLevelPropertiesKHR( + const VkVideoEncodeQualityLevelPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + preferredRateControlMode(in_struct->preferredRateControlMode), + preferredRateControlLayerCount(in_struct->preferredRateControlLayerCount) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pPresentIds) { - pPresentIds = new uint64_t[in_struct->swapchainCount]; - memcpy((void*)pPresentIds, (void*)in_struct->pPresentIds, sizeof(uint64_t) * in_struct->swapchainCount); - } } -safe_VkPresentIdKHR::safe_VkPresentIdKHR() - : sType(VK_STRUCTURE_TYPE_PRESENT_ID_KHR), pNext(nullptr), swapchainCount(), pPresentIds(nullptr) {} +safe_VkVideoEncodeQualityLevelPropertiesKHR::safe_VkVideoEncodeQualityLevelPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR), + pNext(nullptr), + preferredRateControlMode(), + preferredRateControlLayerCount() {} -safe_VkPresentIdKHR::safe_VkPresentIdKHR(const safe_VkPresentIdKHR& copy_src) { +safe_VkVideoEncodeQualityLevelPropertiesKHR::safe_VkVideoEncodeQualityLevelPropertiesKHR( + const safe_VkVideoEncodeQualityLevelPropertiesKHR& copy_src) { sType = copy_src.sType; - swapchainCount = copy_src.swapchainCount; - pPresentIds = nullptr; + preferredRateControlMode = copy_src.preferredRateControlMode; + preferredRateControlLayerCount = copy_src.preferredRateControlLayerCount; pNext = SafePnextCopy(copy_src.pNext); - - if (copy_src.pPresentIds) { - pPresentIds = new uint64_t[copy_src.swapchainCount]; - memcpy((void*)pPresentIds, (void*)copy_src.pPresentIds, sizeof(uint64_t) * copy_src.swapchainCount); - } } -safe_VkPresentIdKHR& safe_VkPresentIdKHR::operator=(const safe_VkPresentIdKHR& copy_src) { +safe_VkVideoEncodeQualityLevelPropertiesKHR& safe_VkVideoEncodeQualityLevelPropertiesKHR::operator=( + const safe_VkVideoEncodeQualityLevelPropertiesKHR& copy_src) { if (©_src == this) return *this; - if (pPresentIds) delete[] pPresentIds; FreePnextChain(pNext); sType = copy_src.sType; - swapchainCount = copy_src.swapchainCount; - pPresentIds = nullptr; + preferredRateControlMode = copy_src.preferredRateControlMode; + preferredRateControlLayerCount = copy_src.preferredRateControlLayerCount; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pPresentIds) { - pPresentIds = new uint64_t[copy_src.swapchainCount]; - memcpy((void*)pPresentIds, (void*)copy_src.pPresentIds, sizeof(uint64_t) * copy_src.swapchainCount); - } - return *this; } -safe_VkPresentIdKHR::~safe_VkPresentIdKHR() { - if (pPresentIds) delete[] pPresentIds; - FreePnextChain(pNext); -} +safe_VkVideoEncodeQualityLevelPropertiesKHR::~safe_VkVideoEncodeQualityLevelPropertiesKHR() { FreePnextChain(pNext); } -void safe_VkPresentIdKHR::initialize(const VkPresentIdKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - if (pPresentIds) delete[] pPresentIds; +void safe_VkVideoEncodeQualityLevelPropertiesKHR::initialize(const VkVideoEncodeQualityLevelPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - swapchainCount = in_struct->swapchainCount; - pPresentIds = nullptr; + preferredRateControlMode = in_struct->preferredRateControlMode; + preferredRateControlLayerCount = in_struct->preferredRateControlLayerCount; pNext = SafePnextCopy(in_struct->pNext, copy_state); - - if (in_struct->pPresentIds) { - pPresentIds = new uint64_t[in_struct->swapchainCount]; - memcpy((void*)pPresentIds, (void*)in_struct->pPresentIds, sizeof(uint64_t) * in_struct->swapchainCount); - } } -void safe_VkPresentIdKHR::initialize(const safe_VkPresentIdKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeQualityLevelPropertiesKHR::initialize(const safe_VkVideoEncodeQualityLevelPropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - swapchainCount = copy_src->swapchainCount; - pPresentIds = nullptr; + preferredRateControlMode = copy_src->preferredRateControlMode; + preferredRateControlLayerCount = copy_src->preferredRateControlLayerCount; pNext = SafePnextCopy(copy_src->pNext); - - if (copy_src->pPresentIds) { - pPresentIds = new uint64_t[copy_src->swapchainCount]; - memcpy((void*)pPresentIds, (void*)copy_src->pPresentIds, sizeof(uint64_t) * copy_src->swapchainCount); - } } -safe_VkPhysicalDevicePresentIdFeaturesKHR::safe_VkPhysicalDevicePresentIdFeaturesKHR( - const VkPhysicalDevicePresentIdFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), presentId(in_struct->presentId) { +safe_VkVideoEncodeQualityLevelInfoKHR::safe_VkVideoEncodeQualityLevelInfoKHR(const VkVideoEncodeQualityLevelInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), qualityLevel(in_struct->qualityLevel) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDevicePresentIdFeaturesKHR::safe_VkPhysicalDevicePresentIdFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR), pNext(nullptr), presentId() {} +safe_VkVideoEncodeQualityLevelInfoKHR::safe_VkVideoEncodeQualityLevelInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR), pNext(nullptr), qualityLevel() {} -safe_VkPhysicalDevicePresentIdFeaturesKHR::safe_VkPhysicalDevicePresentIdFeaturesKHR( - const safe_VkPhysicalDevicePresentIdFeaturesKHR& copy_src) { +safe_VkVideoEncodeQualityLevelInfoKHR::safe_VkVideoEncodeQualityLevelInfoKHR( + const safe_VkVideoEncodeQualityLevelInfoKHR& copy_src) { sType = copy_src.sType; - presentId = copy_src.presentId; + qualityLevel = copy_src.qualityLevel; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDevicePresentIdFeaturesKHR& safe_VkPhysicalDevicePresentIdFeaturesKHR::operator=( - const safe_VkPhysicalDevicePresentIdFeaturesKHR& copy_src) { +safe_VkVideoEncodeQualityLevelInfoKHR& safe_VkVideoEncodeQualityLevelInfoKHR::operator=( + const safe_VkVideoEncodeQualityLevelInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - presentId = copy_src.presentId; + qualityLevel = copy_src.qualityLevel; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDevicePresentIdFeaturesKHR::~safe_VkPhysicalDevicePresentIdFeaturesKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeQualityLevelInfoKHR::~safe_VkVideoEncodeQualityLevelInfoKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDevicePresentIdFeaturesKHR::initialize(const VkPhysicalDevicePresentIdFeaturesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeQualityLevelInfoKHR::initialize(const VkVideoEncodeQualityLevelInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - presentId = in_struct->presentId; + qualityLevel = in_struct->qualityLevel; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDevicePresentIdFeaturesKHR::initialize(const safe_VkPhysicalDevicePresentIdFeaturesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeQualityLevelInfoKHR::initialize(const safe_VkVideoEncodeQualityLevelInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - presentId = copy_src->presentId; + qualityLevel = copy_src->qualityLevel; pNext = SafePnextCopy(copy_src->pNext); } -#ifdef VK_ENABLE_BETA_EXTENSIONS -safe_VkVideoEncodeInfoKHR::safe_VkVideoEncodeInfoKHR(const VkVideoEncodeInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - flags(in_struct->flags), - dstBuffer(in_struct->dstBuffer), - dstBufferOffset(in_struct->dstBufferOffset), - dstBufferRange(in_struct->dstBufferRange), - srcPictureResource(&in_struct->srcPictureResource), - pSetupReferenceSlot(nullptr), - referenceSlotCount(in_struct->referenceSlotCount), - pReferenceSlots(nullptr), - precedingExternallyEncodedBytes(in_struct->precedingExternallyEncodedBytes) { +safe_VkVideoEncodeSessionParametersGetInfoKHR::safe_VkVideoEncodeSessionParametersGetInfoKHR( + const VkVideoEncodeSessionParametersGetInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), videoSessionParameters(in_struct->videoSessionParameters) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(in_struct->pSetupReferenceSlot); - if (referenceSlotCount && in_struct->pReferenceSlots) { - pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount]; - for (uint32_t i = 0; i < referenceSlotCount; ++i) { - pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]); - } - } } -safe_VkVideoEncodeInfoKHR::safe_VkVideoEncodeInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR), - pNext(nullptr), - flags(), - dstBuffer(), - dstBufferOffset(), - dstBufferRange(), - pSetupReferenceSlot(nullptr), - referenceSlotCount(), - pReferenceSlots(nullptr), - precedingExternallyEncodedBytes() {} +safe_VkVideoEncodeSessionParametersGetInfoKHR::safe_VkVideoEncodeSessionParametersGetInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR), pNext(nullptr), videoSessionParameters() {} -safe_VkVideoEncodeInfoKHR::safe_VkVideoEncodeInfoKHR(const safe_VkVideoEncodeInfoKHR& copy_src) { +safe_VkVideoEncodeSessionParametersGetInfoKHR::safe_VkVideoEncodeSessionParametersGetInfoKHR( + const safe_VkVideoEncodeSessionParametersGetInfoKHR& copy_src) { sType = copy_src.sType; - flags = copy_src.flags; - dstBuffer = copy_src.dstBuffer; - dstBufferOffset = copy_src.dstBufferOffset; - dstBufferRange = copy_src.dstBufferRange; - srcPictureResource.initialize(©_src.srcPictureResource); - pSetupReferenceSlot = nullptr; - referenceSlotCount = copy_src.referenceSlotCount; - pReferenceSlots = nullptr; - precedingExternallyEncodedBytes = copy_src.precedingExternallyEncodedBytes; + videoSessionParameters = copy_src.videoSessionParameters; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(*copy_src.pSetupReferenceSlot); - if (referenceSlotCount && copy_src.pReferenceSlots) { - pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount]; - for (uint32_t i = 0; i < referenceSlotCount; ++i) { - pReferenceSlots[i].initialize(©_src.pReferenceSlots[i]); - } - } } -safe_VkVideoEncodeInfoKHR& safe_VkVideoEncodeInfoKHR::operator=(const safe_VkVideoEncodeInfoKHR& copy_src) { +safe_VkVideoEncodeSessionParametersGetInfoKHR& safe_VkVideoEncodeSessionParametersGetInfoKHR::operator=( + const safe_VkVideoEncodeSessionParametersGetInfoKHR& copy_src) { if (©_src == this) return *this; - if (pSetupReferenceSlot) delete pSetupReferenceSlot; - if (pReferenceSlots) delete[] pReferenceSlots; FreePnextChain(pNext); sType = copy_src.sType; - flags = copy_src.flags; - dstBuffer = copy_src.dstBuffer; - dstBufferOffset = copy_src.dstBufferOffset; - dstBufferRange = copy_src.dstBufferRange; - srcPictureResource.initialize(©_src.srcPictureResource); - pSetupReferenceSlot = nullptr; - referenceSlotCount = copy_src.referenceSlotCount; - pReferenceSlots = nullptr; - precedingExternallyEncodedBytes = copy_src.precedingExternallyEncodedBytes; + videoSessionParameters = copy_src.videoSessionParameters; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(*copy_src.pSetupReferenceSlot); - if (referenceSlotCount && copy_src.pReferenceSlots) { - pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount]; - for (uint32_t i = 0; i < referenceSlotCount; ++i) { - pReferenceSlots[i].initialize(©_src.pReferenceSlots[i]); - } - } return *this; } -safe_VkVideoEncodeInfoKHR::~safe_VkVideoEncodeInfoKHR() { - if (pSetupReferenceSlot) delete pSetupReferenceSlot; - if (pReferenceSlots) delete[] pReferenceSlots; - FreePnextChain(pNext); -} +safe_VkVideoEncodeSessionParametersGetInfoKHR::~safe_VkVideoEncodeSessionParametersGetInfoKHR() { FreePnextChain(pNext); } -void safe_VkVideoEncodeInfoKHR::initialize(const VkVideoEncodeInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - if (pSetupReferenceSlot) delete pSetupReferenceSlot; - if (pReferenceSlots) delete[] pReferenceSlots; +void safe_VkVideoEncodeSessionParametersGetInfoKHR::initialize(const VkVideoEncodeSessionParametersGetInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - flags = in_struct->flags; - dstBuffer = in_struct->dstBuffer; - dstBufferOffset = in_struct->dstBufferOffset; - dstBufferRange = in_struct->dstBufferRange; - srcPictureResource.initialize(&in_struct->srcPictureResource); - pSetupReferenceSlot = nullptr; - referenceSlotCount = in_struct->referenceSlotCount; - pReferenceSlots = nullptr; - precedingExternallyEncodedBytes = in_struct->precedingExternallyEncodedBytes; + videoSessionParameters = in_struct->videoSessionParameters; pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (in_struct->pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(in_struct->pSetupReferenceSlot); - if (referenceSlotCount && in_struct->pReferenceSlots) { - pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount]; - for (uint32_t i = 0; i < referenceSlotCount; ++i) { - pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]); - } - } } - -void safe_VkVideoEncodeInfoKHR::initialize(const safe_VkVideoEncodeInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - flags = copy_src->flags; - dstBuffer = copy_src->dstBuffer; - dstBufferOffset = copy_src->dstBufferOffset; - dstBufferRange = copy_src->dstBufferRange; - srcPictureResource.initialize(©_src->srcPictureResource); - pSetupReferenceSlot = nullptr; - referenceSlotCount = copy_src->referenceSlotCount; - pReferenceSlots = nullptr; - precedingExternallyEncodedBytes = copy_src->precedingExternallyEncodedBytes; - pNext = SafePnextCopy(copy_src->pNext); - if (copy_src->pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(*copy_src->pSetupReferenceSlot); - if (referenceSlotCount && copy_src->pReferenceSlots) { - pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount]; - for (uint32_t i = 0; i < referenceSlotCount; ++i) { - pReferenceSlots[i].initialize(©_src->pReferenceSlots[i]); - } - } + +void safe_VkVideoEncodeSessionParametersGetInfoKHR::initialize(const safe_VkVideoEncodeSessionParametersGetInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + videoSessionParameters = copy_src->videoSessionParameters; + pNext = SafePnextCopy(copy_src->pNext); } -safe_VkVideoEncodeCapabilitiesKHR::safe_VkVideoEncodeCapabilitiesKHR(const VkVideoEncodeCapabilitiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - flags(in_struct->flags), - rateControlModes(in_struct->rateControlModes), - maxRateControlLayers(in_struct->maxRateControlLayers), - maxBitrate(in_struct->maxBitrate), - maxQualityLevels(in_struct->maxQualityLevels), - encodeInputPictureGranularity(in_struct->encodeInputPictureGranularity), - supportedEncodeFeedbackFlags(in_struct->supportedEncodeFeedbackFlags) { +safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::safe_VkVideoEncodeSessionParametersFeedbackInfoKHR( + const VkVideoEncodeSessionParametersFeedbackInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), hasOverrides(in_struct->hasOverrides) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkVideoEncodeCapabilitiesKHR::safe_VkVideoEncodeCapabilitiesKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR), - pNext(nullptr), - flags(), - rateControlModes(), - maxRateControlLayers(), - maxBitrate(), - maxQualityLevels(), - encodeInputPictureGranularity(), - supportedEncodeFeedbackFlags() {} +safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::safe_VkVideoEncodeSessionParametersFeedbackInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR), pNext(nullptr), hasOverrides() {} -safe_VkVideoEncodeCapabilitiesKHR::safe_VkVideoEncodeCapabilitiesKHR(const safe_VkVideoEncodeCapabilitiesKHR& copy_src) { +safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::safe_VkVideoEncodeSessionParametersFeedbackInfoKHR( + const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& copy_src) { sType = copy_src.sType; - flags = copy_src.flags; - rateControlModes = copy_src.rateControlModes; - maxRateControlLayers = copy_src.maxRateControlLayers; - maxBitrate = copy_src.maxBitrate; - maxQualityLevels = copy_src.maxQualityLevels; - encodeInputPictureGranularity = copy_src.encodeInputPictureGranularity; - supportedEncodeFeedbackFlags = copy_src.supportedEncodeFeedbackFlags; + hasOverrides = copy_src.hasOverrides; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkVideoEncodeCapabilitiesKHR& safe_VkVideoEncodeCapabilitiesKHR::operator=(const safe_VkVideoEncodeCapabilitiesKHR& copy_src) { +safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::operator=( + const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - flags = copy_src.flags; - rateControlModes = copy_src.rateControlModes; - maxRateControlLayers = copy_src.maxRateControlLayers; - maxBitrate = copy_src.maxBitrate; - maxQualityLevels = copy_src.maxQualityLevels; - encodeInputPictureGranularity = copy_src.encodeInputPictureGranularity; - supportedEncodeFeedbackFlags = copy_src.supportedEncodeFeedbackFlags; + hasOverrides = copy_src.hasOverrides; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkVideoEncodeCapabilitiesKHR::~safe_VkVideoEncodeCapabilitiesKHR() { FreePnextChain(pNext); } +safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::~safe_VkVideoEncodeSessionParametersFeedbackInfoKHR() { FreePnextChain(pNext); } -void safe_VkVideoEncodeCapabilitiesKHR::initialize(const VkVideoEncodeCapabilitiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::initialize(const VkVideoEncodeSessionParametersFeedbackInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - flags = in_struct->flags; - rateControlModes = in_struct->rateControlModes; - maxRateControlLayers = in_struct->maxRateControlLayers; - maxBitrate = in_struct->maxBitrate; - maxQualityLevels = in_struct->maxQualityLevels; - encodeInputPictureGranularity = in_struct->encodeInputPictureGranularity; - supportedEncodeFeedbackFlags = in_struct->supportedEncodeFeedbackFlags; + hasOverrides = in_struct->hasOverrides; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkVideoEncodeCapabilitiesKHR::initialize(const safe_VkVideoEncodeCapabilitiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::initialize( + const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - flags = copy_src->flags; - rateControlModes = copy_src->rateControlModes; - maxRateControlLayers = copy_src->maxRateControlLayers; - maxBitrate = copy_src->maxBitrate; - maxQualityLevels = copy_src->maxQualityLevels; - encodeInputPictureGranularity = copy_src->encodeInputPictureGranularity; - supportedEncodeFeedbackFlags = copy_src->supportedEncodeFeedbackFlags; + hasOverrides = copy_src->hasOverrides; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR( - const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), encodeFeedbackFlags(in_struct->encodeFeedbackFlags) { +safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR( + const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), fragmentShaderBarycentric(in_struct->fragmentShaderBarycentric) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR() - : sType(VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR), pNext(nullptr), encodeFeedbackFlags() {} +safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR), + pNext(nullptr), + fragmentShaderBarycentric() {} -safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR( - const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& copy_src) { +safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR( + const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& copy_src) { sType = copy_src.sType; - encodeFeedbackFlags = copy_src.encodeFeedbackFlags; + fragmentShaderBarycentric = copy_src.fragmentShaderBarycentric; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::operator=( - const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& copy_src) { +safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::operator=( + const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - encodeFeedbackFlags = copy_src.encodeFeedbackFlags; + fragmentShaderBarycentric = copy_src.fragmentShaderBarycentric; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::~safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR() { FreePnextChain(pNext); } +safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::~safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR() { + FreePnextChain(pNext); +} -void safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::initialize(const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::initialize( + const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - encodeFeedbackFlags = in_struct->encodeFeedbackFlags; + fragmentShaderBarycentric = in_struct->fragmentShaderBarycentric; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::initialize(const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::initialize( + const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - encodeFeedbackFlags = copy_src->encodeFeedbackFlags; + fragmentShaderBarycentric = copy_src->fragmentShaderBarycentric; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkVideoEncodeUsageInfoKHR::safe_VkVideoEncodeUsageInfoKHR(const VkVideoEncodeUsageInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR( + const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) : sType(in_struct->sType), - videoUsageHints(in_struct->videoUsageHints), - videoContentHints(in_struct->videoContentHints), - tuningMode(in_struct->tuningMode) { + triStripVertexOrderIndependentOfProvokingVertex(in_struct->triStripVertexOrderIndependentOfProvokingVertex) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkVideoEncodeUsageInfoKHR::safe_VkVideoEncodeUsageInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR), pNext(nullptr), videoUsageHints(), videoContentHints(), tuningMode() {} +safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR), + pNext(nullptr), + triStripVertexOrderIndependentOfProvokingVertex() {} -safe_VkVideoEncodeUsageInfoKHR::safe_VkVideoEncodeUsageInfoKHR(const safe_VkVideoEncodeUsageInfoKHR& copy_src) { +safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR( + const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& copy_src) { sType = copy_src.sType; - videoUsageHints = copy_src.videoUsageHints; - videoContentHints = copy_src.videoContentHints; - tuningMode = copy_src.tuningMode; + triStripVertexOrderIndependentOfProvokingVertex = copy_src.triStripVertexOrderIndependentOfProvokingVertex; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkVideoEncodeUsageInfoKHR& safe_VkVideoEncodeUsageInfoKHR::operator=(const safe_VkVideoEncodeUsageInfoKHR& copy_src) { +safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::operator=( + const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - videoUsageHints = copy_src.videoUsageHints; - videoContentHints = copy_src.videoContentHints; - tuningMode = copy_src.tuningMode; + triStripVertexOrderIndependentOfProvokingVertex = copy_src.triStripVertexOrderIndependentOfProvokingVertex; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkVideoEncodeUsageInfoKHR::~safe_VkVideoEncodeUsageInfoKHR() { FreePnextChain(pNext); } +safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::~safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR() { + FreePnextChain(pNext); +} -void safe_VkVideoEncodeUsageInfoKHR::initialize(const VkVideoEncodeUsageInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::initialize( + const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - videoUsageHints = in_struct->videoUsageHints; - videoContentHints = in_struct->videoContentHints; - tuningMode = in_struct->tuningMode; + triStripVertexOrderIndependentOfProvokingVertex = in_struct->triStripVertexOrderIndependentOfProvokingVertex; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkVideoEncodeUsageInfoKHR::initialize(const safe_VkVideoEncodeUsageInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::initialize( + const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - videoUsageHints = copy_src->videoUsageHints; - videoContentHints = copy_src->videoContentHints; - tuningMode = copy_src->tuningMode; + triStripVertexOrderIndependentOfProvokingVertex = copy_src->triStripVertexOrderIndependentOfProvokingVertex; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkVideoEncodeRateControlLayerInfoKHR::safe_VkVideoEncodeRateControlLayerInfoKHR( - const VkVideoEncodeRateControlLayerInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - averageBitrate(in_struct->averageBitrate), - maxBitrate(in_struct->maxBitrate), - frameRateNumerator(in_struct->frameRateNumerator), - frameRateDenominator(in_struct->frameRateDenominator) { +safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR( + const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), shaderSubgroupUniformControlFlow(in_struct->shaderSubgroupUniformControlFlow) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkVideoEncodeRateControlLayerInfoKHR::safe_VkVideoEncodeRateControlLayerInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR), +safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR), pNext(nullptr), - averageBitrate(), - maxBitrate(), - frameRateNumerator(), - frameRateDenominator() {} + shaderSubgroupUniformControlFlow() {} -safe_VkVideoEncodeRateControlLayerInfoKHR::safe_VkVideoEncodeRateControlLayerInfoKHR( - const safe_VkVideoEncodeRateControlLayerInfoKHR& copy_src) { +safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR( + const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& copy_src) { sType = copy_src.sType; - averageBitrate = copy_src.averageBitrate; - maxBitrate = copy_src.maxBitrate; - frameRateNumerator = copy_src.frameRateNumerator; - frameRateDenominator = copy_src.frameRateDenominator; + shaderSubgroupUniformControlFlow = copy_src.shaderSubgroupUniformControlFlow; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkVideoEncodeRateControlLayerInfoKHR& safe_VkVideoEncodeRateControlLayerInfoKHR::operator=( - const safe_VkVideoEncodeRateControlLayerInfoKHR& copy_src) { +safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& +safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::operator=( + const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - averageBitrate = copy_src.averageBitrate; - maxBitrate = copy_src.maxBitrate; - frameRateNumerator = copy_src.frameRateNumerator; - frameRateDenominator = copy_src.frameRateDenominator; + shaderSubgroupUniformControlFlow = copy_src.shaderSubgroupUniformControlFlow; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkVideoEncodeRateControlLayerInfoKHR::~safe_VkVideoEncodeRateControlLayerInfoKHR() { FreePnextChain(pNext); } +safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR:: + ~safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR() { + FreePnextChain(pNext); +} -void safe_VkVideoEncodeRateControlLayerInfoKHR::initialize(const VkVideoEncodeRateControlLayerInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::initialize( + const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - averageBitrate = in_struct->averageBitrate; - maxBitrate = in_struct->maxBitrate; - frameRateNumerator = in_struct->frameRateNumerator; - frameRateDenominator = in_struct->frameRateDenominator; + shaderSubgroupUniformControlFlow = in_struct->shaderSubgroupUniformControlFlow; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkVideoEncodeRateControlLayerInfoKHR::initialize(const safe_VkVideoEncodeRateControlLayerInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::initialize( + const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - averageBitrate = copy_src->averageBitrate; - maxBitrate = copy_src->maxBitrate; - frameRateNumerator = copy_src->frameRateNumerator; - frameRateDenominator = copy_src->frameRateDenominator; + shaderSubgroupUniformControlFlow = copy_src->shaderSubgroupUniformControlFlow; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkVideoEncodeRateControlInfoKHR::safe_VkVideoEncodeRateControlInfoKHR(const VkVideoEncodeRateControlInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) +safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR( + const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) : sType(in_struct->sType), - flags(in_struct->flags), - rateControlMode(in_struct->rateControlMode), - layerCount(in_struct->layerCount), - pLayers(nullptr), - virtualBufferSizeInMs(in_struct->virtualBufferSizeInMs), - initialVirtualBufferSizeInMs(in_struct->initialVirtualBufferSizeInMs) { + workgroupMemoryExplicitLayout(in_struct->workgroupMemoryExplicitLayout), + workgroupMemoryExplicitLayoutScalarBlockLayout(in_struct->workgroupMemoryExplicitLayoutScalarBlockLayout), + workgroupMemoryExplicitLayout8BitAccess(in_struct->workgroupMemoryExplicitLayout8BitAccess), + workgroupMemoryExplicitLayout16BitAccess(in_struct->workgroupMemoryExplicitLayout16BitAccess) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (layerCount && in_struct->pLayers) { - pLayers = new safe_VkVideoEncodeRateControlLayerInfoKHR[layerCount]; - for (uint32_t i = 0; i < layerCount; ++i) { - pLayers[i].initialize(&in_struct->pLayers[i]); - } - } } - -safe_VkVideoEncodeRateControlInfoKHR::safe_VkVideoEncodeRateControlInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR), + +safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR), pNext(nullptr), - flags(), - rateControlMode(), - layerCount(), - pLayers(nullptr), - virtualBufferSizeInMs(), - initialVirtualBufferSizeInMs() {} + workgroupMemoryExplicitLayout(), + workgroupMemoryExplicitLayoutScalarBlockLayout(), + workgroupMemoryExplicitLayout8BitAccess(), + workgroupMemoryExplicitLayout16BitAccess() {} -safe_VkVideoEncodeRateControlInfoKHR::safe_VkVideoEncodeRateControlInfoKHR(const safe_VkVideoEncodeRateControlInfoKHR& copy_src) { +safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR( + const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& copy_src) { sType = copy_src.sType; - flags = copy_src.flags; - rateControlMode = copy_src.rateControlMode; - layerCount = copy_src.layerCount; - pLayers = nullptr; - virtualBufferSizeInMs = copy_src.virtualBufferSizeInMs; - initialVirtualBufferSizeInMs = copy_src.initialVirtualBufferSizeInMs; + workgroupMemoryExplicitLayout = copy_src.workgroupMemoryExplicitLayout; + workgroupMemoryExplicitLayoutScalarBlockLayout = copy_src.workgroupMemoryExplicitLayoutScalarBlockLayout; + workgroupMemoryExplicitLayout8BitAccess = copy_src.workgroupMemoryExplicitLayout8BitAccess; + workgroupMemoryExplicitLayout16BitAccess = copy_src.workgroupMemoryExplicitLayout16BitAccess; pNext = SafePnextCopy(copy_src.pNext); - if (layerCount && copy_src.pLayers) { - pLayers = new safe_VkVideoEncodeRateControlLayerInfoKHR[layerCount]; - for (uint32_t i = 0; i < layerCount; ++i) { - pLayers[i].initialize(©_src.pLayers[i]); - } - } } -safe_VkVideoEncodeRateControlInfoKHR& safe_VkVideoEncodeRateControlInfoKHR::operator=( - const safe_VkVideoEncodeRateControlInfoKHR& copy_src) { +safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& +safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::operator=( + const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& copy_src) { if (©_src == this) return *this; - if (pLayers) delete[] pLayers; FreePnextChain(pNext); sType = copy_src.sType; - flags = copy_src.flags; - rateControlMode = copy_src.rateControlMode; - layerCount = copy_src.layerCount; - pLayers = nullptr; - virtualBufferSizeInMs = copy_src.virtualBufferSizeInMs; - initialVirtualBufferSizeInMs = copy_src.initialVirtualBufferSizeInMs; + workgroupMemoryExplicitLayout = copy_src.workgroupMemoryExplicitLayout; + workgroupMemoryExplicitLayoutScalarBlockLayout = copy_src.workgroupMemoryExplicitLayoutScalarBlockLayout; + workgroupMemoryExplicitLayout8BitAccess = copy_src.workgroupMemoryExplicitLayout8BitAccess; + workgroupMemoryExplicitLayout16BitAccess = copy_src.workgroupMemoryExplicitLayout16BitAccess; pNext = SafePnextCopy(copy_src.pNext); - if (layerCount && copy_src.pLayers) { - pLayers = new safe_VkVideoEncodeRateControlLayerInfoKHR[layerCount]; - for (uint32_t i = 0; i < layerCount; ++i) { - pLayers[i].initialize(©_src.pLayers[i]); - } - } return *this; } -safe_VkVideoEncodeRateControlInfoKHR::~safe_VkVideoEncodeRateControlInfoKHR() { - if (pLayers) delete[] pLayers; +safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::~safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR() { FreePnextChain(pNext); } -void safe_VkVideoEncodeRateControlInfoKHR::initialize(const VkVideoEncodeRateControlInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pLayers) delete[] pLayers; +void safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::initialize( + const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - flags = in_struct->flags; - rateControlMode = in_struct->rateControlMode; - layerCount = in_struct->layerCount; - pLayers = nullptr; - virtualBufferSizeInMs = in_struct->virtualBufferSizeInMs; - initialVirtualBufferSizeInMs = in_struct->initialVirtualBufferSizeInMs; + workgroupMemoryExplicitLayout = in_struct->workgroupMemoryExplicitLayout; + workgroupMemoryExplicitLayoutScalarBlockLayout = in_struct->workgroupMemoryExplicitLayoutScalarBlockLayout; + workgroupMemoryExplicitLayout8BitAccess = in_struct->workgroupMemoryExplicitLayout8BitAccess; + workgroupMemoryExplicitLayout16BitAccess = in_struct->workgroupMemoryExplicitLayout16BitAccess; pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (layerCount && in_struct->pLayers) { - pLayers = new safe_VkVideoEncodeRateControlLayerInfoKHR[layerCount]; - for (uint32_t i = 0; i < layerCount; ++i) { - pLayers[i].initialize(&in_struct->pLayers[i]); - } - } } -void safe_VkVideoEncodeRateControlInfoKHR::initialize(const safe_VkVideoEncodeRateControlInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::initialize( + const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - flags = copy_src->flags; - rateControlMode = copy_src->rateControlMode; - layerCount = copy_src->layerCount; - pLayers = nullptr; - virtualBufferSizeInMs = copy_src->virtualBufferSizeInMs; - initialVirtualBufferSizeInMs = copy_src->initialVirtualBufferSizeInMs; + workgroupMemoryExplicitLayout = copy_src->workgroupMemoryExplicitLayout; + workgroupMemoryExplicitLayoutScalarBlockLayout = copy_src->workgroupMemoryExplicitLayoutScalarBlockLayout; + workgroupMemoryExplicitLayout8BitAccess = copy_src->workgroupMemoryExplicitLayout8BitAccess; + workgroupMemoryExplicitLayout16BitAccess = copy_src->workgroupMemoryExplicitLayout16BitAccess; pNext = SafePnextCopy(copy_src->pNext); - if (layerCount && copy_src->pLayers) { - pLayers = new safe_VkVideoEncodeRateControlLayerInfoKHR[layerCount]; - for (uint32_t i = 0; i < layerCount; ++i) { - pLayers[i].initialize(©_src->pLayers[i]); - } - } } -safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR( - const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), pVideoProfile(nullptr), qualityLevel(in_struct->qualityLevel) { +safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR( + const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + rayTracingMaintenance1(in_struct->rayTracingMaintenance1), + rayTracingPipelineTraceRaysIndirect2(in_struct->rayTracingPipelineTraceRaysIndirect2) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } - if (in_struct->pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(in_struct->pVideoProfile); } -safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR), +safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR), pNext(nullptr), - pVideoProfile(nullptr), - qualityLevel() {} + rayTracingMaintenance1(), + rayTracingPipelineTraceRaysIndirect2() {} -safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR( - const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& copy_src) { +safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR( + const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& copy_src) { sType = copy_src.sType; - pVideoProfile = nullptr; - qualityLevel = copy_src.qualityLevel; + rayTracingMaintenance1 = copy_src.rayTracingMaintenance1; + rayTracingPipelineTraceRaysIndirect2 = copy_src.rayTracingPipelineTraceRaysIndirect2; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(*copy_src.pVideoProfile); } -safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::operator=( - const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& copy_src) { +safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::operator=( + const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& copy_src) { if (©_src == this) return *this; - if (pVideoProfile) delete pVideoProfile; FreePnextChain(pNext); sType = copy_src.sType; - pVideoProfile = nullptr; - qualityLevel = copy_src.qualityLevel; + rayTracingMaintenance1 = copy_src.rayTracingMaintenance1; + rayTracingPipelineTraceRaysIndirect2 = copy_src.rayTracingPipelineTraceRaysIndirect2; pNext = SafePnextCopy(copy_src.pNext); - if (copy_src.pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(*copy_src.pVideoProfile); return *this; } -safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::~safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR() { - if (pVideoProfile) delete pVideoProfile; +safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::~safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::initialize( - const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - if (pVideoProfile) delete pVideoProfile; +void safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::initialize( + const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - pVideoProfile = nullptr; - qualityLevel = in_struct->qualityLevel; + rayTracingMaintenance1 = in_struct->rayTracingMaintenance1; + rayTracingPipelineTraceRaysIndirect2 = in_struct->rayTracingPipelineTraceRaysIndirect2; pNext = SafePnextCopy(in_struct->pNext, copy_state); - if (in_struct->pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(in_struct->pVideoProfile); } -void safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::initialize( - const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::initialize( + const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - pVideoProfile = nullptr; - qualityLevel = copy_src->qualityLevel; + rayTracingMaintenance1 = copy_src->rayTracingMaintenance1; + rayTracingPipelineTraceRaysIndirect2 = copy_src->rayTracingPipelineTraceRaysIndirect2; pNext = SafePnextCopy(copy_src->pNext); - if (copy_src->pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(*copy_src->pVideoProfile); } -safe_VkVideoEncodeQualityLevelPropertiesKHR::safe_VkVideoEncodeQualityLevelPropertiesKHR( - const VkVideoEncodeQualityLevelPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), - preferredRateControlMode(in_struct->preferredRateControlMode), - preferredRateControlLayerCount(in_struct->preferredRateControlLayerCount) { +safe_VkPhysicalDeviceMaintenance5FeaturesKHR::safe_VkPhysicalDeviceMaintenance5FeaturesKHR( + const VkPhysicalDeviceMaintenance5FeaturesKHR* 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_VkVideoEncodeQualityLevelPropertiesKHR::safe_VkVideoEncodeQualityLevelPropertiesKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR), - pNext(nullptr), - preferredRateControlMode(), - preferredRateControlLayerCount() {} +safe_VkPhysicalDeviceMaintenance5FeaturesKHR::safe_VkPhysicalDeviceMaintenance5FeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR), pNext(nullptr), maintenance5() {} -safe_VkVideoEncodeQualityLevelPropertiesKHR::safe_VkVideoEncodeQualityLevelPropertiesKHR( - const safe_VkVideoEncodeQualityLevelPropertiesKHR& copy_src) { +safe_VkPhysicalDeviceMaintenance5FeaturesKHR::safe_VkPhysicalDeviceMaintenance5FeaturesKHR( + const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src) { sType = copy_src.sType; - preferredRateControlMode = copy_src.preferredRateControlMode; - preferredRateControlLayerCount = copy_src.preferredRateControlLayerCount; + maintenance5 = copy_src.maintenance5; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkVideoEncodeQualityLevelPropertiesKHR& safe_VkVideoEncodeQualityLevelPropertiesKHR::operator=( - const safe_VkVideoEncodeQualityLevelPropertiesKHR& copy_src) { +safe_VkPhysicalDeviceMaintenance5FeaturesKHR& safe_VkPhysicalDeviceMaintenance5FeaturesKHR::operator=( + const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - preferredRateControlMode = copy_src.preferredRateControlMode; - preferredRateControlLayerCount = copy_src.preferredRateControlLayerCount; + maintenance5 = copy_src.maintenance5; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkVideoEncodeQualityLevelPropertiesKHR::~safe_VkVideoEncodeQualityLevelPropertiesKHR() { FreePnextChain(pNext); } +safe_VkPhysicalDeviceMaintenance5FeaturesKHR::~safe_VkPhysicalDeviceMaintenance5FeaturesKHR() { FreePnextChain(pNext); } -void safe_VkVideoEncodeQualityLevelPropertiesKHR::initialize(const VkVideoEncodeQualityLevelPropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceMaintenance5FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - preferredRateControlMode = in_struct->preferredRateControlMode; - preferredRateControlLayerCount = in_struct->preferredRateControlLayerCount; + maintenance5 = in_struct->maintenance5; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkVideoEncodeQualityLevelPropertiesKHR::initialize(const safe_VkVideoEncodeQualityLevelPropertiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceMaintenance5FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance5FeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - preferredRateControlMode = copy_src->preferredRateControlMode; - preferredRateControlLayerCount = copy_src->preferredRateControlLayerCount; + maintenance5 = copy_src->maintenance5; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkVideoEncodeQualityLevelInfoKHR::safe_VkVideoEncodeQualityLevelInfoKHR(const VkVideoEncodeQualityLevelInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), qualityLevel(in_struct->qualityLevel) { +safe_VkPhysicalDeviceMaintenance5PropertiesKHR::safe_VkPhysicalDeviceMaintenance5PropertiesKHR( + const VkPhysicalDeviceMaintenance5PropertiesKHR* 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_VkVideoEncodeQualityLevelInfoKHR::safe_VkVideoEncodeQualityLevelInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR), pNext(nullptr), qualityLevel() {} +safe_VkPhysicalDeviceMaintenance5PropertiesKHR::safe_VkPhysicalDeviceMaintenance5PropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR), + pNext(nullptr), + earlyFragmentMultisampleCoverageAfterSampleCounting(), + earlyFragmentSampleMaskTestBeforeSampleCounting(), + depthStencilSwizzleOneSupport(), + polygonModePointSize(), + nonStrictSinglePixelWideLinesUseParallelogram(), + nonStrictWideLinesUseParallelogram() {} -safe_VkVideoEncodeQualityLevelInfoKHR::safe_VkVideoEncodeQualityLevelInfoKHR( - const safe_VkVideoEncodeQualityLevelInfoKHR& copy_src) { +safe_VkPhysicalDeviceMaintenance5PropertiesKHR::safe_VkPhysicalDeviceMaintenance5PropertiesKHR( + const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src) { sType = copy_src.sType; - qualityLevel = copy_src.qualityLevel; + 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_VkVideoEncodeQualityLevelInfoKHR& safe_VkVideoEncodeQualityLevelInfoKHR::operator=( - const safe_VkVideoEncodeQualityLevelInfoKHR& copy_src) { +safe_VkPhysicalDeviceMaintenance5PropertiesKHR& safe_VkPhysicalDeviceMaintenance5PropertiesKHR::operator=( + const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - qualityLevel = copy_src.qualityLevel; + 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_VkVideoEncodeQualityLevelInfoKHR::~safe_VkVideoEncodeQualityLevelInfoKHR() { FreePnextChain(pNext); } +safe_VkPhysicalDeviceMaintenance5PropertiesKHR::~safe_VkPhysicalDeviceMaintenance5PropertiesKHR() { FreePnextChain(pNext); } -void safe_VkVideoEncodeQualityLevelInfoKHR::initialize(const VkVideoEncodeQualityLevelInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceMaintenance5PropertiesKHR::initialize(const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - qualityLevel = in_struct->qualityLevel; + 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_VkVideoEncodeQualityLevelInfoKHR::initialize(const safe_VkVideoEncodeQualityLevelInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceMaintenance5PropertiesKHR::initialize(const safe_VkPhysicalDeviceMaintenance5PropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - qualityLevel = copy_src->qualityLevel; + 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_VkVideoEncodeSessionParametersGetInfoKHR::safe_VkVideoEncodeSessionParametersGetInfoKHR( - const VkVideoEncodeSessionParametersGetInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), videoSessionParameters(in_struct->videoSessionParameters) { +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) { 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_VkVideoEncodeSessionParametersGetInfoKHR::safe_VkVideoEncodeSessionParametersGetInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR), pNext(nullptr), videoSessionParameters() {} +safe_VkRenderingAreaInfoKHR::safe_VkRenderingAreaInfoKHR() + : sType(VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR), + pNext(nullptr), + viewMask(), + colorAttachmentCount(), + pColorAttachmentFormats(nullptr), + depthAttachmentFormat(), + stencilAttachmentFormat() {} -safe_VkVideoEncodeSessionParametersGetInfoKHR::safe_VkVideoEncodeSessionParametersGetInfoKHR( - const safe_VkVideoEncodeSessionParametersGetInfoKHR& copy_src) { +safe_VkRenderingAreaInfoKHR::safe_VkRenderingAreaInfoKHR(const safe_VkRenderingAreaInfoKHR& copy_src) { sType = copy_src.sType; - videoSessionParameters = copy_src.videoSessionParameters; + 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_VkVideoEncodeSessionParametersGetInfoKHR& safe_VkVideoEncodeSessionParametersGetInfoKHR::operator=( - const safe_VkVideoEncodeSessionParametersGetInfoKHR& copy_src) { +safe_VkRenderingAreaInfoKHR& safe_VkRenderingAreaInfoKHR::operator=(const safe_VkRenderingAreaInfoKHR& copy_src) { if (©_src == this) return *this; + if (pColorAttachmentFormats) delete[] pColorAttachmentFormats; FreePnextChain(pNext); sType = copy_src.sType; - videoSessionParameters = copy_src.videoSessionParameters; + 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_VkVideoEncodeSessionParametersGetInfoKHR::~safe_VkVideoEncodeSessionParametersGetInfoKHR() { FreePnextChain(pNext); } +safe_VkRenderingAreaInfoKHR::~safe_VkRenderingAreaInfoKHR() { + if (pColorAttachmentFormats) delete[] pColorAttachmentFormats; + FreePnextChain(pNext); +} -void safe_VkVideoEncodeSessionParametersGetInfoKHR::initialize(const VkVideoEncodeSessionParametersGetInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkRenderingAreaInfoKHR::initialize(const VkRenderingAreaInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pColorAttachmentFormats) delete[] pColorAttachmentFormats; FreePnextChain(pNext); sType = in_struct->sType; - videoSessionParameters = in_struct->videoSessionParameters; + 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_VkVideoEncodeSessionParametersGetInfoKHR::initialize(const safe_VkVideoEncodeSessionParametersGetInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkRenderingAreaInfoKHR::initialize(const safe_VkRenderingAreaInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - videoSessionParameters = copy_src->videoSessionParameters; + 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_VkVideoEncodeSessionParametersFeedbackInfoKHR::safe_VkVideoEncodeSessionParametersFeedbackInfoKHR( - const VkVideoEncodeSessionParametersFeedbackInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), hasOverrides(in_struct->hasOverrides) { +safe_VkImageSubresource2KHR::safe_VkImageSubresource2KHR(const VkImageSubresource2KHR* 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_VkVideoEncodeSessionParametersFeedbackInfoKHR::safe_VkVideoEncodeSessionParametersFeedbackInfoKHR() - : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR), pNext(nullptr), hasOverrides() {} +safe_VkImageSubresource2KHR::safe_VkImageSubresource2KHR() + : sType(VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR), pNext(nullptr), imageSubresource() {} -safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::safe_VkVideoEncodeSessionParametersFeedbackInfoKHR( - const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& copy_src) { +safe_VkImageSubresource2KHR::safe_VkImageSubresource2KHR(const safe_VkImageSubresource2KHR& copy_src) { sType = copy_src.sType; - hasOverrides = copy_src.hasOverrides; + imageSubresource = copy_src.imageSubresource; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::operator=( - const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& copy_src) { +safe_VkImageSubresource2KHR& safe_VkImageSubresource2KHR::operator=(const safe_VkImageSubresource2KHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - hasOverrides = copy_src.hasOverrides; + imageSubresource = copy_src.imageSubresource; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::~safe_VkVideoEncodeSessionParametersFeedbackInfoKHR() { FreePnextChain(pNext); } +safe_VkImageSubresource2KHR::~safe_VkImageSubresource2KHR() { FreePnextChain(pNext); } -void safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::initialize(const VkVideoEncodeSessionParametersFeedbackInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkImageSubresource2KHR::initialize(const VkImageSubresource2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - hasOverrides = in_struct->hasOverrides; + imageSubresource = in_struct->imageSubresource; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::initialize( - const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkImageSubresource2KHR::initialize(const safe_VkImageSubresource2KHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - hasOverrides = copy_src->hasOverrides; + imageSubresource = copy_src->imageSubresource; pNext = SafePnextCopy(copy_src->pNext); } -#endif // VK_ENABLE_BETA_EXTENSIONS -safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR( - const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), fragmentShaderBarycentric(in_struct->fragmentShaderBarycentric) { +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); } + if (in_struct->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(in_struct->pCreateInfo); + if (in_struct->pSubresource) pSubresource = new safe_VkImageSubresource2KHR(in_struct->pSubresource); } -safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR), - pNext(nullptr), - fragmentShaderBarycentric() {} +safe_VkDeviceImageSubresourceInfoKHR::safe_VkDeviceImageSubresourceInfoKHR() + : sType(VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR), pNext(nullptr), pCreateInfo(nullptr), pSubresource(nullptr) {} -safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR( - const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& copy_src) { +safe_VkDeviceImageSubresourceInfoKHR::safe_VkDeviceImageSubresourceInfoKHR(const safe_VkDeviceImageSubresourceInfoKHR& copy_src) { sType = copy_src.sType; - fragmentShaderBarycentric = copy_src.fragmentShaderBarycentric; + 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_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::operator=( - const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& copy_src) { +safe_VkDeviceImageSubresourceInfoKHR& safe_VkDeviceImageSubresourceInfoKHR::operator=( + const safe_VkDeviceImageSubresourceInfoKHR& copy_src) { if (©_src == this) return *this; + if (pCreateInfo) delete pCreateInfo; + if (pSubresource) delete pSubresource; FreePnextChain(pNext); sType = copy_src.sType; - fragmentShaderBarycentric = copy_src.fragmentShaderBarycentric; + 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_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::~safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR() { +safe_VkDeviceImageSubresourceInfoKHR::~safe_VkDeviceImageSubresourceInfoKHR() { + if (pCreateInfo) delete pCreateInfo; + if (pSubresource) delete pSubresource; FreePnextChain(pNext); } -void safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::initialize( - const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +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; - fragmentShaderBarycentric = in_struct->fragmentShaderBarycentric; + 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); } -void safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::initialize( - const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkDeviceImageSubresourceInfoKHR::initialize(const safe_VkDeviceImageSubresourceInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - fragmentShaderBarycentric = copy_src->fragmentShaderBarycentric; + 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_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR( - const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), - triStripVertexOrderIndependentOfProvokingVertex(in_struct->triStripVertexOrderIndependentOfProvokingVertex) { +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_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR), - pNext(nullptr), - triStripVertexOrderIndependentOfProvokingVertex() {} +safe_VkSubresourceLayout2KHR::safe_VkSubresourceLayout2KHR() + : sType(VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR), pNext(nullptr), subresourceLayout() {} -safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR( - const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& copy_src) { +safe_VkSubresourceLayout2KHR::safe_VkSubresourceLayout2KHR(const safe_VkSubresourceLayout2KHR& copy_src) { sType = copy_src.sType; - triStripVertexOrderIndependentOfProvokingVertex = copy_src.triStripVertexOrderIndependentOfProvokingVertex; + subresourceLayout = copy_src.subresourceLayout; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::operator=( - const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& copy_src) { +safe_VkSubresourceLayout2KHR& safe_VkSubresourceLayout2KHR::operator=(const safe_VkSubresourceLayout2KHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - triStripVertexOrderIndependentOfProvokingVertex = copy_src.triStripVertexOrderIndependentOfProvokingVertex; + subresourceLayout = copy_src.subresourceLayout; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::~safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR() { - FreePnextChain(pNext); -} +safe_VkSubresourceLayout2KHR::~safe_VkSubresourceLayout2KHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::initialize( - const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkSubresourceLayout2KHR::initialize(const VkSubresourceLayout2KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - triStripVertexOrderIndependentOfProvokingVertex = in_struct->triStripVertexOrderIndependentOfProvokingVertex; + subresourceLayout = in_struct->subresourceLayout; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::initialize( - const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkSubresourceLayout2KHR::initialize(const safe_VkSubresourceLayout2KHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - triStripVertexOrderIndependentOfProvokingVertex = copy_src->triStripVertexOrderIndependentOfProvokingVertex; + subresourceLayout = copy_src->subresourceLayout; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR( - const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), shaderSubgroupUniformControlFlow(in_struct->shaderSubgroupUniformControlFlow) { +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_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR), - pNext(nullptr), - shaderSubgroupUniformControlFlow() {} +} -safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR( - const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& copy_src) { +safe_VkPipelineCreateFlags2CreateInfoKHR::safe_VkPipelineCreateFlags2CreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR), pNext(nullptr), flags() {} + +safe_VkPipelineCreateFlags2CreateInfoKHR::safe_VkPipelineCreateFlags2CreateInfoKHR( + const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src) { sType = copy_src.sType; - shaderSubgroupUniformControlFlow = copy_src.shaderSubgroupUniformControlFlow; + flags = copy_src.flags; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& -safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::operator=( - const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& copy_src) { +safe_VkPipelineCreateFlags2CreateInfoKHR& safe_VkPipelineCreateFlags2CreateInfoKHR::operator=( + const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - shaderSubgroupUniformControlFlow = copy_src.shaderSubgroupUniformControlFlow; + flags = copy_src.flags; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR:: - ~safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR() { - FreePnextChain(pNext); -} +safe_VkPipelineCreateFlags2CreateInfoKHR::~safe_VkPipelineCreateFlags2CreateInfoKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::initialize( - const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPipelineCreateFlags2CreateInfoKHR::initialize(const VkPipelineCreateFlags2CreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - shaderSubgroupUniformControlFlow = in_struct->shaderSubgroupUniformControlFlow; + flags = in_struct->flags; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::initialize( - const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPipelineCreateFlags2CreateInfoKHR::initialize(const safe_VkPipelineCreateFlags2CreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - shaderSubgroupUniformControlFlow = copy_src->shaderSubgroupUniformControlFlow; + flags = copy_src->flags; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR( - const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), - workgroupMemoryExplicitLayout(in_struct->workgroupMemoryExplicitLayout), - workgroupMemoryExplicitLayoutScalarBlockLayout(in_struct->workgroupMemoryExplicitLayoutScalarBlockLayout), - workgroupMemoryExplicitLayout8BitAccess(in_struct->workgroupMemoryExplicitLayout8BitAccess), - workgroupMemoryExplicitLayout16BitAccess(in_struct->workgroupMemoryExplicitLayout16BitAccess) { +safe_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR(const VkBufferUsageFlags2CreateInfoKHR* 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_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR), - pNext(nullptr), - workgroupMemoryExplicitLayout(), - workgroupMemoryExplicitLayoutScalarBlockLayout(), - workgroupMemoryExplicitLayout8BitAccess(), - workgroupMemoryExplicitLayout16BitAccess() {} +safe_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR), pNext(nullptr), usage() {} -safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR( - const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& copy_src) { +safe_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR( + const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src) { sType = copy_src.sType; - workgroupMemoryExplicitLayout = copy_src.workgroupMemoryExplicitLayout; - workgroupMemoryExplicitLayoutScalarBlockLayout = copy_src.workgroupMemoryExplicitLayoutScalarBlockLayout; - workgroupMemoryExplicitLayout8BitAccess = copy_src.workgroupMemoryExplicitLayout8BitAccess; - workgroupMemoryExplicitLayout16BitAccess = copy_src.workgroupMemoryExplicitLayout16BitAccess; + usage = copy_src.usage; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& -safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::operator=( - const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& copy_src) { +safe_VkBufferUsageFlags2CreateInfoKHR& safe_VkBufferUsageFlags2CreateInfoKHR::operator=( + const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - workgroupMemoryExplicitLayout = copy_src.workgroupMemoryExplicitLayout; - workgroupMemoryExplicitLayoutScalarBlockLayout = copy_src.workgroupMemoryExplicitLayoutScalarBlockLayout; - workgroupMemoryExplicitLayout8BitAccess = copy_src.workgroupMemoryExplicitLayout8BitAccess; - workgroupMemoryExplicitLayout16BitAccess = copy_src.workgroupMemoryExplicitLayout16BitAccess; + usage = copy_src.usage; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::~safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR() { - FreePnextChain(pNext); -} +safe_VkBufferUsageFlags2CreateInfoKHR::~safe_VkBufferUsageFlags2CreateInfoKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::initialize( - const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkBufferUsageFlags2CreateInfoKHR::initialize(const VkBufferUsageFlags2CreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - workgroupMemoryExplicitLayout = in_struct->workgroupMemoryExplicitLayout; - workgroupMemoryExplicitLayoutScalarBlockLayout = in_struct->workgroupMemoryExplicitLayoutScalarBlockLayout; - workgroupMemoryExplicitLayout8BitAccess = in_struct->workgroupMemoryExplicitLayout8BitAccess; - workgroupMemoryExplicitLayout16BitAccess = in_struct->workgroupMemoryExplicitLayout16BitAccess; + usage = in_struct->usage; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::initialize( - const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkBufferUsageFlags2CreateInfoKHR::initialize(const safe_VkBufferUsageFlags2CreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - workgroupMemoryExplicitLayout = copy_src->workgroupMemoryExplicitLayout; - workgroupMemoryExplicitLayoutScalarBlockLayout = copy_src->workgroupMemoryExplicitLayoutScalarBlockLayout; - workgroupMemoryExplicitLayout8BitAccess = copy_src->workgroupMemoryExplicitLayout8BitAccess; - workgroupMemoryExplicitLayout16BitAccess = copy_src->workgroupMemoryExplicitLayout16BitAccess; + usage = copy_src->usage; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR( - const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* 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), - rayTracingMaintenance1(in_struct->rayTracingMaintenance1), - rayTracingPipelineTraceRaysIndirect2(in_struct->rayTracingPipelineTraceRaysIndirect2) { + : sType(in_struct->sType), rayTracingPositionFetch(in_struct->rayTracingPositionFetch) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR), - pNext(nullptr), - rayTracingMaintenance1(), - rayTracingPipelineTraceRaysIndirect2() {} +safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR), pNext(nullptr), rayTracingPositionFetch() {} -safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR( - const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& copy_src) { +safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR( + const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src) { sType = copy_src.sType; - rayTracingMaintenance1 = copy_src.rayTracingMaintenance1; - rayTracingPipelineTraceRaysIndirect2 = copy_src.rayTracingPipelineTraceRaysIndirect2; + rayTracingPositionFetch = copy_src.rayTracingPositionFetch; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::operator=( - const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& copy_src) { +safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::operator=( + const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - rayTracingMaintenance1 = copy_src.rayTracingMaintenance1; - rayTracingPipelineTraceRaysIndirect2 = copy_src.rayTracingPipelineTraceRaysIndirect2; + rayTracingPositionFetch = copy_src.rayTracingPositionFetch; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::~safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR() { +safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::~safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::initialize( - const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* 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; - rayTracingMaintenance1 = in_struct->rayTracingMaintenance1; - rayTracingPipelineTraceRaysIndirect2 = in_struct->rayTracingPipelineTraceRaysIndirect2; + rayTracingPositionFetch = in_struct->rayTracingPositionFetch; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::initialize( - const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* 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; - rayTracingMaintenance1 = copy_src->rayTracingMaintenance1; - rayTracingPipelineTraceRaysIndirect2 = copy_src->rayTracingPipelineTraceRaysIndirect2; + 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_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_VkPhysicalDeviceMaintenance5FeaturesKHR::safe_VkPhysicalDeviceMaintenance5FeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR), pNext(nullptr), maintenance5() {} +safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR), + pNext(nullptr), + MSize(), + NSize(), + KSize(), + AType(), + BType(), + CType(), + ResultType(), + saturatingAccumulation(), + scope() {} -safe_VkPhysicalDeviceMaintenance5FeaturesKHR::safe_VkPhysicalDeviceMaintenance5FeaturesKHR( - const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src) { +safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR( + const safe_VkCooperativeMatrixPropertiesKHR& copy_src) { sType = copy_src.sType; - maintenance5 = copy_src.maintenance5; + 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_VkPhysicalDeviceMaintenance5FeaturesKHR& safe_VkPhysicalDeviceMaintenance5FeaturesKHR::operator=( - const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src) { +safe_VkCooperativeMatrixPropertiesKHR& safe_VkCooperativeMatrixPropertiesKHR::operator=( + const safe_VkCooperativeMatrixPropertiesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - maintenance5 = copy_src.maintenance5; + 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_VkPhysicalDeviceMaintenance5FeaturesKHR::~safe_VkPhysicalDeviceMaintenance5FeaturesKHR() { FreePnextChain(pNext); } +safe_VkCooperativeMatrixPropertiesKHR::~safe_VkCooperativeMatrixPropertiesKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceMaintenance5FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkCooperativeMatrixPropertiesKHR::initialize(const VkCooperativeMatrixPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - maintenance5 = in_struct->maintenance5; + 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_VkPhysicalDeviceMaintenance5FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance5FeaturesKHR* 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; - maintenance5 = copy_src->maintenance5; + 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_VkPhysicalDeviceMaintenance5PropertiesKHR::safe_VkPhysicalDeviceMaintenance5PropertiesKHR( - const VkPhysicalDeviceMaintenance5PropertiesKHR* 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), - earlyFragmentMultisampleCoverageAfterSampleCounting(in_struct->earlyFragmentMultisampleCoverageAfterSampleCounting), - earlyFragmentSampleMaskTestBeforeSampleCounting(in_struct->earlyFragmentSampleMaskTestBeforeSampleCounting), - depthStencilSwizzleOneSupport(in_struct->depthStencilSwizzleOneSupport), - polygonModePointSize(in_struct->polygonModePointSize), - nonStrictSinglePixelWideLinesUseParallelogram(in_struct->nonStrictSinglePixelWideLinesUseParallelogram), - nonStrictWideLinesUseParallelogram(in_struct->nonStrictWideLinesUseParallelogram) { + cooperativeMatrix(in_struct->cooperativeMatrix), + cooperativeMatrixRobustBufferAccess(in_struct->cooperativeMatrixRobustBufferAccess) { 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_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR), pNext(nullptr), - earlyFragmentMultisampleCoverageAfterSampleCounting(), - earlyFragmentSampleMaskTestBeforeSampleCounting(), - depthStencilSwizzleOneSupport(), - polygonModePointSize(), - nonStrictSinglePixelWideLinesUseParallelogram(), - nonStrictWideLinesUseParallelogram() {} - -safe_VkPhysicalDeviceMaintenance5PropertiesKHR::safe_VkPhysicalDeviceMaintenance5PropertiesKHR( - const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src) { + cooperativeMatrix(), + cooperativeMatrixRobustBufferAccess() {} + +safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR( + const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& 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; + cooperativeMatrix = copy_src.cooperativeMatrix; + cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceMaintenance5PropertiesKHR& safe_VkPhysicalDeviceMaintenance5PropertiesKHR::operator=( - const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src) { +safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::operator=( + const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& 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; + cooperativeMatrix = copy_src.cooperativeMatrix; + cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceMaintenance5PropertiesKHR::~safe_VkPhysicalDeviceMaintenance5PropertiesKHR() { FreePnextChain(pNext); } +safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::~safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceMaintenance5PropertiesKHR::initialize(const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* 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; + cooperativeMatrix = in_struct->cooperativeMatrix; + cooperativeMatrixRobustBufferAccess = in_struct->cooperativeMatrixRobustBufferAccess; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceMaintenance5PropertiesKHR::initialize(const safe_VkPhysicalDeviceMaintenance5PropertiesKHR* 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; - earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src->earlyFragmentMultisampleCoverageAfterSampleCounting; - earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src->earlyFragmentSampleMaskTestBeforeSampleCounting; - depthStencilSwizzleOneSupport = copy_src->depthStencilSwizzleOneSupport; - polygonModePointSize = copy_src->polygonModePointSize; - nonStrictSinglePixelWideLinesUseParallelogram = copy_src->nonStrictSinglePixelWideLinesUseParallelogram; - nonStrictWideLinesUseParallelogram = copy_src->nonStrictWideLinesUseParallelogram; + cooperativeMatrix = copy_src->cooperativeMatrix; + cooperativeMatrixRobustBufferAccess = copy_src->cooperativeMatrixRobustBufferAccess; 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_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->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), +safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR), pNext(nullptr), - viewMask(), - colorAttachmentCount(), - pColorAttachmentFormats(nullptr), - depthAttachmentFormat(), - stencilAttachmentFormat() {} + cooperativeMatrixSupportedStages() {} -safe_VkRenderingAreaInfoKHR::safe_VkRenderingAreaInfoKHR(const safe_VkRenderingAreaInfoKHR& copy_src) { +safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR( + const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src) { sType = copy_src.sType; - viewMask = copy_src.viewMask; - colorAttachmentCount = copy_src.colorAttachmentCount; - pColorAttachmentFormats = nullptr; - depthAttachmentFormat = copy_src.depthAttachmentFormat; - stencilAttachmentFormat = copy_src.stencilAttachmentFormat; + cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages; 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_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::operator=( + const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& 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; + cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages; 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; +safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::~safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR() { FreePnextChain(pNext); } -void safe_VkRenderingAreaInfoKHR::initialize(const VkRenderingAreaInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - if (pColorAttachmentFormats) delete[] pColorAttachmentFormats; +void safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::initialize( + const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* 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; + cooperativeMatrixSupportedStages = in_struct->cooperativeMatrixSupportedStages; 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_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::initialize( + const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* 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; + cooperativeMatrixSupportedStages = copy_src->cooperativeMatrixSupportedStages; 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, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), imageSubresource(in_struct->imageSubresource) { +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_VkImageSubresource2KHR::safe_VkImageSubresource2KHR() - : sType(VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR), pNext(nullptr), imageSubresource() {} +safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR), pNext(nullptr), videoMaintenance1() {} -safe_VkImageSubresource2KHR::safe_VkImageSubresource2KHR(const safe_VkImageSubresource2KHR& copy_src) { +safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR( + const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src) { sType = copy_src.sType; - imageSubresource = copy_src.imageSubresource; + videoMaintenance1 = copy_src.videoMaintenance1; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkImageSubresource2KHR& safe_VkImageSubresource2KHR::operator=(const safe_VkImageSubresource2KHR& copy_src) { +safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::operator=( + const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - imageSubresource = copy_src.imageSubresource; + videoMaintenance1 = copy_src.videoMaintenance1; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkImageSubresource2KHR::~safe_VkImageSubresource2KHR() { FreePnextChain(pNext); } +safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::~safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR() { FreePnextChain(pNext); } -void safe_VkImageSubresource2KHR::initialize(const VkImageSubresource2KHR* 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; - imageSubresource = in_struct->imageSubresource; + videoMaintenance1 = in_struct->videoMaintenance1; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkImageSubresource2KHR::initialize(const safe_VkImageSubresource2KHR* 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; - imageSubresource = copy_src->imageSubresource; + videoMaintenance1 = copy_src->videoMaintenance1; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkDeviceImageSubresourceInfoKHR::safe_VkDeviceImageSubresourceInfoKHR(const VkDeviceImageSubresourceInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), pCreateInfo(nullptr), pSubresource(nullptr) { +safe_VkVideoInlineQueryInfoKHR::safe_VkVideoInlineQueryInfoKHR(const VkVideoInlineQueryInfoKHR* 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) { 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_VkImageSubresource2KHR(in_struct->pSubresource); } -safe_VkDeviceImageSubresourceInfoKHR::safe_VkDeviceImageSubresourceInfoKHR() - : sType(VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR), pNext(nullptr), pCreateInfo(nullptr), pSubresource(nullptr) {} +safe_VkVideoInlineQueryInfoKHR::safe_VkVideoInlineQueryInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR), pNext(nullptr), queryPool(), firstQuery(), queryCount() {} -safe_VkDeviceImageSubresourceInfoKHR::safe_VkDeviceImageSubresourceInfoKHR(const safe_VkDeviceImageSubresourceInfoKHR& copy_src) { +safe_VkVideoInlineQueryInfoKHR::safe_VkVideoInlineQueryInfoKHR(const safe_VkVideoInlineQueryInfoKHR& copy_src) { sType = copy_src.sType; - pCreateInfo = nullptr; - pSubresource = nullptr; + queryPool = copy_src.queryPool; + firstQuery = copy_src.firstQuery; + queryCount = copy_src.queryCount; 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_VkDeviceImageSubresourceInfoKHR& safe_VkDeviceImageSubresourceInfoKHR::operator=( - const safe_VkDeviceImageSubresourceInfoKHR& copy_src) { +safe_VkVideoInlineQueryInfoKHR& safe_VkVideoInlineQueryInfoKHR::operator=(const safe_VkVideoInlineQueryInfoKHR& 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; + queryPool = copy_src.queryPool; + firstQuery = copy_src.firstQuery; + queryCount = copy_src.queryCount; 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_VkDeviceImageSubresourceInfoKHR::~safe_VkDeviceImageSubresourceInfoKHR() { - if (pCreateInfo) delete pCreateInfo; - if (pSubresource) delete pSubresource; - FreePnextChain(pNext); -} +safe_VkVideoInlineQueryInfoKHR::~safe_VkVideoInlineQueryInfoKHR() { FreePnextChain(pNext); } -void safe_VkDeviceImageSubresourceInfoKHR::initialize(const VkDeviceImageSubresourceInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { - if (pCreateInfo) delete pCreateInfo; - if (pSubresource) delete pSubresource; +void safe_VkVideoInlineQueryInfoKHR::initialize(const VkVideoInlineQueryInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - pCreateInfo = nullptr; - pSubresource = nullptr; + queryPool = in_struct->queryPool; + firstQuery = in_struct->firstQuery; + queryCount = in_struct->queryCount; 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); } -void safe_VkDeviceImageSubresourceInfoKHR::initialize(const safe_VkDeviceImageSubresourceInfoKHR* 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; - pCreateInfo = nullptr; - pSubresource = nullptr; + queryPool = copy_src->queryPool; + firstQuery = copy_src->firstQuery; + queryCount = copy_src->queryCount; 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_VkSubresourceLayout2KHR::safe_VkSubresourceLayout2KHR(const VkSubresourceLayout2KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), subresourceLayout(in_struct->subresourceLayout) { +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) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkSubresourceLayout2KHR::safe_VkSubresourceLayout2KHR() - : sType(VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR), pNext(nullptr), subresourceLayout() {} +safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR), + pNext(nullptr), + maxVertexAttribDivisor(), + supportsNonZeroFirstInstance() {} -safe_VkSubresourceLayout2KHR::safe_VkSubresourceLayout2KHR(const safe_VkSubresourceLayout2KHR& copy_src) { +safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR( + const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src) { sType = copy_src.sType; - subresourceLayout = copy_src.subresourceLayout; + maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor; + supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkSubresourceLayout2KHR& safe_VkSubresourceLayout2KHR::operator=(const safe_VkSubresourceLayout2KHR& copy_src) { +safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::operator=( + const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - subresourceLayout = copy_src.subresourceLayout; + maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor; + supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkSubresourceLayout2KHR::~safe_VkSubresourceLayout2KHR() { FreePnextChain(pNext); } +safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::~safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR() { + FreePnextChain(pNext); +} -void safe_VkSubresourceLayout2KHR::initialize(const VkSubresourceLayout2KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::initialize( + const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - subresourceLayout = in_struct->subresourceLayout; + maxVertexAttribDivisor = in_struct->maxVertexAttribDivisor; + supportsNonZeroFirstInstance = in_struct->supportsNonZeroFirstInstance; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkSubresourceLayout2KHR::initialize(const safe_VkSubresourceLayout2KHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::initialize( + const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - subresourceLayout = copy_src->subresourceLayout; + maxVertexAttribDivisor = copy_src->maxVertexAttribDivisor; + supportsNonZeroFirstInstance = copy_src->supportsNonZeroFirstInstance; 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) { +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) { 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_VkPipelineCreateFlags2CreateInfoKHR::safe_VkPipelineCreateFlags2CreateInfoKHR() - : sType(VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR), pNext(nullptr), flags() {} +safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::safe_VkPipelineVertexInputDivisorStateCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR), + pNext(nullptr), + vertexBindingDivisorCount(), + pVertexBindingDivisors(nullptr) {} -safe_VkPipelineCreateFlags2CreateInfoKHR::safe_VkPipelineCreateFlags2CreateInfoKHR( - const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src) { +safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::safe_VkPipelineVertexInputDivisorStateCreateInfoKHR( + const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src) { sType = copy_src.sType; - flags = copy_src.flags; + vertexBindingDivisorCount = copy_src.vertexBindingDivisorCount; + pVertexBindingDivisors = nullptr; 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_VkPipelineCreateFlags2CreateInfoKHR& safe_VkPipelineCreateFlags2CreateInfoKHR::operator=( - const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src) { +safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::operator=( + const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src) { if (©_src == this) return *this; + if (pVertexBindingDivisors) delete[] pVertexBindingDivisors; FreePnextChain(pNext); sType = copy_src.sType; - flags = copy_src.flags; + vertexBindingDivisorCount = copy_src.vertexBindingDivisorCount; + pVertexBindingDivisors = nullptr; 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_VkPipelineCreateFlags2CreateInfoKHR::~safe_VkPipelineCreateFlags2CreateInfoKHR() { FreePnextChain(pNext); } +safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::~safe_VkPipelineVertexInputDivisorStateCreateInfoKHR() { + if (pVertexBindingDivisors) delete[] pVertexBindingDivisors; + FreePnextChain(pNext); +} -void safe_VkPipelineCreateFlags2CreateInfoKHR::initialize(const VkPipelineCreateFlags2CreateInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::initialize( + const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pVertexBindingDivisors) delete[] pVertexBindingDivisors; FreePnextChain(pNext); sType = in_struct->sType; - flags = in_struct->flags; + vertexBindingDivisorCount = in_struct->vertexBindingDivisorCount; + pVertexBindingDivisors = nullptr; 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_VkPipelineCreateFlags2CreateInfoKHR::initialize(const safe_VkPipelineCreateFlags2CreateInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::initialize( + const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - flags = copy_src->flags; + vertexBindingDivisorCount = copy_src->vertexBindingDivisorCount; + pVertexBindingDivisors = nullptr; 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_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR(const VkBufferUsageFlags2CreateInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), usage(in_struct->usage) { +safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR( + const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* 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_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR() - : sType(VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR), pNext(nullptr), usage() {} +safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR), + pNext(nullptr), + vertexAttributeInstanceRateDivisor(), + vertexAttributeInstanceRateZeroDivisor() {} -safe_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR( - const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src) { +safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR( + const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src) { sType = copy_src.sType; - usage = copy_src.usage; + vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor; + vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkBufferUsageFlags2CreateInfoKHR& safe_VkBufferUsageFlags2CreateInfoKHR::operator=( - const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src) { +safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::operator=( + const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - usage = copy_src.usage; + vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor; + vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkBufferUsageFlags2CreateInfoKHR::~safe_VkBufferUsageFlags2CreateInfoKHR() { FreePnextChain(pNext); } +safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::~safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR() { + FreePnextChain(pNext); +} -void safe_VkBufferUsageFlags2CreateInfoKHR::initialize(const VkBufferUsageFlags2CreateInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::initialize( + const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - usage = in_struct->usage; + vertexAttributeInstanceRateDivisor = in_struct->vertexAttributeInstanceRateDivisor; + vertexAttributeInstanceRateZeroDivisor = in_struct->vertexAttributeInstanceRateZeroDivisor; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkBufferUsageFlags2CreateInfoKHR::initialize(const safe_VkBufferUsageFlags2CreateInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::initialize( + const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - usage = copy_src->usage; + vertexAttributeInstanceRateDivisor = copy_src->vertexAttributeInstanceRateDivisor; + vertexAttributeInstanceRateZeroDivisor = copy_src->vertexAttributeInstanceRateZeroDivisor; 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_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_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR), pNext(nullptr), rayTracingPositionFetch() {} +safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR() + : sType(VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR), pNext(nullptr), timeDomain() {} -safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR( - const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src) { +safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR(const safe_VkCalibratedTimestampInfoKHR& copy_src) { sType = copy_src.sType; - rayTracingPositionFetch = copy_src.rayTracingPositionFetch; + timeDomain = copy_src.timeDomain; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::operator=( - const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src) { +safe_VkCalibratedTimestampInfoKHR& safe_VkCalibratedTimestampInfoKHR::operator=(const safe_VkCalibratedTimestampInfoKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - rayTracingPositionFetch = copy_src.rayTracingPositionFetch; + timeDomain = copy_src.timeDomain; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::~safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR() { - FreePnextChain(pNext); -} +safe_VkCalibratedTimestampInfoKHR::~safe_VkCalibratedTimestampInfoKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::initialize( - const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkCalibratedTimestampInfoKHR::initialize(const VkCalibratedTimestampInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - rayTracingPositionFetch = in_struct->rayTracingPositionFetch; + timeDomain = in_struct->timeDomain; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::initialize( - const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* 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; - rayTracingPositionFetch = copy_src->rayTracingPositionFetch; + timeDomain = copy_src->timeDomain; pNext = SafePnextCopy(copy_src->pNext); } -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) { +safe_VkPhysicalDeviceMaintenance6FeaturesKHR::safe_VkPhysicalDeviceMaintenance6FeaturesKHR( + const VkPhysicalDeviceMaintenance6FeaturesKHR* 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_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR() - : sType(VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR), - pNext(nullptr), - MSize(), - NSize(), - KSize(), - AType(), - BType(), - CType(), - ResultType(), - saturatingAccumulation(), - scope() {} +safe_VkPhysicalDeviceMaintenance6FeaturesKHR::safe_VkPhysicalDeviceMaintenance6FeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR), pNext(nullptr), maintenance6() {} -safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR( - const safe_VkCooperativeMatrixPropertiesKHR& copy_src) { +safe_VkPhysicalDeviceMaintenance6FeaturesKHR::safe_VkPhysicalDeviceMaintenance6FeaturesKHR( + const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& 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; + maintenance6 = copy_src.maintenance6; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkCooperativeMatrixPropertiesKHR& safe_VkCooperativeMatrixPropertiesKHR::operator=( - const safe_VkCooperativeMatrixPropertiesKHR& copy_src) { +safe_VkPhysicalDeviceMaintenance6FeaturesKHR& safe_VkPhysicalDeviceMaintenance6FeaturesKHR::operator=( + const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& 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; + maintenance6 = copy_src.maintenance6; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkCooperativeMatrixPropertiesKHR::~safe_VkCooperativeMatrixPropertiesKHR() { FreePnextChain(pNext); } +safe_VkPhysicalDeviceMaintenance6FeaturesKHR::~safe_VkPhysicalDeviceMaintenance6FeaturesKHR() { FreePnextChain(pNext); } -void safe_VkCooperativeMatrixPropertiesKHR::initialize(const VkCooperativeMatrixPropertiesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceMaintenance6FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance6FeaturesKHR* 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; + maintenance6 = in_struct->maintenance6; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkCooperativeMatrixPropertiesKHR::initialize(const safe_VkCooperativeMatrixPropertiesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceMaintenance6FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance6FeaturesKHR* 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; + maintenance6 = copy_src->maintenance6; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR( - const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkPhysicalDeviceMaintenance6PropertiesKHR::safe_VkPhysicalDeviceMaintenance6PropertiesKHR( + const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), - cooperativeMatrix(in_struct->cooperativeMatrix), - cooperativeMatrixRobustBufferAccess(in_struct->cooperativeMatrixRobustBufferAccess) { + blockTexelViewCompatibleMultipleLayers(in_struct->blockTexelViewCompatibleMultipleLayers), + maxCombinedImageSamplerDescriptorCount(in_struct->maxCombinedImageSamplerDescriptorCount), + fragmentShadingRateClampCombinerInputs(in_struct->fragmentShadingRateClampCombinerInputs) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR), +safe_VkPhysicalDeviceMaintenance6PropertiesKHR::safe_VkPhysicalDeviceMaintenance6PropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR), pNext(nullptr), - cooperativeMatrix(), - cooperativeMatrixRobustBufferAccess() {} + blockTexelViewCompatibleMultipleLayers(), + maxCombinedImageSamplerDescriptorCount(), + fragmentShadingRateClampCombinerInputs() {} -safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR( - const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src) { +safe_VkPhysicalDeviceMaintenance6PropertiesKHR::safe_VkPhysicalDeviceMaintenance6PropertiesKHR( + const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src) { sType = copy_src.sType; - cooperativeMatrix = copy_src.cooperativeMatrix; - cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess; + blockTexelViewCompatibleMultipleLayers = copy_src.blockTexelViewCompatibleMultipleLayers; + maxCombinedImageSamplerDescriptorCount = copy_src.maxCombinedImageSamplerDescriptorCount; + fragmentShadingRateClampCombinerInputs = copy_src.fragmentShadingRateClampCombinerInputs; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::operator=( - const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src) { +safe_VkPhysicalDeviceMaintenance6PropertiesKHR& safe_VkPhysicalDeviceMaintenance6PropertiesKHR::operator=( + const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - cooperativeMatrix = copy_src.cooperativeMatrix; - cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess; + blockTexelViewCompatibleMultipleLayers = copy_src.blockTexelViewCompatibleMultipleLayers; + maxCombinedImageSamplerDescriptorCount = copy_src.maxCombinedImageSamplerDescriptorCount; + fragmentShadingRateClampCombinerInputs = copy_src.fragmentShadingRateClampCombinerInputs; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::~safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR() { FreePnextChain(pNext); } +safe_VkPhysicalDeviceMaintenance6PropertiesKHR::~safe_VkPhysicalDeviceMaintenance6PropertiesKHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceMaintenance6PropertiesKHR::initialize(const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - cooperativeMatrix = in_struct->cooperativeMatrix; - cooperativeMatrixRobustBufferAccess = in_struct->cooperativeMatrixRobustBufferAccess; + blockTexelViewCompatibleMultipleLayers = in_struct->blockTexelViewCompatibleMultipleLayers; + maxCombinedImageSamplerDescriptorCount = in_struct->maxCombinedImageSamplerDescriptorCount; + fragmentShadingRateClampCombinerInputs = in_struct->fragmentShadingRateClampCombinerInputs; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::initialize( - const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceMaintenance6PropertiesKHR::initialize(const safe_VkPhysicalDeviceMaintenance6PropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - cooperativeMatrix = copy_src->cooperativeMatrix; - cooperativeMatrixRobustBufferAccess = copy_src->cooperativeMatrixRobustBufferAccess; + blockTexelViewCompatibleMultipleLayers = copy_src->blockTexelViewCompatibleMultipleLayers; + maxCombinedImageSamplerDescriptorCount = copy_src->maxCombinedImageSamplerDescriptorCount; + fragmentShadingRateClampCombinerInputs = copy_src->fragmentShadingRateClampCombinerInputs; 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) { +safe_VkBindMemoryStatusKHR::safe_VkBindMemoryStatusKHR(const VkBindMemoryStatusKHR* 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_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR), - pNext(nullptr), - cooperativeMatrixSupportedStages() {} +safe_VkBindMemoryStatusKHR::safe_VkBindMemoryStatusKHR() + : sType(VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR), pNext(nullptr), pResult(nullptr) {} -safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR( - const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src) { +safe_VkBindMemoryStatusKHR::safe_VkBindMemoryStatusKHR(const safe_VkBindMemoryStatusKHR& copy_src) { sType = copy_src.sType; - cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages; + pResult = nullptr; pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pResult) { + pResult = new VkResult(*copy_src.pResult); + } } -safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::operator=( - const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src) { +safe_VkBindMemoryStatusKHR& safe_VkBindMemoryStatusKHR::operator=(const safe_VkBindMemoryStatusKHR& copy_src) { if (©_src == this) return *this; + if (pResult) delete pResult; FreePnextChain(pNext); sType = copy_src.sType; - cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages; + pResult = nullptr; pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pResult) { + pResult = new VkResult(*copy_src.pResult); + } + return *this; } -safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::~safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR() { +safe_VkBindMemoryStatusKHR::~safe_VkBindMemoryStatusKHR() { + if (pResult) delete pResult; FreePnextChain(pNext); } -void safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::initialize( - const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkBindMemoryStatusKHR::initialize(const VkBindMemoryStatusKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pResult) delete pResult; FreePnextChain(pNext); sType = in_struct->sType; - cooperativeMatrixSupportedStages = in_struct->cooperativeMatrixSupportedStages; + pResult = nullptr; pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pResult) { + pResult = new VkResult(*in_struct->pResult); + } } -void safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::initialize( - const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkBindMemoryStatusKHR::initialize(const safe_VkBindMemoryStatusKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - cooperativeMatrixSupportedStages = copy_src->cooperativeMatrixSupportedStages; + pResult = nullptr; pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pResult) { + pResult = new VkResult(*copy_src->pResult); + } } -safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR( - const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) +safe_VkBindDescriptorSetsInfoKHR::safe_VkBindDescriptorSetsInfoKHR(const VkBindDescriptorSetsInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), - maxVertexAttribDivisor(in_struct->maxVertexAttribDivisor), - supportsNonZeroFirstInstance(in_struct->supportsNonZeroFirstInstance) { + 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_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR), +safe_VkBindDescriptorSetsInfoKHR::safe_VkBindDescriptorSetsInfoKHR() + : sType(VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR), pNext(nullptr), - maxVertexAttribDivisor(), - supportsNonZeroFirstInstance() {} + stageFlags(), + layout(), + firstSet(), + descriptorSetCount(), + pDescriptorSets(nullptr), + dynamicOffsetCount(), + pDynamicOffsets(nullptr) {} -safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR( - const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src) { +safe_VkBindDescriptorSetsInfoKHR::safe_VkBindDescriptorSetsInfoKHR(const safe_VkBindDescriptorSetsInfoKHR& copy_src) { sType = copy_src.sType; - maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor; - supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance; - pNext = SafePnextCopy(copy_src.pNext); + 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_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::operator=( - const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src) { +safe_VkBindDescriptorSetsInfoKHR& safe_VkBindDescriptorSetsInfoKHR::operator=(const safe_VkBindDescriptorSetsInfoKHR& copy_src) { if (©_src == this) return *this; + if (pDescriptorSets) delete[] pDescriptorSets; + if (pDynamicOffsets) delete[] pDynamicOffsets; FreePnextChain(pNext); sType = copy_src.sType; - maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor; - supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance; - pNext = SafePnextCopy(copy_src.pNext); + 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_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::~safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR() { +safe_VkBindDescriptorSetsInfoKHR::~safe_VkBindDescriptorSetsInfoKHR() { + if (pDescriptorSets) delete[] pDescriptorSets; + if (pDynamicOffsets) delete[] pDynamicOffsets; FreePnextChain(pNext); } -void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::initialize( - const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkBindDescriptorSetsInfoKHR::initialize(const VkBindDescriptorSetsInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDescriptorSets) delete[] pDescriptorSets; + if (pDynamicOffsets) delete[] pDynamicOffsets; FreePnextChain(pNext); sType = in_struct->sType; - maxVertexAttribDivisor = in_struct->maxVertexAttribDivisor; - supportsNonZeroFirstInstance = in_struct->supportsNonZeroFirstInstance; - pNext = SafePnextCopy(in_struct->pNext, copy_state); + 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_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::initialize( - const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkBindDescriptorSetsInfoKHR::initialize(const safe_VkBindDescriptorSetsInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - maxVertexAttribDivisor = copy_src->maxVertexAttribDivisor; - supportsNonZeroFirstInstance = copy_src->supportsNonZeroFirstInstance; - pNext = SafePnextCopy(copy_src->pNext); + 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_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_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) { 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), +safe_VkPushConstantsInfoKHR::safe_VkPushConstantsInfoKHR() + : sType(VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR), pNext(nullptr), - vertexBindingDivisorCount(), - pVertexBindingDivisors(nullptr) {} + layout(), + stageFlags(), + offset(), + size(), + pValues(nullptr) {} -safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::safe_VkPipelineVertexInputDivisorStateCreateInfoKHR( - const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src) { +safe_VkPushConstantsInfoKHR::safe_VkPushConstantsInfoKHR(const safe_VkPushConstantsInfoKHR& copy_src) { sType = copy_src.sType; - vertexBindingDivisorCount = copy_src.vertexBindingDivisorCount; - pVertexBindingDivisors = nullptr; + 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); - - 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_VkPushConstantsInfoKHR& safe_VkPushConstantsInfoKHR::operator=(const safe_VkPushConstantsInfoKHR& copy_src) { if (©_src == this) return *this; - if (pVertexBindingDivisors) delete[] pVertexBindingDivisors; FreePnextChain(pNext); sType = copy_src.sType; - vertexBindingDivisorCount = copy_src.vertexBindingDivisorCount; - pVertexBindingDivisors = nullptr; + 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); - 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_VkPushConstantsInfoKHR::~safe_VkPushConstantsInfoKHR() { FreePnextChain(pNext); } -void safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::initialize( - const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - if (pVertexBindingDivisors) delete[] pVertexBindingDivisors; +void safe_VkPushConstantsInfoKHR::initialize(const VkPushConstantsInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - vertexBindingDivisorCount = in_struct->vertexBindingDivisorCount; - pVertexBindingDivisors = nullptr; + 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); - - 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_VkPushConstantsInfoKHR::initialize(const safe_VkPushConstantsInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - vertexBindingDivisorCount = copy_src->vertexBindingDivisorCount; - pVertexBindingDivisors = nullptr; + 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); - - 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_VkPushDescriptorSetInfoKHR::safe_VkPushDescriptorSetInfoKHR(const VkPushDescriptorSetInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), - vertexAttributeInstanceRateDivisor(in_struct->vertexAttributeInstanceRateDivisor), - vertexAttributeInstanceRateZeroDivisor(in_struct->vertexAttributeInstanceRateZeroDivisor) { + 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_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR), +safe_VkPushDescriptorSetInfoKHR::safe_VkPushDescriptorSetInfoKHR() + : sType(VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR), pNext(nullptr), - vertexAttributeInstanceRateDivisor(), - vertexAttributeInstanceRateZeroDivisor() {} + stageFlags(), + layout(), + set(), + descriptorWriteCount(), + pDescriptorWrites(nullptr) {} -safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR( - const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src) { +safe_VkPushDescriptorSetInfoKHR::safe_VkPushDescriptorSetInfoKHR(const safe_VkPushDescriptorSetInfoKHR& copy_src) { sType = copy_src.sType; - vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor; - vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor; - pNext = SafePnextCopy(copy_src.pNext); + 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_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::operator=( - const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src) { +safe_VkPushDescriptorSetInfoKHR& safe_VkPushDescriptorSetInfoKHR::operator=(const safe_VkPushDescriptorSetInfoKHR& copy_src) { if (©_src == this) return *this; + if (pDescriptorWrites) delete[] pDescriptorWrites; FreePnextChain(pNext); sType = copy_src.sType; - vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor; - vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor; - pNext = SafePnextCopy(copy_src.pNext); + 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_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::~safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR() { +safe_VkPushDescriptorSetInfoKHR::~safe_VkPushDescriptorSetInfoKHR() { + if (pDescriptorWrites) delete[] pDescriptorWrites; FreePnextChain(pNext); } -void safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::initialize( - const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPushDescriptorSetInfoKHR::initialize(const VkPushDescriptorSetInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDescriptorWrites) delete[] pDescriptorWrites; FreePnextChain(pNext); sType = in_struct->sType; - vertexAttributeInstanceRateDivisor = in_struct->vertexAttributeInstanceRateDivisor; - vertexAttributeInstanceRateZeroDivisor = in_struct->vertexAttributeInstanceRateZeroDivisor; - pNext = SafePnextCopy(in_struct->pNext, copy_state); + 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_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::initialize( - const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPushDescriptorSetInfoKHR::initialize(const safe_VkPushDescriptorSetInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - vertexAttributeInstanceRateDivisor = copy_src->vertexAttributeInstanceRateDivisor; - vertexAttributeInstanceRateZeroDivisor = copy_src->vertexAttributeInstanceRateZeroDivisor; - pNext = SafePnextCopy(copy_src->pNext); + 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_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR(const VkCalibratedTimestampInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), timeDomain(in_struct->timeDomain) { +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) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR() - : sType(VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR), pNext(nullptr), timeDomain() {} +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(const safe_VkCalibratedTimestampInfoKHR& copy_src) { +safe_VkPushDescriptorSetWithTemplateInfoKHR::safe_VkPushDescriptorSetWithTemplateInfoKHR( + const safe_VkPushDescriptorSetWithTemplateInfoKHR& copy_src) { sType = copy_src.sType; - timeDomain = copy_src.timeDomain; + descriptorUpdateTemplate = copy_src.descriptorUpdateTemplate; + layout = copy_src.layout; + set = copy_src.set; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkCalibratedTimestampInfoKHR& safe_VkCalibratedTimestampInfoKHR::operator=(const safe_VkCalibratedTimestampInfoKHR& copy_src) { +safe_VkPushDescriptorSetWithTemplateInfoKHR& safe_VkPushDescriptorSetWithTemplateInfoKHR::operator=( + const safe_VkPushDescriptorSetWithTemplateInfoKHR& copy_src) { if (©_src == this) return *this; + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } FreePnextChain(pNext); sType = copy_src.sType; - timeDomain = copy_src.timeDomain; + descriptorUpdateTemplate = copy_src.descriptorUpdateTemplate; + layout = copy_src.layout; + set = copy_src.set; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkCalibratedTimestampInfoKHR::~safe_VkCalibratedTimestampInfoKHR() { FreePnextChain(pNext); } +safe_VkPushDescriptorSetWithTemplateInfoKHR::~safe_VkPushDescriptorSetWithTemplateInfoKHR() { + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + FreePnextChain(pNext); +} -void safe_VkCalibratedTimestampInfoKHR::initialize(const VkCalibratedTimestampInfoKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPushDescriptorSetWithTemplateInfoKHR::initialize(const VkPushDescriptorSetWithTemplateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } FreePnextChain(pNext); sType = in_struct->sType; - timeDomain = in_struct->timeDomain; + descriptorUpdateTemplate = in_struct->descriptorUpdateTemplate; + layout = in_struct->layout; + set = in_struct->set; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkCalibratedTimestampInfoKHR::initialize(const safe_VkCalibratedTimestampInfoKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPushDescriptorSetWithTemplateInfoKHR::initialize(const safe_VkPushDescriptorSetWithTemplateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - timeDomain = copy_src->timeDomain; + descriptorUpdateTemplate = copy_src->descriptorUpdateTemplate; + layout = copy_src->layout; + set = copy_src->set; pNext = SafePnextCopy(copy_src->pNext); } diff --git a/layers/vulkan/generated/vk_safe_struct_utils.cpp b/layers/vulkan/generated/vk_safe_struct_utils.cpp index c865ce1efc4..d4e0688f2f6 100644 --- a/layers/vulkan/generated/vk_safe_struct_utils.cpp +++ b/layers/vulkan/generated/vk_safe_struct_utils.cpp @@ -66,6 +66,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: safe_pNext = new safe_VkShaderModuleCreateInfo(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + safe_pNext = new safe_VkPipelineLayoutCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: safe_pNext = new safe_VkPhysicalDeviceSubgroupProperties(reinterpret_cast(pNext), copy_state, false); break; @@ -417,6 +420,84 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: safe_pNext = new safe_VkVideoDecodeUsageInfoKHR(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: + safe_pNext = new safe_VkVideoEncodeH264CapabilitiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: + safe_pNext = new safe_VkVideoEncodeH264QualityLevelPropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH264SessionCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH264SessionParametersAddInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH264SessionParametersCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH264SessionParametersGetInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH264PictureInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH264DpbSlotInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH264ProfileInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH264RateControlInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH264RateControlLayerInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH264GopRemainingFrameInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR: + safe_pNext = new safe_VkVideoEncodeH265CapabilitiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH265SessionCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: + safe_pNext = new safe_VkVideoEncodeH265QualityLevelPropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH265SessionParametersAddInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH265SessionParametersCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH265SessionParametersGetInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH265PictureInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH265DpbSlotInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH265ProfileInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH265RateControlInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH265RateControlLayerInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeH265GopRemainingFrameInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: safe_pNext = new safe_VkVideoDecodeH264ProfileInfoKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -563,7 +644,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: safe_pNext = new safe_VkPhysicalDevicePresentIdFeaturesKHR(reinterpret_cast(pNext), copy_state, false); break; -#ifdef VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: safe_pNext = new safe_VkVideoEncodeCapabilitiesKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -579,7 +659,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: safe_pNext = new safe_VkVideoEncodeQualityLevelInfoKHR(reinterpret_cast(pNext), copy_state, false); break; -#endif // VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: safe_pNext = new safe_VkQueueFamilyCheckpointProperties2NV(reinterpret_cast(pNext), copy_state, false); break; @@ -619,6 +698,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: + safe_pNext = new safe_VkVideoInlineQueryInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: safe_pNext = new safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -628,6 +713,15 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { 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_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_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: safe_pNext = new safe_VkDebugReportCallbackCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); break; @@ -652,86 +746,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: safe_pNext = new safe_VkPipelineRasterizationStateStreamCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); break; -#ifdef VK_ENABLE_BETA_EXTENSIONS - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: - safe_pNext = new safe_VkVideoEncodeH264CapabilitiesEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT: - safe_pNext = new safe_VkVideoEncodeH264QualityLevelPropertiesEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH264SessionCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH264SessionParametersAddInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH264SessionParametersCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH264SessionParametersGetInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH264SessionParametersFeedbackInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH264PictureInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH264DpbSlotInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH264ProfileInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH264RateControlInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH264RateControlLayerInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH264GopRemainingFrameInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: - safe_pNext = new safe_VkVideoEncodeH265CapabilitiesEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH265SessionCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT: - safe_pNext = new safe_VkVideoEncodeH265QualityLevelPropertiesEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH265SessionParametersAddInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH265SessionParametersCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH265SessionParametersGetInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH265SessionParametersFeedbackInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH265PictureInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH265DpbSlotInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH265ProfileInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH265RateControlInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH265RateControlLayerInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT: - safe_pNext = new safe_VkVideoEncodeH265GopRemainingFrameInfoEXT(reinterpret_cast(pNext), copy_state, false); - break; -#endif // VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: safe_pNext = new safe_VkTextureLODGatherFormatPropertiesAMD(reinterpret_cast(pNext), copy_state, false); break; @@ -1665,6 +1679,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: safe_pNext = new safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: safe_pNext = new safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM(reinterpret_cast(pNext), copy_state, false); break; @@ -1785,6 +1802,9 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: delete reinterpret_cast(header); break; @@ -2136,6 +2156,84 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: delete reinterpret_cast(header); break; @@ -2282,7 +2380,6 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: delete reinterpret_cast(header); break; -#ifdef VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: delete reinterpret_cast(header); break; @@ -2298,7 +2395,6 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: delete reinterpret_cast(header); break; -#endif // VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: delete reinterpret_cast(header); break; @@ -2338,6 +2434,12 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: delete reinterpret_cast(header); break; @@ -2347,6 +2449,15 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_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_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: delete reinterpret_cast(header); break; @@ -2371,86 +2482,6 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: delete reinterpret_cast(header); break; -#ifdef VK_ENABLE_BETA_EXTENSIONS - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: - delete reinterpret_cast(header); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT: - delete reinterpret_cast(header); - break; -#endif // VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: delete reinterpret_cast(header); break; @@ -3384,6 +3415,9 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: delete reinterpret_cast(header); break; diff --git a/layers/vulkan/generated/vk_safe_struct_vendor.cpp b/layers/vulkan/generated/vk_safe_struct_vendor.cpp index 74ec09ecaf1..8050dea4378 100644 --- a/layers/vulkan/generated/vk_safe_struct_vendor.cpp +++ b/layers/vulkan/generated/vk_safe_struct_vendor.cpp @@ -14339,6 +14339,65 @@ void safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::initialize( } } +safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV::safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV( + const VkPhysicalDevicePerStageDescriptorSetFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + perStageDescriptorSet(in_struct->perStageDescriptorSet), + dynamicPipelineLayout(in_struct->dynamicPipelineLayout) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV::safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV), + pNext(nullptr), + perStageDescriptorSet(), + dynamicPipelineLayout() {} + +safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV::safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV( + const safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV& copy_src) { + sType = copy_src.sType; + perStageDescriptorSet = copy_src.perStageDescriptorSet; + dynamicPipelineLayout = copy_src.dynamicPipelineLayout; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV& safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV::operator=( + const safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + perStageDescriptorSet = copy_src.perStageDescriptorSet; + dynamicPipelineLayout = copy_src.dynamicPipelineLayout; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV::~safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV::initialize( + const VkPhysicalDevicePerStageDescriptorSetFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + perStageDescriptorSet = in_struct->perStageDescriptorSet; + dynamicPipelineLayout = in_struct->dynamicPipelineLayout; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV::initialize( + const safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + perStageDescriptorSet = copy_src->perStageDescriptorSet; + dynamicPipelineLayout = copy_src->dynamicPipelineLayout; + pNext = SafePnextCopy(copy_src->pNext); +} + safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM::safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM( const VkPhysicalDeviceImageProcessing2FeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), textureBlockMatch2(in_struct->textureBlockMatch2) { diff --git a/layers/vulkan/generated/vk_validation_error_messages.h b/layers/vulkan/generated/vk_validation_error_messages.h index 7445d8b14bb..2059bfc570d 100644 --- a/layers/vulkan/generated/vk_validation_error_messages.h +++ b/layers/vulkan/generated/vk_validation_error_messages.h @@ -1,6 +1,6 @@ // *** THIS FILE IS GENERATED - DO NOT EDIT *** // See generate_spec_error_message.py for modifications -// Based on Vulkan specification version: 1.3.273 +// Based on Vulkan specification version: 1.3.274 /*************************************************************************** * @@ -773,6 +773,9 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkAccelerationStructureCreateInfoKHR-createFlags-08108", "If createFlags includes VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, the descriptorBufferCaptureReplay feature must be enabled", "1.3-extensions"}, {"VUID-VkAccelerationStructureCreateInfoKHR-createFlags-parameter", "createFlags must be a valid combination of VkAccelerationStructureCreateFlagBitsKHR values", "1.3-extensions"}, {"VUID-VkAccelerationStructureCreateInfoKHR-deviceAddress-03612", "If deviceAddress is not zero, createFlags must include VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR", "1.3-extensions"}, + {"VUID-VkAccelerationStructureCreateInfoKHR-deviceAddress-09488", "If deviceAddress is not zero, it must have been retrieved from an identically created acceleration structure, except for buffer and deviceAddress", "1.3-extensions"}, + {"VUID-VkAccelerationStructureCreateInfoKHR-deviceAddress-09489", "If deviceAddress is not zero, buffer must have been created identically to the buffer used to create the acceleration structure from which deviceAddress was retrieved, except for VkBufferOpaqueCaptureAddressCreateInfo::opaqueCaptureAddress", "1.3-extensions"}, + {"VUID-VkAccelerationStructureCreateInfoKHR-deviceAddress-09490", "If deviceAddress is not zero, buffer must have been created with a VkBufferOpaqueCaptureAddressCreateInfo::opaqueCaptureAddress that was retrieved from vkGetBufferOpaqueCaptureAddress for the buffer that was used to create the acceleration structure from which deviceAddress was retrieved", "1.3-extensions"}, {"VUID-VkAccelerationStructureCreateInfoKHR-offset-03616", "The sum of offset and size must be less than the size of buffer", "1.3-extensions"}, {"VUID-VkAccelerationStructureCreateInfoKHR-offset-03734", "offset must be a multiple of 256 bytes", "1.3-extensions"}, {"VUID-VkAccelerationStructureCreateInfoKHR-pNext-08109", "If the pNext chain includes a VkOpaqueCaptureDescriptorDataCreateInfoEXT structure, createFlags must contain VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT", "1.3-extensions"}, @@ -1035,10 +1038,42 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkBindBufferMemoryInfo-memoryOffset-01031", "memoryOffset must be less than the size of memory", "1.3-extensions"}, {"VUID-VkBindBufferMemoryInfo-memoryOffset-01036", "memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer", "1.3-extensions"}, {"VUID-VkBindBufferMemoryInfo-pNext-01605", "If the pNext chain includes a VkBindBufferMemoryDeviceGroupInfo structure, all instances of memory specified by VkBindBufferMemoryDeviceGroupInfo::pDeviceIndices must have been allocated", "1.3-extensions"}, - {"VUID-VkBindBufferMemoryInfo-pNext-pNext", "pNext must be NULL or a pointer to a valid instance of VkBindBufferMemoryDeviceGroupInfo", "1.3-extensions"}, + {"VUID-VkBindBufferMemoryInfo-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkBindBufferMemoryDeviceGroupInfo or VkBindMemoryStatusKHR", "1.3-extensions"}, {"VUID-VkBindBufferMemoryInfo-sType-sType", "sType must be VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO", "1.3-extensions"}, {"VUID-VkBindBufferMemoryInfo-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, {"VUID-VkBindBufferMemoryInfo-size-01037", "The size member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer must be less than or equal to the size of memory minus memoryOffset", "1.3-extensions"}, + {"VUID-VkBindDescriptorBufferEmbeddedSamplersInfoEXT-None-09495", "If the dynamicPipelineLayout feature is not enabled, layout must be a valid VkPipelineLayout handle", "1.3-extensions"}, + {"VUID-VkBindDescriptorBufferEmbeddedSamplersInfoEXT-layout-09496", "If layout is VK_NULL_HANDLE, the pNext chain must include a valid VkPipelineLayoutCreateInfo structure", "1.3-extensions"}, + {"VUID-VkBindDescriptorBufferEmbeddedSamplersInfoEXT-layout-parameter", "If layout is not VK_NULL_HANDLE, layout must be a valid VkPipelineLayout handle", "1.3-extensions"}, + {"VUID-VkBindDescriptorBufferEmbeddedSamplersInfoEXT-pNext-pNext", "pNext must be NULL or a pointer to a valid instance of VkPipelineLayoutCreateInfo", "1.3-extensions"}, + {"VUID-VkBindDescriptorBufferEmbeddedSamplersInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT", "1.3-extensions"}, + {"VUID-VkBindDescriptorBufferEmbeddedSamplersInfoEXT-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, + {"VUID-VkBindDescriptorBufferEmbeddedSamplersInfoEXT-set-08070", "The VkDescriptorSetLayout at index set when layout was created must have been created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT bit set", "1.3-extensions"}, + {"VUID-VkBindDescriptorBufferEmbeddedSamplersInfoEXT-set-08071", "set must be less than or equal to VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created", "1.3-extensions"}, + {"VUID-VkBindDescriptorBufferEmbeddedSamplersInfoEXT-stageFlags-parameter", "stageFlags must be a valid combination of VkShaderStageFlagBits values", "1.3-extensions"}, + {"VUID-VkBindDescriptorBufferEmbeddedSamplersInfoEXT-stageFlags-requiredbitmask", "stageFlags must not be 0", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-None-09495", "If the dynamicPipelineLayout feature is not enabled, layout must be a valid VkPipelineLayout handle", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-commonparent", "Both of layout, and the elements of pDescriptorSets that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-descriptorSetCount-arraylength", "descriptorSetCount must be greater than 0", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-dynamicOffsetCount-00359", "dynamicOffsetCount must be equal to the total number of dynamic descriptors in pDescriptorSets", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-firstSet-00360", "The sum of firstSet and descriptorSetCount must be less than or equal to VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-layout-09496", "If layout is VK_NULL_HANDLE, the pNext chain must include a valid VkPipelineLayoutCreateInfo structure", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-layout-parameter", "If layout is not VK_NULL_HANDLE, layout must be a valid VkPipelineLayout handle", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-pDescriptorSets-00358", "Each element of pDescriptorSets must have been allocated with a VkDescriptorSetLayout that matches (is the same as, or identically defined as) the VkDescriptorSetLayout at set n in layout, where n is the sum of firstSet and the index into pDescriptorSets", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-pDescriptorSets-01979", "For each dynamic uniform or storage buffer binding in pDescriptorSets, the sum of the effective offset and the range of the binding must be less than or equal to the size of the buffer", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-pDescriptorSets-04616", "Each element of pDescriptorSets must not have been allocated from a VkDescriptorPool with the VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT flag set", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-pDescriptorSets-06563", "If graphicsPipelineLibrary is not enabled, each element of pDescriptorSets must be a valid VkDescriptorSet", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-pDescriptorSets-06715", "For each dynamic uniform or storage buffer binding in pDescriptorSets, if the range was set with VK_WHOLE_SIZE then pDynamicOffsets which corresponds to the descriptor binding must be 0", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-pDescriptorSets-08010", "Each element of pDescriptorSets must have been allocated with a VkDescriptorSetLayout which was not created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-pDescriptorSets-parameter", "pDescriptorSets must be a valid pointer to an array of descriptorSetCount valid VkDescriptorSet handles", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-pDynamicOffsets-01971", "Each element of pDynamicOffsets which corresponds to a descriptor binding with type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-pDynamicOffsets-01972", "Each element of pDynamicOffsets which corresponds to a descriptor binding with type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-pDynamicOffsets-parameter", "If dynamicOffsetCount is not 0, and pDynamicOffsets is not NULL, pDynamicOffsets must be a valid pointer to an array of dynamicOffsetCount or VK_NULL_HANDLE uint32_t values", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-pNext-pNext", "pNext must be NULL or a pointer to a valid instance of VkPipelineLayoutCreateInfo", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-stageFlags-parameter", "stageFlags must be a valid combination of VkShaderStageFlagBits values", "1.3-extensions"}, + {"VUID-VkBindDescriptorSetsInfoKHR-stageFlags-requiredbitmask", "stageFlags must not be 0", "1.3-extensions"}, {"VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01633", "At least one of deviceIndexCount and splitInstanceBindRegionCount must be zero", "1.3-extensions"}, {"VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01634", "deviceIndexCount must either be zero or equal to the number of physical devices in the logical device", "1.3-extensions"}, {"VUID-VkBindImageMemoryDeviceGroupInfo-extent-01640", "The extent.width member of any element of pSplitInstanceBindRegions must either be a multiple of the sparse image block width of all non-metadata aspects of the image, or else extent.width + offset.x must equal the width of the image subresource", "1.3-extensions"}, @@ -1083,7 +1118,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkBindImageMemoryInfo-pNext-01629", "If the pNext chain includes a VkBindImageMemoryDeviceGroupInfo structure, the union of the areas of all elements of VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions that correspond to the same instance of image must cover the entire image", "1.3-extensions"}, {"VUID-VkBindImageMemoryInfo-pNext-01631", "If the pNext chain includes a VkBindImageMemorySwapchainInfoKHR structure, memory must be VK_NULL_HANDLE", "1.3-extensions"}, {"VUID-VkBindImageMemoryInfo-pNext-01632", "If the pNext chain does not include a VkBindImageMemorySwapchainInfoKHR structure, memory must be a valid VkDeviceMemory handle", "1.3-extensions"}, - {"VUID-VkBindImageMemoryInfo-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkBindImageMemoryDeviceGroupInfo, VkBindImageMemorySwapchainInfoKHR, or VkBindImagePlaneMemoryInfo", "1.3-extensions"}, + {"VUID-VkBindImageMemoryInfo-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkBindImageMemoryDeviceGroupInfo, VkBindImageMemorySwapchainInfoKHR, VkBindImagePlaneMemoryInfo, or VkBindMemoryStatusKHR", "1.3-extensions"}, {"VUID-VkBindImageMemoryInfo-sType-sType", "sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO", "1.3-extensions"}, {"VUID-VkBindImageMemoryInfo-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, {"VUID-VkBindImageMemorySwapchainInfoKHR-imageIndex-01644", "imageIndex must be less than the number of images in swapchain", "1.3-extensions"}, @@ -1098,6 +1133,8 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkBindIndexBufferIndirectCommandNV-None-02948", "Each element of the buffer from which the address was acquired and that is non-sparse must be bound completely and contiguously to a single VkDeviceMemory object", "1.3-extensions"}, {"VUID-VkBindIndexBufferIndirectCommandNV-bufferAddress-02947", "The bufferAddress must be aligned to the indexType used", "1.3-extensions"}, {"VUID-VkBindIndexBufferIndirectCommandNV-indexType-parameter", "indexType must be a valid VkIndexType value", "1.3-extensions"}, + {"VUID-VkBindMemoryStatusKHR-pResult-parameter", "pResult must be a valid pointer to a VkResult value", "1.3-extensions"}, + {"VUID-VkBindMemoryStatusKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR", "1.3-extensions"}, {"VUID-VkBindPipelineIndirectCommandNV-None-09092", "The referenced pipeline must have been created with VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV", "1.3-extensions"}, {"VUID-VkBindPipelineIndirectCommandNV-None-09093", "The referenced pipeline must have been updated with vkCmdUpdatePipelineIndirectBufferNV", "1.3-extensions"}, {"VUID-VkBindPipelineIndirectCommandNV-None-09094", "The referenced pipeline's address must have been queried with vkGetPipelineIndirectDeviceAddressNV", "1.3-extensions"}, @@ -1232,6 +1269,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkBufferCreateInfo-flags-01887", "If the protectedMemory feature is not enabled, flags must not contain VK_BUFFER_CREATE_PROTECTED_BIT", "1.3-extensions"}, {"VUID-VkBufferCreateInfo-flags-03338", "If flags includes VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, the bufferDeviceAddressCaptureReplay feature must be enabled", "1.3-extensions"}, {"VUID-VkBufferCreateInfo-flags-08099", "If flags includes VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, the descriptorBufferCaptureReplay feature must be enabled", "1.3-extensions"}, + {"VUID-VkBufferCreateInfo-flags-08325", "If flags includes VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR, then videoMaintenance1 must be enabled", "1.3-extensions"}, {"VUID-VkBufferCreateInfo-flags-parameter", "flags must be a valid combination of VkBufferCreateFlagBits values", "1.3-extensions"}, {"VUID-VkBufferCreateInfo-opaqueCaptureAddress-03337", "If VkBufferOpaqueCaptureAddressCreateInfo::opaqueCaptureAddress is not zero, flags must include VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT", "1.3-extensions"}, {"VUID-VkBufferCreateInfo-pNext-00920", "If the pNext chain includes a VkExternalMemoryBufferCreateInfo structure, its handleTypes member must only contain bits that are also in VkExternalBufferProperties::externalMemoryProperties.compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalBufferProperties with pExternalBufferInfo->handleType equal to any one of the handle types specified in VkExternalMemoryBufferCreateInfo::handleTypes", "1.3-extensions"}, @@ -1246,8 +1284,8 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkBufferCreateInfo-sharingMode-parameter", "sharingMode must be a valid VkSharingMode value", "1.3-extensions"}, {"VUID-VkBufferCreateInfo-size-00912", "size must be greater than 0", "1.3-extensions"}, {"VUID-VkBufferCreateInfo-size-06409", "size must be less than or equal to VkPhysicalDeviceMaintenance4Properties::maxBufferSize", "1.3-extensions"}, - {"VUID-VkBufferCreateInfo-usage-04813", "If usage includes VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR or VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR, then the pNext chain must include a VkVideoProfileListInfoKHR structure with profileCount greater than 0 and pProfiles including at least one VkVideoProfileInfoKHR structure with a videoCodecOperation member specifying a decode operation", "1.3-extensions"}, - {"VUID-VkBufferCreateInfo-usage-04814", "If usage includes VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR or VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR, then the pNext chain must include a VkVideoProfileListInfoKHR structure with profileCount greater than 0 and pProfiles including at least one VkVideoProfileInfoKHR structure with a videoCodecOperation member specifying an encode operation", "1.3-extensions"}, + {"VUID-VkBufferCreateInfo-usage-04813", "If usage includes VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR or VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR, and flags does not include VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR, then the pNext chain must include a VkVideoProfileListInfoKHR structure with profileCount greater than 0 and pProfiles including at least one VkVideoProfileInfoKHR structure with a videoCodecOperation member specifying a decode operation", "1.3-extensions"}, + {"VUID-VkBufferCreateInfo-usage-04814", "If usage includes VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR or VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR, and flags does not include VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR, then the pNext chain must include a VkVideoProfileListInfoKHR structure with profileCount greater than 0 and pProfiles including at least one VkVideoProfileInfoKHR structure with a videoCodecOperation member specifying an encode operation", "1.3-extensions"}, {"VUID-VkBufferCreateInfo-usage-08097", "If usage includes VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT, creating this VkBuffer must not cause the total required space for all currently valid buffers using this flag on the device to exceed VkPhysicalDeviceDescriptorBufferPropertiesEXT::samplerDescriptorBufferAddressSpaceSize or VkPhysicalDeviceDescriptorBufferPropertiesEXT::descriptorBufferAddressSpaceSize", "1.3-extensions"}, {"VUID-VkBufferCreateInfo-usage-08098", "If usage includes VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT, creating this VkBuffer must not cause the total required space for all currently valid buffers using this flag on the device to exceed VkPhysicalDeviceDescriptorBufferPropertiesEXT::resourceDescriptorBufferAddressSpaceSize or VkPhysicalDeviceDescriptorBufferPropertiesEXT::descriptorBufferAddressSpaceSize", "1.3-extensions"}, {"VUID-VkBufferCreateInfo-usage-08101", "If usage includes VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT, the descriptorBufferPushDescriptors feature must be enabled", "1.3-extensions"}, @@ -1556,6 +1594,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkComponentMapping-b-parameter", "b must be a valid VkComponentSwizzle value", "1.3-extensions"}, {"VUID-VkComponentMapping-g-parameter", "g must be a valid VkComponentSwizzle value", "1.3-extensions"}, {"VUID-VkComponentMapping-r-parameter", "r must be a valid VkComponentSwizzle value", "1.3-extensions"}, + {"VUID-VkComputePipelineCreateInfo-None-09497", "If the pNext chain does not include a VkPipelineCreateFlags2CreateInfoKHR structure, flags: must be a valid combination of VkPipelineCreateFlagBits values", "1.3-extensions"}, {"VUID-VkComputePipelineCreateInfo-commonparent", "Both of basePipelineHandle, and layout that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice", "1.3-extensions"}, {"VUID-VkComputePipelineCreateInfo-flags-03365", "flags must not include VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR", "1.3-extensions"}, {"VUID-VkComputePipelineCreateInfo-flags-03366", "flags must not include VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR", "1.3-extensions"}, @@ -2060,10 +2099,10 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkCudaLaunchInfoNV-gridDimY-09407", "gridDimY must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]", "1.3-extensions"}, {"VUID-VkCudaLaunchInfoNV-gridDimZ-09408", "gridDimZ must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]", "1.3-extensions"}, {"VUID-VkCudaLaunchInfoNV-pExtras-09412", "pExtras must be NULL", "1.3-extensions"}, - {"VUID-VkCudaLaunchInfoNV-pExtras-parameter", "If extraCount is not 0, and pExtras is not NULL, pExtras must be a valid pointer to an array of extraCount bytes", "1.3-extensions"}, + {"VUID-VkCudaLaunchInfoNV-pExtras-parameter", "If extraCount is not 0, pExtras must be a valid pointer to an array of extraCount bytes", "1.3-extensions"}, {"VUID-VkCudaLaunchInfoNV-pNext-pNext", "pNext must be NULL", "1.3-extensions"}, {"VUID-VkCudaLaunchInfoNV-pParams-09410", "pParams must be a pointer to a table of paramCount parameters, corresponding to the arguments of function.", "1.3-extensions"}, - {"VUID-VkCudaLaunchInfoNV-pParams-parameter", "If paramCount is not 0, and pParams is not NULL, pParams must be a valid pointer to an array of paramCount bytes", "1.3-extensions"}, + {"VUID-VkCudaLaunchInfoNV-pParams-parameter", "If paramCount is not 0, pParams must be a valid pointer to an array of paramCount bytes", "1.3-extensions"}, {"VUID-VkCudaLaunchInfoNV-paramCount-09409", "paramCount must be the total amount of parameters listed in the pParams table.", "1.3-extensions"}, {"VUID-VkCudaLaunchInfoNV-sType-sType", "sType must be VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV", "1.3-extensions"}, {"VUID-VkCudaModuleCreateInfoNV-dataSize-09413", "dataSize must be the total size in bytes of the PTX files or binary cache passed to pData.", "1.3-extensions"}, @@ -2280,7 +2319,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkDescriptorSetBindingReferenceVALVE-descriptorSetLayout-parameter", "descriptorSetLayout must be a valid VkDescriptorSetLayout handle", "1.3-extensions"}, {"VUID-VkDescriptorSetBindingReferenceVALVE-pNext-pNext", "pNext must be NULL", "1.3-extensions"}, {"VUID-VkDescriptorSetBindingReferenceVALVE-sType-sType", "sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE", "1.3-extensions"}, - {"VUID-VkDescriptorSetLayoutBinding-descriptorCount-00283", "If descriptorCount is not 0, stageFlags must be a valid combination of VkShaderStageFlagBits values", "1.3-extensions"}, + {"VUID-VkDescriptorSetLayoutBinding-descriptorCount-09465", "If descriptorCount is not 0, stageFlags must be VK_SHADER_STAGE_ALL or a valid combination of other VkShaderStageFlagBits values", "1.3-extensions"}, {"VUID-VkDescriptorSetLayoutBinding-descriptorType-00282", "If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and descriptorCount is not 0 and pImmutableSamplers is not NULL, pImmutableSamplers must be a valid pointer to an array of descriptorCount valid VkSampler handles", "1.3-extensions"}, {"VUID-VkDescriptorSetLayoutBinding-descriptorType-01510", "If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT and descriptorCount is not 0, then stageFlags must be 0 or VK_SHADER_STAGE_FRAGMENT_BIT", "1.3-extensions"}, {"VUID-VkDescriptorSetLayoutBinding-descriptorType-02209", "If descriptorType is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK then descriptorCount must be a multiple of 4", "1.3-extensions"}, @@ -2291,6 +2330,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkDescriptorSetLayoutBinding-flags-08005", "If VkDescriptorSetLayoutCreateInfo::flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT, descriptorType must be VK_DESCRIPTOR_TYPE_SAMPLER", "1.3-extensions"}, {"VUID-VkDescriptorSetLayoutBinding-flags-08006", "If VkDescriptorSetLayoutCreateInfo::flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT, descriptorCount must less than or equal to 1", "1.3-extensions"}, {"VUID-VkDescriptorSetLayoutBinding-flags-08007", "If VkDescriptorSetLayoutCreateInfo::flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT, and descriptorCount is equal to 1, pImmutableSamplers must not be NULL", "1.3-extensions"}, + {"VUID-VkDescriptorSetLayoutBinding-flags-09466", "If VkDescriptorSetLayoutCreateInfo::flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV, and descriptorCount is not 0, then stageFlags must be a valid combination of VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, VK_SHADER_STAGE_GEOMETRY_BIT, VK_SHADER_STAGE_FRAGMENT_BIT and VK_SHADER_STAGE_COMPUTE_BIT values", "1.3-extensions"}, {"VUID-VkDescriptorSetLayoutBinding-pImmutableSamplers-04009", "The sampler objects indicated by pImmutableSamplers must not have a borderColor with one of the values VK_BORDER_COLOR_FLOAT_CUSTOM_EXT or VK_BORDER_COLOR_INT_CUSTOM_EXT", "1.3-extensions"}, {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-None-03011", "All bindings with descriptor type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT", "1.3-extensions"}, {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-bindingCount-03002", "If bindingCount is not zero, bindingCount must equal VkDescriptorSetLayoutCreateInfo::bindingCount", "1.3-extensions"}, @@ -2311,7 +2351,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-09379", "If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then it must be the element with the the highest binding number", "1.3-extensions"}, {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-parameter", "If bindingCount is not 0, pBindingFlags must be a valid pointer to an array of bindingCount valid combinations of VkDescriptorBindingFlagBits values", "1.3-extensions"}, {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-sType-sType", "sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO", "1.3-extensions"}, - {"VUID-VkDescriptorSetLayoutCreateInfo-binding-00279", "The VkDescriptorSetLayoutBinding::binding members of the elements of the pBindings array must each have different values", "1.3-extensions"}, + {"VUID-VkDescriptorSetLayoutCreateInfo-binding-00279", "If the perStageDescriptorSet feature is not enabled, or flags does not contain VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV, then the VkDescriptorSetLayoutBinding::binding members of the elements of the pBindings array must each have different values", "1.3-extensions"}, {"VUID-VkDescriptorSetLayoutCreateInfo-descriptorType-03001", "If any binding has the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT bit set, then all bindings must not have descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC", "1.3-extensions"}, {"VUID-VkDescriptorSetLayoutCreateInfo-descriptorType-04594", "If a binding has a descriptorType value of VK_DESCRIPTOR_TYPE_MUTABLE_EXT, then pImmutableSamplers must be NULL", "1.3-extensions"}, {"VUID-VkDescriptorSetLayoutCreateInfo-flags-00280", "If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then all elements of pBindings must not have a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC", "1.3-extensions"}, @@ -2326,6 +2366,8 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkDescriptorSetLayoutCreateInfo-flags-08001", "If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT, flags must also contain VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT", "1.3-extensions"}, {"VUID-VkDescriptorSetLayoutCreateInfo-flags-08002", "If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT, then flags must not contain VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT", "1.3-extensions"}, {"VUID-VkDescriptorSetLayoutCreateInfo-flags-08003", "If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT, then flags must not contain VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE", "1.3-extensions"}, + {"VUID-VkDescriptorSetLayoutCreateInfo-flags-09463", "If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV, then perStageDescriptorSet must be enabled", "1.3-extensions"}, + {"VUID-VkDescriptorSetLayoutCreateInfo-flags-09464", "If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV, then there must not be any two elements of the pBindings array with the same VkDescriptorSetLayoutBinding::binding value and their VkDescriptorSetLayoutBinding::stageFlags containing the same bit", "1.3-extensions"}, {"VUID-VkDescriptorSetLayoutCreateInfo-flags-parameter", "flags must be a valid combination of VkDescriptorSetLayoutCreateFlagBits values", "1.3-extensions"}, {"VUID-VkDescriptorSetLayoutCreateInfo-mutableDescriptorType-04595", "If VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT::mutableDescriptorType is not enabled, pBindings must not contain a descriptorType of VK_DESCRIPTOR_TYPE_MUTABLE_EXT", "1.3-extensions"}, {"VUID-VkDescriptorSetLayoutCreateInfo-pBindings-07303", "If any element pBindings[i] has a descriptorType of VK_DESCRIPTOR_TYPE_MUTABLE_EXT, then a VkMutableDescriptorTypeCreateInfoEXT must be present in the pNext chain, and mutableDescriptorTypeListCount must be greater than i", "1.3-extensions"}, @@ -2382,7 +2424,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkDeviceCreateInfo-pNext-06532", "If the pNext chain includes a VkPhysicalDeviceVulkan13Features structure, then it must not include a VkPhysicalDeviceDynamicRenderingFeatures, VkPhysicalDeviceImageRobustnessFeatures, VkPhysicalDeviceInlineUniformBlockFeatures, VkPhysicalDeviceMaintenance4Features, VkPhysicalDevicePipelineCreationCacheControlFeatures, VkPhysicalDevicePrivateDataFeatures, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures, VkPhysicalDeviceShaderIntegerDotProductFeatures, VkPhysicalDeviceShaderTerminateInvocationFeatures, VkPhysicalDeviceSubgroupSizeControlFeatures, VkPhysicalDeviceSynchronization2Features, VkPhysicalDeviceTextureCompressionASTCHDRFeatures, or VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures structure", "1.3-extensions"}, {"VUID-VkDeviceCreateInfo-pNext-09396", "If the pNext chain includes a VkDeviceQueueShaderCoreControlCreateInfoARM structure, then it must not be included in the pNext chain of any of the VkDeviceQueueCreateInfo structures in pQueueCreateInfos.", "1.3-extensions"}, {"VUID-VkDeviceCreateInfo-pNext-09397", "If the pNext chain includes a VkDeviceQueueShaderCoreControlCreateInfoARM structure then VkPhysicalDeviceSchedulingControlsPropertiesARM::schedulingControlsFlags must contain VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM.", "1.3-extensions"}, - {"VUID-VkDeviceCreateInfo-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceDeviceMemoryReportCreateInfoEXT, VkDeviceDiagnosticsConfigCreateInfoNV, VkDeviceGroupDeviceCreateInfo, VkDeviceMemoryOverallocationCreateInfoAMD, VkDevicePrivateDataCreateInfo, VkDeviceQueueShaderCoreControlCreateInfoARM, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice4444FormatsFeaturesEXT, VkPhysicalDevice8BitStorageFeatures, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceAccelerationStructureFeaturesKHR, VkPhysicalDeviceAddressBindingReportFeaturesEXT, VkPhysicalDeviceAmigoProfilingFeaturesSEC, VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT, VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeatures, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI, VkPhysicalDeviceCoherentMemoryFeaturesAMD, VkPhysicalDeviceColorWriteEnableFeaturesEXT, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCooperativeMatrixFeaturesKHR, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCopyMemoryIndirectFeaturesNV, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceCoverageReductionModeFeaturesNV, VkPhysicalDeviceCubicClampFeaturesQCOM, VkPhysicalDeviceCubicWeightsFeaturesQCOM, VkPhysicalDeviceCudaKernelLaunchFeaturesNV, VkPhysicalDeviceCustomBorderColorFeaturesEXT, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, VkPhysicalDeviceDepthBiasControlFeaturesEXT, VkPhysicalDeviceDepthClampZeroOneFeaturesEXT, VkPhysicalDeviceDepthClipControlFeaturesEXT, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorBufferFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeatures, VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV, VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV, VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV, VkPhysicalDeviceDeviceMemoryReportFeaturesEXT, VkPhysicalDeviceDiagnosticsConfigFeaturesNV, VkPhysicalDeviceDisplacementMicromapFeaturesNV, VkPhysicalDeviceDynamicRenderingFeatures, VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT, VkPhysicalDeviceExtendedDynamicState3FeaturesEXT, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT, VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV, VkPhysicalDeviceExternalFormatResolveFeaturesANDROID, VkPhysicalDeviceExternalMemoryRDMAFeaturesNV, VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX, VkPhysicalDeviceFaultFeaturesEXT, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV, VkPhysicalDeviceFragmentShadingRateFeaturesKHR, VkPhysicalDeviceFrameBoundaryFeaturesEXT, VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR, VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, VkPhysicalDeviceHostImageCopyFeaturesEXT, VkPhysicalDeviceHostQueryResetFeatures, VkPhysicalDeviceImage2DViewOf3DFeaturesEXT, VkPhysicalDeviceImageCompressionControlFeaturesEXT, VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, VkPhysicalDeviceImageProcessing2FeaturesQCOM, VkPhysicalDeviceImageProcessingFeaturesQCOM, VkPhysicalDeviceImageRobustnessFeatures, VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT, VkPhysicalDeviceImageViewMinLodFeaturesEXT, VkPhysicalDeviceImagelessFramebufferFeatures, VkPhysicalDeviceIndexTypeUint8FeaturesEXT, VkPhysicalDeviceInheritedViewportScissorFeaturesNV, VkPhysicalDeviceInlineUniformBlockFeatures, VkPhysicalDeviceInvocationMaskFeaturesHUAWEI, VkPhysicalDeviceLegacyDitheringFeaturesEXT, VkPhysicalDeviceLineRasterizationFeaturesEXT, VkPhysicalDeviceLinearColorAttachmentFeaturesNV, VkPhysicalDeviceMaintenance4Features, VkPhysicalDeviceMaintenance5FeaturesKHR, VkPhysicalDeviceMemoryDecompressionFeaturesNV, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiDrawFeaturesEXT, VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM, VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT, VkPhysicalDeviceNestedCommandBufferFeaturesEXT, VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT, VkPhysicalDeviceOpacityMicromapFeaturesEXT, VkPhysicalDeviceOpticalFlowFeaturesNV, VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, VkPhysicalDevicePerformanceQueryFeaturesKHR, VkPhysicalDevicePipelineCreationCacheControlFeatures, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT, VkPhysicalDevicePipelinePropertiesFeaturesEXT, VkPhysicalDevicePipelineProtectedAccessFeaturesEXT, VkPhysicalDevicePipelineRobustnessFeaturesEXT, VkPhysicalDevicePortabilitySubsetFeaturesKHR, VkPhysicalDevicePresentBarrierFeaturesNV, VkPhysicalDevicePresentIdFeaturesKHR, VkPhysicalDevicePresentWaitFeaturesKHR, VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, VkPhysicalDevicePrivateDataFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceProvokingVertexFeaturesEXT, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT, VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, VkPhysicalDeviceRayQueryFeaturesKHR, VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV, VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR, VkPhysicalDeviceRayTracingMotionBlurFeaturesNV, VkPhysicalDeviceRayTracingPipelineFeaturesKHR, VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR, VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG, VkPhysicalDeviceRenderPassStripedFeaturesARM, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceRobustness2FeaturesEXT, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeatures, VkPhysicalDeviceSchedulingControlsFeaturesARM, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT, VkPhysicalDeviceShaderAtomicInt64Features, VkPhysicalDeviceShaderClockFeaturesKHR, VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, VkPhysicalDeviceShaderEnqueueFeaturesAMDX, VkPhysicalDeviceShaderFloat16Int8Features, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShaderIntegerDotProductFeatures, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT, VkPhysicalDeviceShaderObjectFeaturesEXT, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, VkPhysicalDeviceShaderTerminateInvocationFeatures, VkPhysicalDeviceShaderTileImageFeaturesEXT, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceSubgroupSizeControlFeatures, VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT, VkPhysicalDeviceSubpassShadingFeaturesHUAWEI, VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT, VkPhysicalDeviceSynchronization2Features, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTextureCompressionASTCHDRFeatures, VkPhysicalDeviceTilePropertiesFeaturesQCOM, VkPhysicalDeviceTimelineSemaphoreFeatures, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceUniformBufferStandardLayoutFeatures, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT, VkPhysicalDeviceVulkan11Features, VkPhysicalDeviceVulkan12Features, VkPhysicalDeviceVulkan13Features, VkPhysicalDeviceVulkanMemoryModelFeatures, VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, VkPhysicalDeviceYcbcrDegammaFeaturesQCOM, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT, or VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures", "1.3-extensions"}, + {"VUID-VkDeviceCreateInfo-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceDeviceMemoryReportCreateInfoEXT, VkDeviceDiagnosticsConfigCreateInfoNV, VkDeviceGroupDeviceCreateInfo, VkDeviceMemoryOverallocationCreateInfoAMD, VkDevicePrivateDataCreateInfo, VkDeviceQueueShaderCoreControlCreateInfoARM, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice4444FormatsFeaturesEXT, VkPhysicalDevice8BitStorageFeatures, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceAccelerationStructureFeaturesKHR, VkPhysicalDeviceAddressBindingReportFeaturesEXT, VkPhysicalDeviceAmigoProfilingFeaturesSEC, VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT, VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeatures, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI, VkPhysicalDeviceCoherentMemoryFeaturesAMD, VkPhysicalDeviceColorWriteEnableFeaturesEXT, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCooperativeMatrixFeaturesKHR, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCopyMemoryIndirectFeaturesNV, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceCoverageReductionModeFeaturesNV, VkPhysicalDeviceCubicClampFeaturesQCOM, VkPhysicalDeviceCubicWeightsFeaturesQCOM, VkPhysicalDeviceCudaKernelLaunchFeaturesNV, VkPhysicalDeviceCustomBorderColorFeaturesEXT, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, VkPhysicalDeviceDepthBiasControlFeaturesEXT, VkPhysicalDeviceDepthClampZeroOneFeaturesEXT, VkPhysicalDeviceDepthClipControlFeaturesEXT, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorBufferFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeatures, VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV, VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV, VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV, VkPhysicalDeviceDeviceMemoryReportFeaturesEXT, VkPhysicalDeviceDiagnosticsConfigFeaturesNV, VkPhysicalDeviceDisplacementMicromapFeaturesNV, VkPhysicalDeviceDynamicRenderingFeatures, VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT, VkPhysicalDeviceExtendedDynamicState3FeaturesEXT, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT, VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV, VkPhysicalDeviceExternalFormatResolveFeaturesANDROID, VkPhysicalDeviceExternalMemoryRDMAFeaturesNV, VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX, VkPhysicalDeviceFaultFeaturesEXT, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV, VkPhysicalDeviceFragmentShadingRateFeaturesKHR, VkPhysicalDeviceFrameBoundaryFeaturesEXT, VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR, VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, VkPhysicalDeviceHostImageCopyFeaturesEXT, VkPhysicalDeviceHostQueryResetFeatures, VkPhysicalDeviceImage2DViewOf3DFeaturesEXT, VkPhysicalDeviceImageCompressionControlFeaturesEXT, VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, VkPhysicalDeviceImageProcessing2FeaturesQCOM, VkPhysicalDeviceImageProcessingFeaturesQCOM, VkPhysicalDeviceImageRobustnessFeatures, VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT, VkPhysicalDeviceImageViewMinLodFeaturesEXT, VkPhysicalDeviceImagelessFramebufferFeatures, VkPhysicalDeviceIndexTypeUint8FeaturesEXT, VkPhysicalDeviceInheritedViewportScissorFeaturesNV, VkPhysicalDeviceInlineUniformBlockFeatures, VkPhysicalDeviceInvocationMaskFeaturesHUAWEI, VkPhysicalDeviceLegacyDitheringFeaturesEXT, VkPhysicalDeviceLineRasterizationFeaturesEXT, VkPhysicalDeviceLinearColorAttachmentFeaturesNV, VkPhysicalDeviceMaintenance4Features, VkPhysicalDeviceMaintenance5FeaturesKHR, VkPhysicalDeviceMaintenance6FeaturesKHR, VkPhysicalDeviceMemoryDecompressionFeaturesNV, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiDrawFeaturesEXT, VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM, VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT, VkPhysicalDeviceNestedCommandBufferFeaturesEXT, VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT, VkPhysicalDeviceOpacityMicromapFeaturesEXT, VkPhysicalDeviceOpticalFlowFeaturesNV, VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, VkPhysicalDevicePerStageDescriptorSetFeaturesNV, VkPhysicalDevicePerformanceQueryFeaturesKHR, VkPhysicalDevicePipelineCreationCacheControlFeatures, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT, VkPhysicalDevicePipelinePropertiesFeaturesEXT, VkPhysicalDevicePipelineProtectedAccessFeaturesEXT, VkPhysicalDevicePipelineRobustnessFeaturesEXT, VkPhysicalDevicePortabilitySubsetFeaturesKHR, VkPhysicalDevicePresentBarrierFeaturesNV, VkPhysicalDevicePresentIdFeaturesKHR, VkPhysicalDevicePresentWaitFeaturesKHR, VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, VkPhysicalDevicePrivateDataFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceProvokingVertexFeaturesEXT, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT, VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, VkPhysicalDeviceRayQueryFeaturesKHR, VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV, VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR, VkPhysicalDeviceRayTracingMotionBlurFeaturesNV, VkPhysicalDeviceRayTracingPipelineFeaturesKHR, VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR, VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG, VkPhysicalDeviceRenderPassStripedFeaturesARM, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceRobustness2FeaturesEXT, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeatures, VkPhysicalDeviceSchedulingControlsFeaturesARM, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT, VkPhysicalDeviceShaderAtomicInt64Features, VkPhysicalDeviceShaderClockFeaturesKHR, VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, VkPhysicalDeviceShaderEnqueueFeaturesAMDX, VkPhysicalDeviceShaderFloat16Int8Features, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShaderIntegerDotProductFeatures, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT, VkPhysicalDeviceShaderObjectFeaturesEXT, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, VkPhysicalDeviceShaderTerminateInvocationFeatures, VkPhysicalDeviceShaderTileImageFeaturesEXT, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceSubgroupSizeControlFeatures, VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT, VkPhysicalDeviceSubpassShadingFeaturesHUAWEI, VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT, VkPhysicalDeviceSynchronization2Features, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTextureCompressionASTCHDRFeatures, VkPhysicalDeviceTilePropertiesFeaturesQCOM, VkPhysicalDeviceTimelineSemaphoreFeatures, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceUniformBufferStandardLayoutFeatures, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT, VkPhysicalDeviceVideoMaintenance1FeaturesKHR, VkPhysicalDeviceVulkan11Features, VkPhysicalDeviceVulkan12Features, VkPhysicalDeviceVulkan13Features, VkPhysicalDeviceVulkanMemoryModelFeatures, VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, VkPhysicalDeviceYcbcrDegammaFeaturesQCOM, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT, or VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures", "1.3-extensions"}, {"VUID-VkDeviceCreateInfo-pProperties-04451", "If the VK_KHR_portability_subset extension is included in pProperties of vkEnumerateDeviceExtensionProperties, ppEnabledExtensionNames must include \"VK_KHR_portability_subset\"", "1.3-extensions"}, {"VUID-VkDeviceCreateInfo-pQueueCreateInfos-06654", "If multiple elements of pQueueCreateInfos share the same queueFamilyIndex, then all of such elements must have the same global priority level, which can be specified explicitly by the including a VkDeviceQueueGlobalPriorityCreateInfoKHR structure in the pNext chain, or by the implicit default value", "1.3-extensions"}, {"VUID-VkDeviceCreateInfo-pQueueCreateInfos-06755", "If multiple elements of pQueueCreateInfos share the same queueFamilyIndex, the sum of their queueCount members must be less than or equal to the queueCount member of the VkQueueFamilyProperties structure, as returned by vkGetPhysicalDeviceQueueFamilyProperties in the pQueueFamilyProperties[queueFamilyIndex]", "1.3-extensions"}, @@ -2611,6 +2653,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkExecutionGraphPipelineCreateInfoAMDX-None-09134", "There must be no two nodes in the pipeline that share both the same shader name and index, as specified by VkPipelineShaderStageNodeCreateInfoAMDX", "1.3-extensions"}, {"VUID-VkExecutionGraphPipelineCreateInfoAMDX-None-09135", "There must be no two nodes in the pipeline that share the same shader name and have input payload declarations with different sizes", "1.3-extensions"}, {"VUID-VkExecutionGraphPipelineCreateInfoAMDX-None-09136", "There must be no two nodes in the pipeline that share the same name but have different execution models", "1.3-extensions"}, + {"VUID-VkExecutionGraphPipelineCreateInfoAMDX-None-09497", "If the pNext chain does not include a VkPipelineCreateFlags2CreateInfoKHR structure, flags: must be a valid combination of VkPipelineCreateFlagBits values", "1.3-extensions"}, {"VUID-VkExecutionGraphPipelineCreateInfoAMDX-PayloadNodeNameAMDX-09139", "If an output payload declared in any shader in the pipeline has a PayloadNodeNameAMDX decoration with a Node Name that matches the shader name of any other node in the graph, the size of the output payload must match the size of the input payload in the matching node", "1.3-extensions"}, {"VUID-VkExecutionGraphPipelineCreateInfoAMDX-StaticNumWorkgroupsAMDX-09138", "There must be no two nodes in the pipeline that share the same name where one includes StaticNumWorkgroupsAMDX and the other does not", "1.3-extensions"}, {"VUID-VkExecutionGraphPipelineCreateInfoAMDX-commonparent", "Both of basePipelineHandle, and layout that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice", "1.3-extensions"}, @@ -2925,7 +2968,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkGetLatencyMarkerInfoNV-pTimings-parameter", "If timingCount is not 0, and pTimings is not NULL, pTimings must be a valid pointer to an array of timingCount VkLatencyTimingsFrameReportNV structures", "1.3-extensions"}, {"VUID-VkGetLatencyMarkerInfoNV-sType-sType", "sType must be VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-Geometry-07726", "If the pipeline is being created with a Geometry Execution Model, uses the OutputPoints Execution Mode, and shaderTessellationAndGeometryPointSize is not enabled, a PointSize decorated variable must not be written to", "1.3-extensions"}, - {"VUID-VkGraphicsPipelineCreateInfo-Input-06632", "If the pipeline requires fragment shader state with a fragment shader that either enables sample shading or decorates any variable in the Input storage class with Sample, then pMultisampleState must not be NULL", "1.3-extensions"}, + {"VUID-VkGraphicsPipelineCreateInfo-Input-06632", "If the pipeline requires fragment shader state with a fragment shader that either enables sample shading or decorates any variable in the Input storage class with Sample, and the VK_EXT_extended_dynamic_state3 extension is not enabled or any of the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT, VK_DYNAMIC_STATE_SAMPLE_MASK_EXT, or VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT dynamic states is not set, or alphaToOne is enabled on the device and VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT is not set, then pMultisampleState must be a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-Input-07904", "If the pipeline is being created with vertex input state and pVertexInputState is not dynamic, then all variables with the Input storage class decorated with Location in the Vertex Execution Model OpEntryPoint must contain a location in VkVertexInputAttributeDescription::location", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-Input-08733", "If the pipeline requires vertex input state and pVertexInputState is not dynamic, then the numeric type associated with all Input variables of the corresponding Location in the Vertex Execution Model OpEntryPoint must be the same as VkVertexInputAttributeDescription::format", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-None-02322", "If the pipeline requires pre-rasterization shader state, and there are any mesh shader stages in the pipeline there must not be any shader stage in the pipeline with a Xfb execution mode", "1.3-extensions"}, @@ -2935,6 +2978,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkGraphicsPipelineCreateInfo-None-06569", "If the pipeline requires fragment shader state and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, VkPipelineFragmentShadingRateEnumStateCreateInfoNV::shadingRateType must be a valid VkFragmentShadingRateTypeNV value", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-None-07826", "If the pipeline includes a complete set of state, and there are no libraries included in VkPipelineLibraryCreateInfoKHR::pLibraries, then VkPipelineLayout must be a valid pipeline layout", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-None-09043", "If pDynamicState->pDynamicStates does not include VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT, and the format of any color attachment is VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, the colorWriteMask member of the corresponding element of pColorBlendState->pAttachments must either include all of VK_COLOR_COMPONENT_R_BIT, VK_COLOR_COMPONENT_G_BIT, and VK_COLOR_COMPONENT_B_BIT, or none of them", "1.3-extensions"}, + {"VUID-VkGraphicsPipelineCreateInfo-None-09497", "If the pNext chain does not include a VkPipelineCreateFlags2CreateInfoKHR structure, flags: must be a valid combination of VkPipelineCreateFlagBits values", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-PrimitiveId-06264", "If the pipeline requires pre-rasterization shader state, it includes a mesh shader and the fragment shader code reads from an input variable that is decorated with PrimitiveId, then the mesh shader code must write to a matching output variable, decorated with PrimitiveId, in all execution paths", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-TaskNV-07063", "The shader stages for VK_SHADER_STAGE_TASK_BIT_EXT or VK_SHADER_STAGE_MESH_BIT_EXT must use either the TaskNV and MeshNV Execution Model or the TaskEXT and MeshEXT Execution Model, but must not use both", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-TessellationEvaluation-07723", "If the pipeline is being created with a TessellationEvaluation Execution Model, no Geometry Execution Model, uses the PointMode Execution Mode, and shaderTessellationAndGeometryPointSize is enabled, a PointSize decorated variable must be written to if maintenance5 is not enabled", "1.3-extensions"}, @@ -3056,7 +3100,6 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkGraphicsPipelineCreateInfo-flags-08907", "If VkGraphicsPipelineLibraryCreateInfoEXT::flags includes VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT, and pre-rasterization shader state is not specified, the pipeline must define fragment output interface state", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-flags-08909", "If flags does not include VK_PIPELINE_CREATE_LIBRARY_BIT_KHR, pre-rasterization shader state is specified either in a library or by the inclusion of VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT, and that state either includes VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE or has pRasterizationState->rasterizerDiscardEnable set to VK_FALSE, the pipeline must define fragment output interface state and fragment shader state or include those states in linked pipeline libraries", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-flags-09245", "If flags includes VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT, flags must also include VK_PIPELINE_CREATE_LIBRARY_BIT_KHR", "1.3-extensions"}, - {"VUID-VkGraphicsPipelineCreateInfo-flags-parameter", "flags must be a valid combination of VkPipelineCreateFlagBits values", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-fragmentShadingRateNonTrivialCombinerOps-04506", "If the pipeline requires pre-rasterization shader state or fragment shader state, the fragmentShadingRateNonTrivialCombinerOps limit is not supported, and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, elements of VkPipelineFragmentShadingRateStateCreateInfoKHR::combinerOps must be VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR or VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-fragmentShadingRateNonTrivialCombinerOps-04573", "If the pipeline requires fragment shader state, and the fragmentShadingRateNonTrivialCombinerOps limit is not supported and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, elements of VkPipelineFragmentShadingRateEnumStateCreateInfoNV::combinerOps must be VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR or VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-geometryStreams-02321", "If the pipeline requires pre-rasterization shader state, and the last pre-rasterization shader stage is a geometry shader, and that geometry shader uses the GeometryStreams capability, then VkPhysicalDeviceTransformFeedbackFeaturesEXT::geometryStreams feature must be enabled", "1.3-extensions"}, @@ -3149,9 +3192,8 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkGraphicsPipelineCreateInfo-pLibraries-06647", "If VkPipelineLibraryCreateInfoKHR::pLibraries includes at least one library, VkGraphicsPipelineLibraryCreateInfoEXT::flags is non-zero, and any library was created with VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR, flags must include VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-pLibraries-06681", "If one element of VkPipelineLibraryCreateInfoKHR::pLibraries includes VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT and another element includes VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT, and any element of the pSetLayouts array used to create each library's layout was VK_NULL_HANDLE, then the corresponding element of the pSetLayouts array used to create the other library's layout must not be VK_NULL_HANDLE", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-pLibraries-06758", "If one element of VkPipelineLibraryCreateInfoKHR::pLibraries includes VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT and another element includes VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT, and any element of the pSetLayouts array used to create each library's layout was VK_NULL_HANDLE, then the corresponding element of the pSetLayouts array used to create the other library's layout must not have shader bindings for shaders in the other subset", "1.3-extensions"}, - {"VUID-VkGraphicsPipelineCreateInfo-pMultisampleState-06629", "If the pipeline requires fragment shader state pMultisampleState must be NULL or a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-pMultisampleState-09026", "If the pipeline requires fragment output interface state, and the VK_EXT_extended_dynamic_state3 extension is not enabled or any of the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT, VK_DYNAMIC_STATE_SAMPLE_MASK_EXT, or VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT dynamic states is not set, or alphaToOne is enabled on the device and VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT is not set, pMultisampleState must be a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure", "1.3-extensions"}, - {"VUID-VkGraphicsPipelineCreateInfo-pMultisampleState-09027", "If pMultisampleState is not NULL is must be a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure", "1.3-extensions"}, + {"VUID-VkGraphicsPipelineCreateInfo-pMultisampleState-09027", "If pMultisampleState is not NULL it must be a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkAttachmentSampleCountInfoAMD, VkExternalFormatANDROID, VkGraphicsPipelineLibraryCreateInfoEXT, VkGraphicsPipelineShaderGroupsCreateInfoNV, VkMultiviewPerViewAttributesInfoNVX, VkPipelineCompilerControlCreateInfoAMD, VkPipelineCreateFlags2CreateInfoKHR, VkPipelineCreationFeedbackCreateInfo, VkPipelineDiscardRectangleStateCreateInfoEXT, VkPipelineFragmentShadingRateEnumStateCreateInfoNV, VkPipelineFragmentShadingRateStateCreateInfoKHR, VkPipelineLibraryCreateInfoKHR, VkPipelineRenderingCreateInfo, VkPipelineRepresentativeFragmentTestStateCreateInfoNV, or VkPipelineRobustnessCreateInfoEXT", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-pRasterizationState-09039", "If VkGraphicsPipelineLibraryCreateInfoEXT::flags includes VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT, and the VK_EXT_extended_dynamic_state3 extension is not enabled, or any of the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT, VK_DYNAMIC_STATE_SAMPLE_MASK_EXT, or VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT dynamic states are not set, or alphaToOne is enabled on the device and VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT is not set, then pMultisampleState must be a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-pRasterizationState-09040", "If pRasterizationState is not NULL it must be a valid pointer to a valid VkPipelineRasterizationStateCreateInfo structure", "1.3-extensions"}, @@ -3236,7 +3278,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkGraphicsPipelineCreateInfo-renderPass-09037", "If renderPass is VK_NULL_HANDLE, the pipeline is being created with fragment output interface state, and VkPipelineRenderingCreateInfo::colorAttachmentCount is not equal to 0, and the VK_EXT_extended_dynamic_state3 extension is not enabled, or any of the VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT, VK_DYNAMIC_STATE_LOGIC_OP_EXT, VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT, VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT, VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT, or VK_DYNAMIC_STATE_BLEND_CONSTANTS dynamic states are not set, pColorBlendState must be a valid pointer to a valid VkPipelineColorBlendStateCreateInfo structure", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-renderpass-06624", "If renderpass is not VK_NULL_HANDLE, VkGraphicsPipelineLibraryCreateInfoEXT::flags includes at least one of and no more than two of VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT, VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT, or VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT, and an element of VkPipelineLibraryCreateInfoKHR::pLibraries includes one of the other flags, renderPass must be compatible with that used to create the library", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-renderpass-06625", "If renderpass is VK_NULL_HANDLE, VkGraphicsPipelineLibraryCreateInfoEXT::flags includes at least one of and no more than two of VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT, VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT, or VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT, and an element of VkPipelineLibraryCreateInfoKHR::pLibraries includes one of the other flags, the value of renderPass used to create that library must also be VK_NULL_HANDLE", "1.3-extensions"}, - {"VUID-VkGraphicsPipelineCreateInfo-renderpass-06631", "If the pipeline requires fragment shader state and renderpass is not VK_NULL_HANDLE, then pMultisampleState must not be NULL", "1.3-extensions"}, + {"VUID-VkGraphicsPipelineCreateInfo-renderpass-06631", "If renderPass is not VK_NULL_HANDLE, the pipeline requires fragment shader state, and the VK_EXT_extended_dynamic_state3 extension is not enabled or any of the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT, VK_DYNAMIC_STATE_SAMPLE_MASK_EXT, or VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT dynamic states is not set, or alphaToOne is enabled on the device and VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT is not set, then pMultisampleState must be a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-sType-sType", "sType must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, {"VUID-VkGraphicsPipelineCreateInfo-sampleLocationsEnable-01524", "If the pipeline requires fragment shader state, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure included in the pNext chain of pMultisampleState is VK_TRUE, the fragment shader code must not statically use the extended instruction InterpolateAtSample", "1.3-extensions"}, @@ -3391,6 +3433,9 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkImageCreateInfo-flags-06883", "If flags contains VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT, samples must be VK_SAMPLE_COUNT_1_BIT", "1.3-extensions"}, {"VUID-VkImageCreateInfo-flags-07755", "If flags contains VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT, imageType must be VK_IMAGE_TYPE_3D", "1.3-extensions"}, {"VUID-VkImageCreateInfo-flags-08104", "If flags includes VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, the descriptorBufferCaptureReplay feature must be enabled", "1.3-extensions"}, + {"VUID-VkImageCreateInfo-flags-08328", "If flags includes VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR, then videoMaintenance1 must be enabled", "1.3-extensions"}, + {"VUID-VkImageCreateInfo-flags-08329", "If flags includes VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR and usage does not include VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR, then usage must not include VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR", "1.3-extensions"}, + {"VUID-VkImageCreateInfo-flags-08331", "If flags includes VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR, then usage must not include VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR", "1.3-extensions"}, {"VUID-VkImageCreateInfo-flags-08865", "If flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, extent.width and extent.height must be equal", "1.3-extensions"}, {"VUID-VkImageCreateInfo-flags-08866", "If flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, arrayLayers must be greater than or equal to 6", "1.3-extensions"}, {"VUID-VkImageCreateInfo-flags-09403", "If flags contains VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, flags must not include VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, VK_IMAGE_CREATE_SPARSE_BINDING_BIT, or VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT", "1.3-extensions"}, @@ -3485,8 +3530,8 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkImageCreateInfo-usage-00965", "If usage includes VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.height must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferHeight", "1.3-extensions"}, {"VUID-VkImageCreateInfo-usage-00966", "If usage includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, usage must also contain at least one of VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT", "1.3-extensions"}, {"VUID-VkImageCreateInfo-usage-00968", "If the shaderStorageImageMultisample feature is not enabled, and usage contains VK_IMAGE_USAGE_STORAGE_BIT, samples must be VK_SAMPLE_COUNT_1_BIT", "1.3-extensions"}, - {"VUID-VkImageCreateInfo-usage-04815", "If usage includes VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR, VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR, or VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR, then the pNext chain must include a VkVideoProfileListInfoKHR structure with profileCount greater than 0 and pProfiles including at least one VkVideoProfileInfoKHR structure with a videoCodecOperation member specifying a decode operation", "1.3-extensions"}, - {"VUID-VkImageCreateInfo-usage-04816", "If usage includes VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR, or VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR, then the pNext chain must include a VkVideoProfileListInfoKHR structure with profileCount greater than 0 and pProfiles including at least one VkVideoProfileInfoKHR structure with a videoCodecOperation member specifying an encode operation", "1.3-extensions"}, + {"VUID-VkImageCreateInfo-usage-04815", "If usage includes VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR, VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR, or VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR, and flags does not include VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR, then the pNext chain must include a VkVideoProfileListInfoKHR structure with profileCount greater than 0 and pProfiles including at least one VkVideoProfileInfoKHR structure with a videoCodecOperation member specifying a decode operation", "1.3-extensions"}, + {"VUID-VkImageCreateInfo-usage-04816", "If usage includes VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR, or VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR, and flags does not include VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR, then the pNext chain must include a VkVideoProfileListInfoKHR structure with profileCount greater than 0 and pProfiles including at least one VkVideoProfileInfoKHR structure with a videoCodecOperation member specifying an encode operation", "1.3-extensions"}, {"VUID-VkImageCreateInfo-usage-04992", "If usage includes VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI, tiling must be VK_IMAGE_TILING_LINEAR", "1.3-extensions"}, {"VUID-VkImageCreateInfo-usage-parameter", "usage must be a valid combination of VkImageUsageFlagBits values", "1.3-extensions"}, {"VUID-VkImageCreateInfo-usage-requiredbitmask", "usage must not be 0", "1.3-extensions"}, @@ -3853,10 +3898,17 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkImageViewCreateInfo-image-06723", "If image was created with VK_IMAGE_TYPE_3D but without VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set then viewType must not be VK_IMAGE_VIEW_TYPE_2D_ARRAY", "1.3-extensions"}, {"VUID-VkImageViewCreateInfo-image-06724", "If image is not a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT or VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT set, or viewType is not VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange.baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created", "1.3-extensions"}, {"VUID-VkImageViewCreateInfo-image-06728", "If image was created with VK_IMAGE_TYPE_3D but without VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT or VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT set, then viewType must not be VK_IMAGE_VIEW_TYPE_2D", "1.3-extensions"}, - {"VUID-VkImageViewCreateInfo-image-07072", "If image was created with the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag and format is a non-compressed format, the levelCount and layerCount members of subresourceRange must both be 1", "1.3-extensions"}, + {"VUID-VkImageViewCreateInfo-image-07072", "If image was created with the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag and format is a non-compressed format, the levelCount member of subresourceRange must be 1", "1.3-extensions"}, + {"VUID-VkImageViewCreateInfo-image-08333", "If image was created with VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR and usage contains VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR, then the image view's format features must contain VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR", "1.3-extensions"}, + {"VUID-VkImageViewCreateInfo-image-08334", "If image was created with VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR and usage contains VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR, then the image view's format features must contain VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR", "1.3-extensions"}, + {"VUID-VkImageViewCreateInfo-image-08335", "If image was created with VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR, then usage must not include VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR", "1.3-extensions"}, + {"VUID-VkImageViewCreateInfo-image-08336", "If image was created with VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR and usage contains VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, then the image view's format features must contain VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR", "1.3-extensions"}, + {"VUID-VkImageViewCreateInfo-image-08337", "If image was created with VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR and usage contains VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR, then the image view's format features must contain VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR", "1.3-extensions"}, + {"VUID-VkImageViewCreateInfo-image-08338", "If image was created with VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR, then usage must not include VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR", "1.3-extensions"}, {"VUID-VkImageViewCreateInfo-image-08957", "If image has an QNX Screen external format, format must be VK_FORMAT_UNDEFINED", "1.3-extensions"}, {"VUID-VkImageViewCreateInfo-image-08958", "If image has an QNX Screen external format, the pNext chain must include a VkSamplerYcbcrConversionInfo structure with a conversion object created with the same external format as image", "1.3-extensions"}, {"VUID-VkImageViewCreateInfo-image-08959", "If image has an QNX Screen external format, all members of components must be the identity swizzle", "1.3-extensions"}, + {"VUID-VkImageViewCreateInfo-image-09487", "If image was created with the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, the VkPhysicalDeviceMaintenance6PropertiesKHR::blockTexelViewCompatibleMultipleLayers property is not set to VK_TRUE, and format is a non-compressed format, then the layerCount member of subresourceRange must be 1", "1.3-extensions"}, {"VUID-VkImageViewCreateInfo-image-parameter", "image must be a valid VkImage handle", "1.3-extensions"}, {"VUID-VkImageViewCreateInfo-imageViewFormatReinterpretation-04466", "If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::imageViewFormatReinterpretation is VK_FALSE, the VkFormat in format must not contain a different number of components, or a different number of bits in each component, than the format of the VkImage in image", "1.3-extensions"}, {"VUID-VkImageViewCreateInfo-imageViewFormatSwizzle-04465", "If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::imageViewFormatSwizzle is VK_FALSE, all elements of components must have the identity swizzle", "1.3-extensions"}, @@ -4677,6 +4729,8 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkPhysicalDeviceMaintenance4Properties-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES", "1.3-extensions"}, {"VUID-VkPhysicalDeviceMaintenance5FeaturesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR", "1.3-extensions"}, {"VUID-VkPhysicalDeviceMaintenance5PropertiesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR", "1.3-extensions"}, + {"VUID-VkPhysicalDeviceMaintenance6FeaturesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR", "1.3-extensions"}, + {"VUID-VkPhysicalDeviceMaintenance6PropertiesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR", "1.3-extensions"}, {"VUID-VkPhysicalDeviceMemoryBudgetPropertiesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT", "1.3-extensions"}, {"VUID-VkPhysicalDeviceMemoryDecompressionFeaturesNV-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV", "1.3-extensions"}, {"VUID-VkPhysicalDeviceMemoryDecompressionPropertiesNV-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV", "1.3-extensions"}, @@ -4710,6 +4764,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkPhysicalDeviceOpticalFlowPropertiesNV-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV", "1.3-extensions"}, {"VUID-VkPhysicalDevicePCIBusInfoPropertiesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT", "1.3-extensions"}, {"VUID-VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT", "1.3-extensions"}, + {"VUID-VkPhysicalDevicePerStageDescriptorSetFeaturesNV-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV", "1.3-extensions"}, {"VUID-VkPhysicalDevicePerformanceQueryFeaturesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR", "1.3-extensions"}, {"VUID-VkPhysicalDevicePerformanceQueryPropertiesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR", "1.3-extensions"}, {"VUID-VkPhysicalDevicePipelineCreationCacheControlFeatures-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES", "1.3-extensions"}, @@ -4728,7 +4783,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT", "1.3-extensions"}, {"VUID-VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT", "1.3-extensions"}, {"VUID-VkPhysicalDevicePrivateDataFeatures-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES", "1.3-extensions"}, - {"VUID-VkPhysicalDeviceProperties2-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceAccelerationStructurePropertiesKHR, VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceCooperativeMatrixPropertiesKHR, VkPhysicalDeviceCooperativeMatrixPropertiesNV, VkPhysicalDeviceCopyMemoryIndirectPropertiesNV, VkPhysicalDeviceCudaKernelLaunchPropertiesNV, VkPhysicalDeviceCustomBorderColorPropertiesEXT, VkPhysicalDeviceDepthStencilResolveProperties, VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT, VkPhysicalDeviceDescriptorBufferPropertiesEXT, VkPhysicalDeviceDescriptorIndexingProperties, VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDisplacementMicromapPropertiesNV, VkPhysicalDeviceDriverProperties, VkPhysicalDeviceDrmPropertiesEXT, VkPhysicalDeviceExtendedDynamicState3PropertiesEXT, VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV, VkPhysicalDeviceExternalFormatResolvePropertiesANDROID, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceFloatControlsProperties, VkPhysicalDeviceFragmentDensityMap2PropertiesEXT, VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM, VkPhysicalDeviceFragmentDensityMapPropertiesEXT, VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR, VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV, VkPhysicalDeviceFragmentShadingRatePropertiesKHR, VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT, VkPhysicalDeviceHostImageCopyPropertiesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceImageProcessing2PropertiesQCOM, VkPhysicalDeviceImageProcessingPropertiesQCOM, VkPhysicalDeviceInlineUniformBlockProperties, VkPhysicalDeviceLayeredDriverPropertiesMSFT, VkPhysicalDeviceLineRasterizationPropertiesEXT, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMaintenance4Properties, VkPhysicalDeviceMaintenance5PropertiesKHR, VkPhysicalDeviceMemoryDecompressionPropertiesNV, VkPhysicalDeviceMeshShaderPropertiesEXT, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiDrawPropertiesEXT, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDeviceNestedCommandBufferPropertiesEXT, VkPhysicalDeviceOpacityMicromapPropertiesEXT, VkPhysicalDeviceOpticalFlowPropertiesNV, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePerformanceQueryPropertiesKHR, VkPhysicalDevicePipelineRobustnessPropertiesEXT, VkPhysicalDevicePointClippingProperties, VkPhysicalDevicePortabilitySubsetPropertiesKHR, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDeviceProvokingVertexPropertiesEXT, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV, VkPhysicalDeviceRayTracingPipelinePropertiesKHR, VkPhysicalDeviceRayTracingPropertiesNV, VkPhysicalDeviceRenderPassStripedPropertiesARM, VkPhysicalDeviceRobustness2PropertiesEXT, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxProperties, VkPhysicalDeviceSchedulingControlsPropertiesARM, VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM, VkPhysicalDeviceShaderCoreProperties2AMD, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceShaderCorePropertiesARM, VkPhysicalDeviceShaderEnqueuePropertiesAMDX, VkPhysicalDeviceShaderIntegerDotProductProperties, VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT, VkPhysicalDeviceShaderObjectPropertiesEXT, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV, VkPhysicalDeviceShaderTileImagePropertiesEXT, VkPhysicalDeviceShadingRateImagePropertiesNV, VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceSubgroupSizeControlProperties, VkPhysicalDeviceSubpassShadingPropertiesHUAWEI, VkPhysicalDeviceTexelBufferAlignmentProperties, VkPhysicalDeviceTimelineSemaphoreProperties, VkPhysicalDeviceTransformFeedbackPropertiesEXT, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT, VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR, VkPhysicalDeviceVulkan11Properties, VkPhysicalDeviceVulkan12Properties, or VkPhysicalDeviceVulkan13Properties", "1.3-extensions"}, + {"VUID-VkPhysicalDeviceProperties2-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceAccelerationStructurePropertiesKHR, VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceCooperativeMatrixPropertiesKHR, VkPhysicalDeviceCooperativeMatrixPropertiesNV, VkPhysicalDeviceCopyMemoryIndirectPropertiesNV, VkPhysicalDeviceCudaKernelLaunchPropertiesNV, VkPhysicalDeviceCustomBorderColorPropertiesEXT, VkPhysicalDeviceDepthStencilResolveProperties, VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT, VkPhysicalDeviceDescriptorBufferPropertiesEXT, VkPhysicalDeviceDescriptorIndexingProperties, VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDisplacementMicromapPropertiesNV, VkPhysicalDeviceDriverProperties, VkPhysicalDeviceDrmPropertiesEXT, VkPhysicalDeviceExtendedDynamicState3PropertiesEXT, VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV, VkPhysicalDeviceExternalFormatResolvePropertiesANDROID, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceFloatControlsProperties, VkPhysicalDeviceFragmentDensityMap2PropertiesEXT, VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM, VkPhysicalDeviceFragmentDensityMapPropertiesEXT, VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR, VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV, VkPhysicalDeviceFragmentShadingRatePropertiesKHR, VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT, VkPhysicalDeviceHostImageCopyPropertiesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceImageProcessing2PropertiesQCOM, VkPhysicalDeviceImageProcessingPropertiesQCOM, VkPhysicalDeviceInlineUniformBlockProperties, VkPhysicalDeviceLayeredDriverPropertiesMSFT, VkPhysicalDeviceLineRasterizationPropertiesEXT, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMaintenance4Properties, VkPhysicalDeviceMaintenance5PropertiesKHR, VkPhysicalDeviceMaintenance6PropertiesKHR, VkPhysicalDeviceMemoryDecompressionPropertiesNV, VkPhysicalDeviceMeshShaderPropertiesEXT, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiDrawPropertiesEXT, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDeviceNestedCommandBufferPropertiesEXT, VkPhysicalDeviceOpacityMicromapPropertiesEXT, VkPhysicalDeviceOpticalFlowPropertiesNV, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePerformanceQueryPropertiesKHR, VkPhysicalDevicePipelineRobustnessPropertiesEXT, VkPhysicalDevicePointClippingProperties, VkPhysicalDevicePortabilitySubsetPropertiesKHR, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDeviceProvokingVertexPropertiesEXT, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV, VkPhysicalDeviceRayTracingPipelinePropertiesKHR, VkPhysicalDeviceRayTracingPropertiesNV, VkPhysicalDeviceRenderPassStripedPropertiesARM, VkPhysicalDeviceRobustness2PropertiesEXT, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxProperties, VkPhysicalDeviceSchedulingControlsPropertiesARM, VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM, VkPhysicalDeviceShaderCoreProperties2AMD, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceShaderCorePropertiesARM, VkPhysicalDeviceShaderEnqueuePropertiesAMDX, VkPhysicalDeviceShaderIntegerDotProductProperties, VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT, VkPhysicalDeviceShaderObjectPropertiesEXT, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV, VkPhysicalDeviceShaderTileImagePropertiesEXT, VkPhysicalDeviceShadingRateImagePropertiesNV, VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceSubgroupSizeControlProperties, VkPhysicalDeviceSubpassShadingPropertiesHUAWEI, VkPhysicalDeviceTexelBufferAlignmentProperties, VkPhysicalDeviceTimelineSemaphoreProperties, VkPhysicalDeviceTransformFeedbackPropertiesEXT, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT, VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR, VkPhysicalDeviceVulkan11Properties, VkPhysicalDeviceVulkan12Properties, or VkPhysicalDeviceVulkan13Properties", "1.3-extensions"}, {"VUID-VkPhysicalDeviceProperties2-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2", "1.3-extensions"}, {"VUID-VkPhysicalDeviceProperties2-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, {"VUID-VkPhysicalDeviceProtectedMemoryFeatures-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES", "1.3-extensions"}, @@ -4838,13 +4893,17 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR", "1.3-extensions"}, {"VUID-VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT", "1.3-extensions"}, {"VUID-VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR-pNext-pNext", "pNext must be NULL", "1.3-extensions"}, + {"VUID-VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR-pVideoProfile-08259", "pVideoProfile must be a supported video profile", "1.3-extensions"}, + {"VUID-VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR-pVideoProfile-08260", "pVideoProfile->videoCodecOperation must specify an encode operation", "1.3-extensions"}, {"VUID-VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR-pVideoProfile-parameter", "pVideoProfile must be a valid pointer to a valid VkVideoProfileInfoKHR structure", "1.3-extensions"}, + {"VUID-VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR-qualityLevel-08261", "qualityLevel must be less than VkVideoEncodeCapabilitiesKHR::maxQualityLevels, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile specified in pVideoProfile", "1.3-extensions"}, {"VUID-VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR", "1.3-extensions"}, {"VUID-VkPhysicalDeviceVideoFormatInfoKHR-imageUsage-parameter", "imageUsage must be a valid combination of VkImageUsageFlagBits values", "1.3-extensions"}, {"VUID-VkPhysicalDeviceVideoFormatInfoKHR-imageUsage-requiredbitmask", "imageUsage must not be 0", "1.3-extensions"}, {"VUID-VkPhysicalDeviceVideoFormatInfoKHR-pNext-pNext", "pNext must be NULL or a pointer to a valid instance of VkVideoProfileListInfoKHR", "1.3-extensions"}, {"VUID-VkPhysicalDeviceVideoFormatInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR", "1.3-extensions"}, {"VUID-VkPhysicalDeviceVideoFormatInfoKHR-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, + {"VUID-VkPhysicalDeviceVideoMaintenance1FeaturesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR", "1.3-extensions"}, {"VUID-VkPhysicalDeviceVulkan11Features-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES", "1.3-extensions"}, {"VUID-VkPhysicalDeviceVulkan11Properties-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES", "1.3-extensions"}, {"VUID-VkPhysicalDeviceVulkan12Features-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES", "1.3-extensions"}, @@ -5007,7 +5066,6 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkPipelineLayoutCreateInfo-flags-parameter", "flags must be a valid combination of VkPipelineLayoutCreateFlagBits values", "1.3-extensions"}, {"VUID-VkPipelineLayoutCreateInfo-graphicsPipelineLibrary-06753", "If graphicsPipelineLibrary is not enabled, elements of pSetLayouts must be valid VkDescriptorSetLayout objects", "1.3-extensions"}, {"VUID-VkPipelineLayoutCreateInfo-pImmutableSamplers-03566", "The total number of pImmutableSamplers created with flags containing VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT or VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::maxDescriptorSetSubsampledSamplers", "1.3-extensions"}, - {"VUID-VkPipelineLayoutCreateInfo-pNext-pNext", "pNext must be NULL", "1.3-extensions"}, {"VUID-VkPipelineLayoutCreateInfo-pPushConstantRanges-00292", "Any two elements of pPushConstantRanges must not include the same stage in stageFlags", "1.3-extensions"}, {"VUID-VkPipelineLayoutCreateInfo-pPushConstantRanges-parameter", "If pushConstantRangeCount is not 0, pPushConstantRanges must be a valid pointer to an array of pushConstantRangeCount valid VkPushConstantRange structures", "1.3-extensions"}, {"VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00293", "pSetLayouts must not contain more than one descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR set", "1.3-extensions"}, @@ -5249,12 +5307,57 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkPushConstantRange-size-00298", "size must be less than or equal to VkPhysicalDeviceLimits::maxPushConstantsSize minus offset", "1.3-extensions"}, {"VUID-VkPushConstantRange-stageFlags-parameter", "stageFlags must be a valid combination of VkShaderStageFlagBits values", "1.3-extensions"}, {"VUID-VkPushConstantRange-stageFlags-requiredbitmask", "stageFlags must not be 0", "1.3-extensions"}, + {"VUID-VkPushConstantsInfoKHR-None-09495", "If the dynamicPipelineLayout feature is not enabled, layout must be a valid VkPipelineLayout handle", "1.3-extensions"}, + {"VUID-VkPushConstantsInfoKHR-layout-09496", "If layout is VK_NULL_HANDLE, the pNext chain must include a valid VkPipelineLayoutCreateInfo structure", "1.3-extensions"}, + {"VUID-VkPushConstantsInfoKHR-layout-parameter", "If layout is not VK_NULL_HANDLE, layout must be a valid VkPipelineLayout handle", "1.3-extensions"}, + {"VUID-VkPushConstantsInfoKHR-offset-00368", "offset must be a multiple of 4", "1.3-extensions"}, + {"VUID-VkPushConstantsInfoKHR-offset-00370", "offset must be less than VkPhysicalDeviceLimits::maxPushConstantsSize", "1.3-extensions"}, + {"VUID-VkPushConstantsInfoKHR-offset-01795", "For each byte in the range specified by offset and size and for each shader stage in stageFlags, there must be a push constant range in layout that includes that byte and that stage", "1.3-extensions"}, + {"VUID-VkPushConstantsInfoKHR-offset-01796", "For each byte in the range specified by offset and size and for each push constant range that overlaps that byte, stageFlags must include all stages in that push constant range's VkPushConstantRange::stageFlags", "1.3-extensions"}, + {"VUID-VkPushConstantsInfoKHR-pNext-pNext", "pNext must be NULL or a pointer to a valid instance of VkPipelineLayoutCreateInfo", "1.3-extensions"}, + {"VUID-VkPushConstantsInfoKHR-pValues-parameter", "pValues must be a valid pointer to an array of size bytes", "1.3-extensions"}, + {"VUID-VkPushConstantsInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR", "1.3-extensions"}, + {"VUID-VkPushConstantsInfoKHR-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, + {"VUID-VkPushConstantsInfoKHR-size-00369", "size must be a multiple of 4", "1.3-extensions"}, + {"VUID-VkPushConstantsInfoKHR-size-00371", "size must be less than or equal to VkPhysicalDeviceLimits::maxPushConstantsSize minus offset", "1.3-extensions"}, + {"VUID-VkPushConstantsInfoKHR-size-arraylength", "size must be greater than 0", "1.3-extensions"}, + {"VUID-VkPushConstantsInfoKHR-stageFlags-parameter", "stageFlags must be a valid combination of VkShaderStageFlagBits values", "1.3-extensions"}, + {"VUID-VkPushConstantsInfoKHR-stageFlags-requiredbitmask", "stageFlags must not be 0", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetInfoKHR-None-09495", "If the dynamicPipelineLayout feature is not enabled, layout must be a valid VkPipelineLayout handle", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetInfoKHR-descriptorWriteCount-arraylength", "descriptorWriteCount must be greater than 0", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetInfoKHR-layout-09496", "If layout is VK_NULL_HANDLE, the pNext chain must include a valid VkPipelineLayoutCreateInfo structure", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetInfoKHR-layout-parameter", "If layout is not VK_NULL_HANDLE, layout must be a valid VkPipelineLayout handle", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetInfoKHR-pDescriptorWrites-06494", "For each element i where pDescriptorWrites[i].descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, pDescriptorWrites[i].pImageInfo must be a valid pointer to an array of pDescriptorWrites[i].descriptorCount valid VkDescriptorImageInfo structures", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetInfoKHR-pDescriptorWrites-parameter", "pDescriptorWrites must be a valid pointer to an array of descriptorWriteCount valid VkWriteDescriptorSet structures", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetInfoKHR-pNext-pNext", "pNext must be NULL or a pointer to a valid instance of VkPipelineLayoutCreateInfo", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetInfoKHR-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetInfoKHR-set-00364", "set must be less than VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetInfoKHR-set-00365", "set must be the unique set number in the pipeline layout that uses a descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetInfoKHR-stageFlags-parameter", "stageFlags must be a valid combination of VkShaderStageFlagBits values", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetInfoKHR-stageFlags-requiredbitmask", "stageFlags must not be 0", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetWithTemplateInfoKHR-None-09495", "If the dynamicPipelineLayout feature is not enabled, layout must be a valid VkPipelineLayout handle", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetWithTemplateInfoKHR-commandBuffer-00366", "The pipelineBindPoint specified during the creation of the descriptor update template must be supported by the commandBuffer's parent VkCommandPool's queue family", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetWithTemplateInfoKHR-commonparent", "Both of descriptorUpdateTemplate, and layout that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetWithTemplateInfoKHR-descriptorUpdateTemplate-07994", "descriptorUpdateTemplate must have been created with a templateType of VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetWithTemplateInfoKHR-descriptorUpdateTemplate-parameter", "descriptorUpdateTemplate must be a valid VkDescriptorUpdateTemplate handle", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetWithTemplateInfoKHR-layout-07993", "layout must be compatible with the layout used to create descriptorUpdateTemplate", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetWithTemplateInfoKHR-layout-09496", "If layout is VK_NULL_HANDLE, the pNext chain must include a valid VkPipelineLayoutCreateInfo structure", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetWithTemplateInfoKHR-layout-parameter", "If layout is not VK_NULL_HANDLE, layout must be a valid VkPipelineLayout handle", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetWithTemplateInfoKHR-pData-01686", "pData must be a valid pointer to a memory containing one or more valid instances of VkDescriptorImageInfo, VkDescriptorBufferInfo, or VkBufferView in a layout defined by descriptorUpdateTemplate when it was created with vkCreateDescriptorUpdateTemplate", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetWithTemplateInfoKHR-pData-parameter", "pData must be a pointer value", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetWithTemplateInfoKHR-pNext-pNext", "pNext must be NULL or a pointer to a valid instance of VkPipelineLayoutCreateInfo", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetWithTemplateInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetWithTemplateInfoKHR-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetWithTemplateInfoKHR-set-07304", "set must be less than VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetWithTemplateInfoKHR-set-07305", "set must be the unique set number in the pipeline layout that uses a descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR", "1.3-extensions"}, + {"VUID-VkPushDescriptorSetWithTemplateInfoKHR-set-07995", "set must be the same value used to create descriptorUpdateTemplate", "1.3-extensions"}, {"VUID-VkQueryLowLatencySupportNV-pQueriedLowLatencyData-parameter", "pQueriedLowLatencyData must be a pointer value", "1.3-extensions"}, {"VUID-VkQueryLowLatencySupportNV-sType-sType", "sType must be VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV", "1.3-extensions"}, {"VUID-VkQueryPoolCreateInfo-flags-zerobitmask", "flags must be 0", "1.3-extensions"}, {"VUID-VkQueryPoolCreateInfo-meshShaderQueries-07068", "If the meshShaderQueries feature is not enabled, queryType must not be VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT", "1.3-extensions"}, {"VUID-VkQueryPoolCreateInfo-meshShaderQueries-07069", "If the meshShaderQueries feature is not enabled, and queryType is VK_QUERY_TYPE_PIPELINE_STATISTICS, pipelineStatistics must not contain VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT or VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT", "1.3-extensions"}, - {"VUID-VkQueryPoolCreateInfo-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkQueryPoolPerformanceCreateInfoKHR, VkQueryPoolPerformanceQueryCreateInfoINTEL, VkQueryPoolVideoEncodeFeedbackCreateInfoKHR, VkVideoDecodeH264ProfileInfoKHR, VkVideoDecodeH265ProfileInfoKHR, VkVideoDecodeUsageInfoKHR, VkVideoEncodeH264ProfileInfoEXT, VkVideoEncodeH265ProfileInfoEXT, VkVideoEncodeUsageInfoKHR, or VkVideoProfileInfoKHR", "1.3-extensions"}, + {"VUID-VkQueryPoolCreateInfo-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkQueryPoolPerformanceCreateInfoKHR, VkQueryPoolPerformanceQueryCreateInfoINTEL, VkQueryPoolVideoEncodeFeedbackCreateInfoKHR, VkVideoDecodeH264ProfileInfoKHR, VkVideoDecodeH265ProfileInfoKHR, VkVideoDecodeUsageInfoKHR, VkVideoEncodeH264ProfileInfoKHR, VkVideoEncodeH265ProfileInfoKHR, VkVideoEncodeUsageInfoKHR, or VkVideoProfileInfoKHR", "1.3-extensions"}, {"VUID-VkQueryPoolCreateInfo-queryCount-02763", "queryCount must be greater than 0", "1.3-extensions"}, {"VUID-VkQueryPoolCreateInfo-queryType-00791", "If the pipelineStatisticsQuery feature is not enabled, queryType must not be VK_QUERY_TYPE_PIPELINE_STATISTICS", "1.3-extensions"}, {"VUID-VkQueryPoolCreateInfo-queryType-00792", "If queryType is VK_QUERY_TYPE_PIPELINE_STATISTICS, pipelineStatistics must be a valid combination of VkQueryPipelineStatisticFlagBits values", "1.3-extensions"}, @@ -5285,6 +5388,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkQueueFamilyProperties2-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, {"VUID-VkQueueFamilyQueryResultStatusPropertiesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR", "1.3-extensions"}, {"VUID-VkQueueFamilyVideoPropertiesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR", "1.3-extensions"}, + {"VUID-VkRayTracingPipelineCreateInfoKHR-None-09497", "If the pNext chain does not include a VkPipelineCreateFlags2CreateInfoKHR structure, flags: must be a valid combination of VkPipelineCreateFlagBits values", "1.3-extensions"}, {"VUID-VkRayTracingPipelineCreateInfoKHR-commonparent", "Both of basePipelineHandle, and layout that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice", "1.3-extensions"}, {"VUID-VkRayTracingPipelineCreateInfoKHR-flags-02904", "flags must not include VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV", "1.3-extensions"}, {"VUID-VkRayTracingPipelineCreateInfoKHR-flags-03465", "If flags includes VK_PIPELINE_CREATE_LIBRARY_BIT_KHR, pLibraryInterface must not be NULL", "1.3-extensions"}, @@ -5336,6 +5440,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkRayTracingPipelineCreateInfoKHR-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, {"VUID-VkRayTracingPipelineCreateInfoKHR-stage-03425", "If flags does not include VK_PIPELINE_CREATE_LIBRARY_BIT_KHR, the stage member of at least one element of pStages, including those implicitly added by pLibraryInfo, must be VK_SHADER_STAGE_RAYGEN_BIT_KHR", "1.3-extensions"}, {"VUID-VkRayTracingPipelineCreateInfoKHR-stage-06899", "The stage value in all pStages elements must be one of VK_SHADER_STAGE_RAYGEN_BIT_KHR, VK_SHADER_STAGE_ANY_HIT_BIT_KHR, VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, VK_SHADER_STAGE_MISS_BIT_KHR, VK_SHADER_STAGE_INTERSECTION_BIT_KHR, or VK_SHADER_STAGE_CALLABLE_BIT_KHR", "1.3-extensions"}, + {"VUID-VkRayTracingPipelineCreateInfoNV-None-09497", "If the pNext chain does not include a VkPipelineCreateFlags2CreateInfoKHR structure, flags: must be a valid combination of VkPipelineCreateFlagBits values", "1.3-extensions"}, {"VUID-VkRayTracingPipelineCreateInfoNV-commonparent", "Both of basePipelineHandle, and layout that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice", "1.3-extensions"}, {"VUID-VkRayTracingPipelineCreateInfoNV-flags-02904", "flags must not include VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV", "1.3-extensions"}, {"VUID-VkRayTracingPipelineCreateInfoNV-flags-02957", "flags must not include both VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV and VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT at the same time", "1.3-extensions"}, @@ -5535,7 +5640,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkRenderPassSampleLocationsBeginInfoEXT-pAttachmentInitialSampleLocations-parameter", "If attachmentInitialSampleLocationsCount is not 0, pAttachmentInitialSampleLocations must be a valid pointer to an array of attachmentInitialSampleLocationsCount valid VkAttachmentSampleLocationsEXT structures", "1.3-extensions"}, {"VUID-VkRenderPassSampleLocationsBeginInfoEXT-pPostSubpassSampleLocations-parameter", "If postSubpassSampleLocationsCount is not 0, pPostSubpassSampleLocations must be a valid pointer to an array of postSubpassSampleLocationsCount valid VkSubpassSampleLocationsEXT structures", "1.3-extensions"}, {"VUID-VkRenderPassSampleLocationsBeginInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT", "1.3-extensions"}, - {"VUID-VkRenderPassStripeBeginInfoARM-pStripeInfos-parameter", "pStripeInfos must be a valid pointer to an array of stripeInfoCount VkRenderPassStripeInfoARM structures", "1.3-extensions"}, + {"VUID-VkRenderPassStripeBeginInfoARM-pStripeInfos-parameter", "pStripeInfos must be a valid pointer to an array of stripeInfoCount valid VkRenderPassStripeInfoARM structures", "1.3-extensions"}, {"VUID-VkRenderPassStripeBeginInfoARM-sType-sType", "sType must be VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM", "1.3-extensions"}, {"VUID-VkRenderPassStripeBeginInfoARM-stripeArea-09451", "The stripeArea defined by each element of pStripeInfos must not overlap the stripeArea of any other element", "1.3-extensions"}, {"VUID-VkRenderPassStripeBeginInfoARM-stripeInfoCount-09450", "stripeInfoCount must be less than or equal to VkPhysicalDeviceRenderPassStripedPropertiesARM::maxRenderPassStripes", "1.3-extensions"}, @@ -5627,6 +5732,9 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkRenderingInfo-colorAttachmentCount-06101", "If colorAttachmentCount is not 0 and the imageView member of an element of pColorAttachments is not VK_NULL_HANDLE, if the resolveMode member of that element of pColorAttachments is not VK_RESOLVE_MODE_NONE, its resolveImageLayout member must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL", "1.3-extensions"}, {"VUID-VkRenderingInfo-colorAttachmentCount-06106", "colorAttachmentCount must be less than or equal to VkPhysicalDeviceLimits::maxColorAttachments", "1.3-extensions"}, {"VUID-VkRenderingInfo-colorAttachmentCount-09320", "If colorAttachmentCount is not 1, the resolveMode member of any element of pColorAttachments must not be VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID", "1.3-extensions"}, + {"VUID-VkRenderingInfo-colorAttachmentCount-09476", "If colorAttachmentCount is not 0 and there is an element of pColorAttachments with either its resolveMode member set to VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID, or its imageView member not VK_NULL_HANDLE, and its resolveMode member not set to VK_RESOLVE_MODE_NONE, the resolveImageView member of that element of pColorAttachments must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT", "1.3-extensions"}, + {"VUID-VkRenderingInfo-colorAttachmentCount-09479", "If colorAttachmentCount is not 0 and the imageView member of an element of pColorAttachments is not VK_NULL_HANDLE, that imageView must have been created with the identity swizzle", "1.3-extensions"}, + {"VUID-VkRenderingInfo-colorAttachmentCount-09480", "If colorAttachmentCount is not 0, and there is an element of pColorAttachments with either its resolveMode member set to VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID, or its imageView member not set to VK_NULL_HANDLE and its resolveMode member not set to VK_RESOLVE_MODE_NONE, the resolveImageView member of that element of pColorAttachments must have been created with the identity swizzle", "1.3-extensions"}, {"VUID-VkRenderingInfo-flags-09381", "If flags includes VK_RENDERING_CONTENTS_INLINE_BIT_EXT then the nestedCommandBuffer feature must be enabled", "1.3-extensions"}, {"VUID-VkRenderingInfo-flags-parameter", "flags must be a valid combination of VkRenderingFlagBits values", "1.3-extensions"}, {"VUID-VkRenderingInfo-imageView-06107", "If the imageView member of a VkRenderingFragmentDensityMapAttachmentInfoEXT structure included in the pNext chain is not VK_NULL_HANDLE, and the fragmentDensityMapNonSubsampledImages feature is not enabled, valid imageView and resolveImageView members of pDepthAttachment, pStencilAttachment, and each element of pColorAttachments must be a VkImageView created with VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT", "1.3-extensions"}, @@ -5640,6 +5748,8 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkRenderingInfo-imageView-06858", "If multisampled-render-to-single-sampled is enabled, then all attachments referenced by imageView members of pDepthAttachment, pStencilAttachment, and elements of pColorAttachments that are not VK_NULL_HANDLE must have a sample count that is either VK_SAMPLE_COUNT_1_BIT or equal to VkMultisampledRenderToSingleSampledInfoEXT::rasterizationSamples", "1.3-extensions"}, {"VUID-VkRenderingInfo-imageView-06859", "If multisampled-render-to-single-sampled is enabled, then all attachments referenced by imageView members of pDepthAttachment, pStencilAttachment, and elements of pColorAttachments that are not VK_NULL_HANDLE and have a sample count of VK_SAMPLE_COUNT_1_BIT must have been created with VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT in their VkImageCreateInfo::flags", "1.3-extensions"}, {"VUID-VkRenderingInfo-imageView-09429", "imageView members of elements of pColorAttachments that are not VK_NULL_HANDLE must have been created with the same sampleCount , if the multisampledRenderToSingleSampled feature is not enabled", "1.3-extensions"}, + {"VUID-VkRenderingInfo-imageView-09485", "If the imageView member of a VkRenderingFragmentShadingRateAttachmentInfoKHR structure included in the pNext chain is not VK_NULL_HANDLE, it must have been created with the identity swizzle", "1.3-extensions"}, + {"VUID-VkRenderingInfo-imageView-09486", "If the imageView member of a VkRenderingFragmentDensityMapAttachmentInfoEXT structure included in the pNext chain is not VK_NULL_HANDLE, it must have been created with the identity swizzle", "1.3-extensions"}, {"VUID-VkRenderingInfo-layerCount-07817", "layerCount must be less than or equal to maxFramebufferLayers", "1.3-extensions"}, {"VUID-VkRenderingInfo-multisampledRenderToSingleSampled-06857", "imageView members of pDepthAttachment, pStencilAttachment, and elements of pColorAttachments that are not VK_NULL_HANDLE must have been created with the same sampleCount , if none of the following are enabled: The VK_AMD_mixed_attachment_samples extension The VK_NV_framebuffer_mixed_samples extension The multisampledRenderToSingleSampled feature,", "1.3-extensions"}, {"VUID-VkRenderingInfo-multiview-06127", "If the multiview feature is not enabled, viewMask must be 0", "1.3-extensions"}, @@ -5657,6 +5767,9 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkRenderingInfo-pDepthAttachment-07732", "If pDepthAttachment is not NULL and pDepthAttachment->imageView is not VK_NULL_HANDLE, pDepthAttachment->layout must not be VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL", "1.3-extensions"}, {"VUID-VkRenderingInfo-pDepthAttachment-07733", "If pDepthAttachment is not NULL, pDepthAttachment->imageView is not VK_NULL_HANDLE, and pDepthAttachment->resolveMode is not VK_RESOLVE_MODE_NONE, pDepthAttachment->resolveImageLayout must not be VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL", "1.3-extensions"}, {"VUID-VkRenderingInfo-pDepthAttachment-09318", "pDepthAttachment->resolveMode must not be VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID", "1.3-extensions"}, + {"VUID-VkRenderingInfo-pDepthAttachment-09477", "If pDepthAttachment is not NULL and pDepthAttachment->resolveMode is not VK_RESOLVE_MODE_NONE, pDepthAttachment->resolveImageView must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", "1.3-extensions"}, + {"VUID-VkRenderingInfo-pDepthAttachment-09481", "If pDepthAttachment is not NULL and pDepthAttachment->imageView is not VK_NULL_HANDLE, pDepthAttachment->imageView must have been created with the identity swizzle", "1.3-extensions"}, + {"VUID-VkRenderingInfo-pDepthAttachment-09482", "If pDepthAttachment is not NULL, pDepthAttachment->imageView is not VK_NULL_HANDLE, and pDepthAttachment->resolveMode is not VK_RESOLVE_MODE_NONE, pDepthAttachment->resolveImageView must have been created with the identity swizzle", "1.3-extensions"}, {"VUID-VkRenderingInfo-pDepthAttachment-parameter", "If pDepthAttachment is not NULL, pDepthAttachment must be a valid pointer to a valid VkRenderingAttachmentInfo structure", "1.3-extensions"}, {"VUID-VkRenderingInfo-pNext-06077", "If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, renderArea.offset.x must be greater than or equal to 0", "1.3-extensions"}, {"VUID-VkRenderingInfo-pNext-06078", "If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, renderArea.offset.y must be greater than or equal to 0", "1.3-extensions"}, @@ -5684,6 +5797,9 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkRenderingInfo-pStencilAttachment-07734", "If pStencilAttachment is not NULL and pStencilAttachment->imageView is not VK_NULL_HANDLE, pStencilAttachment->layout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL", "1.3-extensions"}, {"VUID-VkRenderingInfo-pStencilAttachment-07735", "If pStencilAttachment is not NULL, pStencilAttachment->imageView is not VK_NULL_HANDLE, and pStencilAttachment->resolveMode is not VK_RESOLVE_MODE_NONE, pStencilAttachment->resolveImageLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL", "1.3-extensions"}, {"VUID-VkRenderingInfo-pStencilAttachment-09319", "pStencilAttachment->resolveMode must not be VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID", "1.3-extensions"}, + {"VUID-VkRenderingInfo-pStencilAttachment-09478", "If pStencilAttachment is not NULL and pStencilAttachment->resolveMode is not VK_RESOLVE_MODE_NONE, pStencilAttachment->resolveImageView must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", "1.3-extensions"}, + {"VUID-VkRenderingInfo-pStencilAttachment-09483", "If pStencilAttachment is not NULL and pStencilAttachment->imageView is not VK_NULL_HANDLE, pStencilAttachment->imageView must have been created with the identity swizzle", "1.3-extensions"}, + {"VUID-VkRenderingInfo-pStencilAttachment-09484", "If pStencilAttachment is not NULL, pStencilAttachment->imageView is not VK_NULL_HANDLE, and pStencilAttachment->resolveMode is not VK_RESOLVE_MODE_NONE, pStencilAttachment->resolveImageView must have been created with the identity swizzle", "1.3-extensions"}, {"VUID-VkRenderingInfo-pStencilAttachment-parameter", "If pStencilAttachment is not NULL, pStencilAttachment must be a valid pointer to a valid VkRenderingAttachmentInfo structure", "1.3-extensions"}, {"VUID-VkRenderingInfo-perViewRenderAreaCount-07857", "If the perViewRenderAreaCount member of a VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM structure included in the pNext chain is not 0, then the multiviewPerViewRenderAreas feature must be enabled.", "1.3-extensions"}, {"VUID-VkRenderingInfo-perViewRenderAreaCount-07858", "If the perViewRenderAreaCount member of a VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM structure included in the pNext chain is not 0, then renderArea must specify a render area that includes the union of all per view render areas.", "1.3-extensions"}, @@ -5921,6 +6037,25 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkSemaphoreWaitInfo-pValues-parameter", "pValues must be a valid pointer to an array of semaphoreCount uint64_t values", "1.3-extensions"}, {"VUID-VkSemaphoreWaitInfo-sType-sType", "sType must be VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO", "1.3-extensions"}, {"VUID-VkSemaphoreWaitInfo-semaphoreCount-arraylength", "semaphoreCount must be greater than 0", "1.3-extensions"}, + {"VUID-VkSetDescriptorBufferOffsetsInfoEXT-None-09495", "If the dynamicPipelineLayout feature is not enabled, layout must be a valid VkPipelineLayout handle", "1.3-extensions"}, + {"VUID-VkSetDescriptorBufferOffsetsInfoEXT-firstSet-08066", "The sum of firstSet and setCount must be less than or equal to VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created", "1.3-extensions"}, + {"VUID-VkSetDescriptorBufferOffsetsInfoEXT-firstSet-09006", "The VkDescriptorSetLayout for each set from firstSet to firstSet + setCount when layout was created must have been created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT bit set", "1.3-extensions"}, + {"VUID-VkSetDescriptorBufferOffsetsInfoEXT-layout-09496", "If layout is VK_NULL_HANDLE, the pNext chain must include a valid VkPipelineLayoutCreateInfo structure", "1.3-extensions"}, + {"VUID-VkSetDescriptorBufferOffsetsInfoEXT-layout-parameter", "If layout is not VK_NULL_HANDLE, layout must be a valid VkPipelineLayout handle", "1.3-extensions"}, + {"VUID-VkSetDescriptorBufferOffsetsInfoEXT-pBufferIndices-08064", "Each element of pBufferIndices must be less than VkPhysicalDeviceDescriptorBufferPropertiesEXT::maxDescriptorBufferBindings", "1.3-extensions"}, + {"VUID-VkSetDescriptorBufferOffsetsInfoEXT-pBufferIndices-08065", "Each element of pBufferIndices must reference a valid descriptor buffer binding set by a previous call to vkCmdBindDescriptorBuffersEXT in commandBuffer", "1.3-extensions"}, + {"VUID-VkSetDescriptorBufferOffsetsInfoEXT-pBufferIndices-parameter", "pBufferIndices must be a valid pointer to an array of setCount uint32_t values", "1.3-extensions"}, + {"VUID-VkSetDescriptorBufferOffsetsInfoEXT-pNext-pNext", "pNext must be NULL or a pointer to a valid instance of VkPipelineLayoutCreateInfo", "1.3-extensions"}, + {"VUID-VkSetDescriptorBufferOffsetsInfoEXT-pOffsets-08061", "The offsets in pOffsets must be aligned to VkPhysicalDeviceDescriptorBufferPropertiesEXT::descriptorBufferOffsetAlignment", "1.3-extensions"}, + {"VUID-VkSetDescriptorBufferOffsetsInfoEXT-pOffsets-08063", "The offsets in pOffsets must be small enough such that any descriptor binding referenced by layout without the VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT flag computes a valid address inside the underlying VkBuffer", "1.3-extensions"}, + {"VUID-VkSetDescriptorBufferOffsetsInfoEXT-pOffsets-08126", "The offsets in pOffsets must be small enough such that any location accessed by a shader as a sampler descriptor must be within VkPhysicalDeviceDescriptorBufferPropertiesEXT::maxSamplerDescriptorBufferRange of the sampler descriptor buffer binding", "1.3-extensions"}, + {"VUID-VkSetDescriptorBufferOffsetsInfoEXT-pOffsets-08127", "The offsets in pOffsets must be small enough such that any location accessed by a shader as a resource descriptor must be within VkPhysicalDeviceDescriptorBufferPropertiesEXT::maxResourceDescriptorBufferRange of the resource descriptor buffer binding", "1.3-extensions"}, + {"VUID-VkSetDescriptorBufferOffsetsInfoEXT-pOffsets-parameter", "pOffsets must be a valid pointer to an array of setCount VkDeviceSize values", "1.3-extensions"}, + {"VUID-VkSetDescriptorBufferOffsetsInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT", "1.3-extensions"}, + {"VUID-VkSetDescriptorBufferOffsetsInfoEXT-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, + {"VUID-VkSetDescriptorBufferOffsetsInfoEXT-setCount-arraylength", "setCount must be greater than 0", "1.3-extensions"}, + {"VUID-VkSetDescriptorBufferOffsetsInfoEXT-stageFlags-parameter", "stageFlags must be a valid combination of VkShaderStageFlagBits values", "1.3-extensions"}, + {"VUID-VkSetDescriptorBufferOffsetsInfoEXT-stageFlags-requiredbitmask", "stageFlags must not be 0", "1.3-extensions"}, {"VUID-VkSetLatencyMarkerInfoNV-marker-parameter", "marker must be a valid VkLatencyMarkerNV value", "1.3-extensions"}, {"VUID-VkSetLatencyMarkerInfoNV-sType-sType", "sType must be VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV", "1.3-extensions"}, {"VUID-VkShaderCreateInfoEXT-codeSize-08735", "If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, codeSize must be a multiple of 4", "1.3-extensions"}, @@ -6056,6 +6191,8 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkSparseMemoryBind-memory-parameter", "If memory is not VK_NULL_HANDLE, memory must be a valid VkDeviceMemory handle", "1.3-extensions"}, {"VUID-VkSparseMemoryBind-memoryOffset-01101", "memoryOffset must be less than the size of memory", "1.3-extensions"}, {"VUID-VkSparseMemoryBind-resourceOffset-01099", "resourceOffset must be less than the size of the resource", "1.3-extensions"}, + {"VUID-VkSparseMemoryBind-resourceOffset-09491", "If the resource being bound is a VkBuffer, resourceOffset and memoryOffset must be an integer multiple of the alignment of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with the buffer resource", "1.3-extensions"}, + {"VUID-VkSparseMemoryBind-resourceOffset-09492", "If the resource being bound is a VkImage, resourceOffset and memoryOffset must be an integer multiple of the alignment of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with the image resource", "1.3-extensions"}, {"VUID-VkSparseMemoryBind-size-01098", "size must be greater than 0", "1.3-extensions"}, {"VUID-VkSparseMemoryBind-size-01100", "size must be less than or equal to the size of the resource minus resourceOffset", "1.3-extensions"}, {"VUID-VkSparseMemoryBind-size-01102", "size must be less than or equal to the size of memory minus memoryOffset", "1.3-extensions"}, @@ -6550,7 +6687,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkVideoBeginCodingInfoKHR-commonparent", "Both of videoSession, and videoSessionParameters that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice", "1.3-extensions"}, {"VUID-VkVideoBeginCodingInfoKHR-flags-07244", "If VkVideoCapabilitiesKHR::flags does not include VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile videoSession was created with, then pPictureResource->imageViewBinding of all elements of pReferenceSlots with a non-NULL pPictureResource member must specify image views created from the same image", "1.3-extensions"}, {"VUID-VkVideoBeginCodingInfoKHR-flags-zerobitmask", "flags must be 0", "1.3-extensions"}, - {"VUID-VkVideoBeginCodingInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264GopRemainingFrameInfoEXT, VkVideoEncodeH264RateControlInfoEXT, VkVideoEncodeH265GopRemainingFrameInfoEXT, VkVideoEncodeH265RateControlInfoEXT, or VkVideoEncodeRateControlInfoKHR", "1.3-extensions"}, + {"VUID-VkVideoBeginCodingInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264GopRemainingFrameInfoKHR, VkVideoEncodeH264RateControlInfoKHR, VkVideoEncodeH265GopRemainingFrameInfoKHR, VkVideoEncodeH265RateControlInfoKHR, or VkVideoEncodeRateControlInfoKHR", "1.3-extensions"}, {"VUID-VkVideoBeginCodingInfoKHR-pPictureResource-07238", "Each video picture resource corresponding to any non-NULL pPictureResource member specified in the elements of pReferenceSlots must be unique within pReferenceSlots", "1.3-extensions"}, {"VUID-VkVideoBeginCodingInfoKHR-pPictureResource-07240", "If the pPictureResource member of any element of pReferenceSlots is not NULL, then the image view specified in pPictureResource->imageViewBinding for that element must be compatible with the video profile videoSession was created with", "1.3-extensions"}, {"VUID-VkVideoBeginCodingInfoKHR-pPictureResource-07241", "If the pPictureResource member of any element of pReferenceSlots is not NULL, then the format of the image view specified in pPictureResource->imageViewBinding for that element must match the VkVideoSessionCreateInfoKHR::referencePictureFormat videoSession was created with", "1.3-extensions"}, @@ -6565,23 +6702,20 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkVideoBeginCodingInfoKHR-videoSession-07237", "videoSession must have memory bound to all of its memory bindings returned by vkGetVideoSessionMemoryRequirementsKHR for videoSession", "1.3-extensions"}, {"VUID-VkVideoBeginCodingInfoKHR-videoSession-07247", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR, then videoSessionParameters must not be VK_NULL_HANDLE", "1.3-extensions"}, {"VUID-VkVideoBeginCodingInfoKHR-videoSession-07248", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, then videoSessionParameters must not be VK_NULL_HANDLE", "1.3-extensions"}, - {"VUID-VkVideoBeginCodingInfoKHR-videoSession-07249", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT, then videoSessionParameters must not be VK_NULL_HANDLE", "1.3-extensions"}, - {"VUID-VkVideoBeginCodingInfoKHR-videoSession-07250", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT, then videoSessionParameters must not be VK_NULL_HANDLE", "1.3-extensions"}, + {"VUID-VkVideoBeginCodingInfoKHR-videoSession-07249", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then videoSessionParameters must not be VK_NULL_HANDLE", "1.3-extensions"}, + {"VUID-VkVideoBeginCodingInfoKHR-videoSession-07250", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then videoSessionParameters must not be VK_NULL_HANDLE", "1.3-extensions"}, {"VUID-VkVideoBeginCodingInfoKHR-videoSession-parameter", "videoSession must be a valid VkVideoSessionKHR handle", "1.3-extensions"}, {"VUID-VkVideoBeginCodingInfoKHR-videoSessionParameters-04857", "If videoSessionParameters is not VK_NULL_HANDLE, it must have been created with videoSession specified in VkVideoSessionParametersCreateInfoKHR::videoSession", "1.3-extensions"}, {"VUID-VkVideoBeginCodingInfoKHR-videoSessionParameters-parameter", "If videoSessionParameters is not VK_NULL_HANDLE, videoSessionParameters must be a valid VkVideoSessionParametersKHR handle", "1.3-extensions"}, {"VUID-VkVideoBeginCodingInfoKHR-videoSessionParameters-parent", "If videoSessionParameters is a valid handle, it must have been created, allocated, or retrieved from videoSession", "1.3-extensions"}, - {"VUID-VkVideoCapabilitiesKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeCapabilitiesKHR, VkVideoDecodeH264CapabilitiesKHR, VkVideoDecodeH265CapabilitiesKHR, VkVideoEncodeCapabilitiesKHR, VkVideoEncodeH264CapabilitiesEXT, or VkVideoEncodeH265CapabilitiesEXT", "1.3-extensions"}, + {"VUID-VkVideoCapabilitiesKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeCapabilitiesKHR, VkVideoDecodeH264CapabilitiesKHR, VkVideoDecodeH265CapabilitiesKHR, VkVideoEncodeCapabilitiesKHR, VkVideoEncodeH264CapabilitiesKHR, or VkVideoEncodeH265CapabilitiesKHR", "1.3-extensions"}, {"VUID-VkVideoCapabilitiesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR", "1.3-extensions"}, {"VUID-VkVideoCapabilitiesKHR-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, {"VUID-VkVideoCodingControlInfoKHR-flags-07018", "If flags includes VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR, then the pNext chain must include a VkVideoEncodeRateControlInfoKHR structure", "1.3-extensions"}, - {"VUID-VkVideoCodingControlInfoKHR-flags-07021", "If flags includes VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR, the rateControlMode member of VkVideoEncodeRateControlInfoKHR included in the pNext chain is not VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR or VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR, and the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT, then the pNext chain must include a VkVideoEncodeH264RateControlInfoEXT structure", "1.3-extensions"}, - {"VUID-VkVideoCodingControlInfoKHR-flags-07024", "If flags includes VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR, the rateControlMode member of VkVideoEncodeRateControlInfoKHR included in the pNext chain is not VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR or VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR, and the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT, then the pNext chain must include a VkVideoEncodeH265RateControlInfoEXT structure", "1.3-extensions"}, + {"VUID-VkVideoCodingControlInfoKHR-flags-08349", "If flags includes VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR, then the pNext chain must include a VkVideoEncodeQualityLevelInfoKHR structure", "1.3-extensions"}, {"VUID-VkVideoCodingControlInfoKHR-flags-parameter", "flags must be a valid combination of VkVideoCodingControlFlagBitsKHR values", "1.3-extensions"}, {"VUID-VkVideoCodingControlInfoKHR-flags-requiredbitmask", "flags must not be 0", "1.3-extensions"}, - {"VUID-VkVideoCodingControlInfoKHR-pNext-07022", "If the pNext chain includes a VkVideoEncodeRateControlInfoKHR, and VkVideoEncodeRateControlInfoKHR::layerCount is greater than 1, then VkVideoEncodeH264RateControlInfoEXT::temporalLayerCount must be equal to layerCount", "1.3-extensions"}, - {"VUID-VkVideoCodingControlInfoKHR-pNext-07025", "If the pNext chain includes a VkVideoEncodeRateControlInfoKHR, and VkVideoEncodeRateControlInfoKHR::layerCount is greater than 1, then VkVideoEncodeH265RateControlInfoEXT::subLayerCount must be equal to layerCount", "1.3-extensions"}, - {"VUID-VkVideoCodingControlInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264RateControlInfoEXT, VkVideoEncodeH265RateControlInfoEXT, VkVideoEncodeQualityLevelInfoKHR, or VkVideoEncodeRateControlInfoKHR", "1.3-extensions"}, + {"VUID-VkVideoCodingControlInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264RateControlInfoKHR, VkVideoEncodeH265RateControlInfoKHR, VkVideoEncodeQualityLevelInfoKHR, or VkVideoEncodeRateControlInfoKHR", "1.3-extensions"}, {"VUID-VkVideoCodingControlInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR", "1.3-extensions"}, {"VUID-VkVideoCodingControlInfoKHR-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, {"VUID-VkVideoDecodeCapabilitiesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR", "1.3-extensions"}, @@ -6620,7 +6754,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkVideoDecodeH265SessionParametersCreateInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR", "1.3-extensions"}, {"VUID-VkVideoDecodeInfoKHR-dstPictureResource-parameter", "dstPictureResource must be a valid VkVideoPictureResourceInfoKHR structure", "1.3-extensions"}, {"VUID-VkVideoDecodeInfoKHR-flags-zerobitmask", "flags must be 0", "1.3-extensions"}, - {"VUID-VkVideoDecodeInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeH264PictureInfoKHR or VkVideoDecodeH265PictureInfoKHR", "1.3-extensions"}, + {"VUID-VkVideoDecodeInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeH264PictureInfoKHR, VkVideoDecodeH265PictureInfoKHR, or VkVideoInlineQueryInfoKHR", "1.3-extensions"}, {"VUID-VkVideoDecodeInfoKHR-pPictureResource-07172", "The pPictureResource member of each element of pReferenceSlots must not be NULL", "1.3-extensions"}, {"VUID-VkVideoDecodeInfoKHR-pReferenceSlots-parameter", "If referenceSlotCount is not 0, pReferenceSlots must be a valid pointer to an array of referenceSlotCount valid VkVideoReferenceSlotInfoKHR structures", "1.3-extensions"}, {"VUID-VkVideoDecodeInfoKHR-pSetupReferenceSlot-07168", "If pSetupReferenceSlot is not NULL, then its slotIndex member must not be negative", "1.3-extensions"}, @@ -6636,100 +6770,144 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkVideoDecodeUsageInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR", "1.3-extensions"}, {"VUID-VkVideoDecodeUsageInfoKHR-videoUsageHints-parameter", "videoUsageHints must be a valid combination of VkVideoDecodeUsageFlagBitsKHR values", "1.3-extensions"}, {"VUID-VkVideoEncodeCapabilitiesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264CapabilitiesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264DpbSlotInfoEXT-pStdReferenceInfo-parameter", "pStdReferenceInfo must be a valid pointer to a valid StdVideoEncodeH264ReferenceInfo value", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264DpbSlotInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264GopRemainingFrameInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264NaluSliceInfoEXT-pNext-pNext", "pNext must be NULL", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264NaluSliceInfoEXT-pStdSliceHeader-parameter", "pStdSliceHeader must be a valid pointer to a valid StdVideoEncodeH264SliceHeader value", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264NaluSliceInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264PictureInfoEXT-naluSliceEntryCount-arraylength", "naluSliceEntryCount must be greater than 0", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264PictureInfoEXT-pNaluSliceEntries-parameter", "pNaluSliceEntries must be a valid pointer to an array of naluSliceEntryCount valid VkVideoEncodeH264NaluSliceInfoEXT structures", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264PictureInfoEXT-pStdPictureInfo-parameter", "pStdPictureInfo must be a valid pointer to a valid StdVideoEncodeH264PictureInfo value", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264PictureInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264ProfileInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264QualityLevelPropertiesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264RateControlInfoEXT-flags-parameter", "flags must be a valid combination of VkVideoEncodeH264RateControlFlagBitsEXT values", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264RateControlInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264RateControlLayerInfoEXT-maxFrameSize-parameter", "maxFrameSize must be a valid VkVideoEncodeH264FrameSizeEXT structure", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264RateControlLayerInfoEXT-maxQp-parameter", "maxQp must be a valid VkVideoEncodeH264QpEXT structure", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264RateControlLayerInfoEXT-minQp-parameter", "minQp must be a valid VkVideoEncodeH264QpEXT structure", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264RateControlLayerInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264SessionCreateInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264SessionParametersAddInfoEXT-None-04840", "Each entry to be added must have a unique, to the rest of the parameter array entries and the existing parameters in the Video Session Parameters Object that is being updated, SPS-PPS IDs", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264SessionParametersAddInfoEXT-None-04841", "Parameter entries that already exist in Video Session Parameters object with a particular SPS-PPS IDs cannot be replaced nor updated", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264SessionParametersAddInfoEXT-None-04842", "When creating a new object using a Video Session Parameters as a template, the array's parameters with the same SPS-PPS IDs as the ones from the template take precedence", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264SessionParametersAddInfoEXT-None-04843", "SPS/PPS parameters must comply with the limits specified in VkVideoSessionCreateInfoKHR during Video Session creation", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264SessionParametersAddInfoEXT-maxStdPPSCount-04839", "When the maxStdPPSCount number of parameters of type StdVideoH264PictureParameterSet in the Video Session Parameters object is reached, no additional parameters of that type can be added to the object. VK_ERROR_TOO_MANY_OBJECTS will be returned if an attempt is made to add additional data to this object at this point", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264SessionParametersAddInfoEXT-maxStdSPSCount-04838", "When the maxStdSPSCount number of parameters of type StdVideoH264SequenceParameterSet in the Video Session Parameters object is reached, no additional parameters of that type can be added to the object. VK_ERROR_TOO_MANY_OBJECTS will be returned if an attempt is made to add additional data to this object at this point", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264SessionParametersAddInfoEXT-pStdPPSs-parameter", "If stdPPSCount is not 0, and pStdPPSs is not NULL, pStdPPSs must be a valid pointer to an array of stdPPSCount StdVideoH264PictureParameterSet values", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264SessionParametersAddInfoEXT-pStdSPSs-parameter", "If stdSPSCount is not 0, and pStdSPSs is not NULL, pStdSPSs must be a valid pointer to an array of stdSPSCount StdVideoH264SequenceParameterSet values", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264SessionParametersAddInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264SessionParametersAddInfoEXT-stdSPSCount-04837", "The values of stdSPSCount and stdPPSCount must be less than or equal to the values of maxStdSPSCount and maxStdPPSCount, respectively", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264SessionParametersCreateInfoEXT-pParametersAddInfo-parameter", "If pParametersAddInfo is not NULL, pParametersAddInfo must be a valid pointer to a valid VkVideoEncodeH264SessionParametersAddInfoEXT structure", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264SessionParametersCreateInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264SessionParametersFeedbackInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH264SessionParametersGetInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265CapabilitiesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265DpbSlotInfoEXT-pStdReferenceInfo-parameter", "pStdReferenceInfo must be a valid pointer to a valid StdVideoEncodeH265ReferenceInfo value", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265DpbSlotInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265GopRemainingFrameInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265NaluSliceSegmentInfoEXT-pNext-pNext", "pNext must be NULL", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265NaluSliceSegmentInfoEXT-pStdSliceSegmentHeader-parameter", "pStdSliceSegmentHeader must be a valid pointer to a valid StdVideoEncodeH265SliceSegmentHeader value", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265NaluSliceSegmentInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265PictureInfoEXT-naluSliceSegmentEntryCount-arraylength", "naluSliceSegmentEntryCount must be greater than 0", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265PictureInfoEXT-pNaluSliceSegmentEntries-parameter", "pNaluSliceSegmentEntries must be a valid pointer to an array of naluSliceSegmentEntryCount valid VkVideoEncodeH265NaluSliceSegmentInfoEXT structures", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265PictureInfoEXT-pStdPictureInfo-parameter", "pStdPictureInfo must be a valid pointer to a valid StdVideoEncodeH265PictureInfo value", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265PictureInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265ProfileInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265QualityLevelPropertiesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265RateControlInfoEXT-flags-parameter", "flags must be a valid combination of VkVideoEncodeH265RateControlFlagBitsEXT values", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265RateControlInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265RateControlLayerInfoEXT-maxFrameSize-parameter", "maxFrameSize must be a valid VkVideoEncodeH265FrameSizeEXT structure", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265RateControlLayerInfoEXT-maxQp-parameter", "maxQp must be a valid VkVideoEncodeH265QpEXT structure", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265RateControlLayerInfoEXT-minQp-parameter", "minQp must be a valid VkVideoEncodeH265QpEXT structure", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265RateControlLayerInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265SessionCreateInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-None-06442", "Each entry to be added must have a unique, to the rest of the parameter array entries and the existing parameters in the Video Session Parameters Object that is being updated, VPS-SPS-PPS IDs", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-None-06443", "Parameter entries that already exist in Video Session Parameters object with a particular VPS-SPS-PPS IDs must not be replaced nor updated", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-None-06444", "When creating a new object using a Video Session Parameters as a template, the array's parameters with the same VPS-SPS-PPS IDs as the ones from the template take precedence", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-None-06445", "VPS/SPS/PPS parameters must comply with the limits specified in VkVideoSessionCreateInfoKHR during Video Session creation", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-pStdPPSs-06441", "Each StdVideoH265PictureParameterSet entry in pStdPPSs must have a unique H.265 VPS-SPS-PPS ID tuple", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-pStdPPSs-parameter", "If stdPPSCount is not 0, and pStdPPSs is not NULL, pStdPPSs must be a valid pointer to an array of stdPPSCount StdVideoH265PictureParameterSet values", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-pStdSPSs-06440", "Each StdVideoH265SequenceParameterSet entry in pStdSPSs must have a unique H.265 VPS-SPS ID pair", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-pStdSPSs-parameter", "If stdSPSCount is not 0, and pStdSPSs is not NULL, pStdSPSs must be a valid pointer to an array of stdSPSCount StdVideoH265SequenceParameterSet values", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-pStdVPSs-06439", "Each StdVideoH265VideoParameterSet entry in pStdVPSs must have a unique H.265 VPS ID", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-pStdVPSs-parameter", "If stdVPSCount is not 0, and pStdVPSs is not NULL, pStdVPSs must be a valid pointer to an array of stdVPSCount StdVideoH265VideoParameterSet values", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-stdVPSCount-06438", "The values of stdVPSCount, stdSPSCount and stdPPSCount must be less than or equal to the values of VkVideoEncodeH265SessionParametersCreateInfoEXT::maxStdVPSCount, VkVideoEncodeH265SessionParametersCreateInfoEXT:maxStdSPSCount, and VkVideoEncodeH265SessionParametersCreateInfoEXT:maxStdPPSCount, respectively", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265SessionParametersCreateInfoEXT-pParametersAddInfo-parameter", "If pParametersAddInfo is not NULL, pParametersAddInfo must be a valid pointer to a valid VkVideoEncodeH265SessionParametersAddInfoEXT structure", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265SessionParametersCreateInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265SessionParametersFeedbackInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeH265SessionParametersGetInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT", "1.3-extensions"}, - {"VUID-VkVideoEncodeInfoKHR-None-07012", "The bound video session must not be in uninitialized state at the time the command is executed on the device", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264CapabilitiesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264DpbSlotInfoKHR-pStdReferenceInfo-parameter", "pStdReferenceInfo must be a valid pointer to a valid StdVideoEncodeH264ReferenceInfo value", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264DpbSlotInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264GopRemainingFrameInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264NaluSliceInfoKHR-pNext-pNext", "pNext must be NULL", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264NaluSliceInfoKHR-pStdSliceHeader-parameter", "pStdSliceHeader must be a valid pointer to a valid StdVideoEncodeH264SliceHeader value", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264NaluSliceInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264PictureInfoKHR-flags-08304", "If VkVideoEncodeH264CapabilitiesKHR::flags, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile, does not include VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR, then generatePrefixNalu must be VK_FALSE", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264PictureInfoKHR-flags-08314", "If VkVideoEncodeH264CapabilitiesKHR::flags, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile, does not include VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR and the slice corresponding to any element of pNaluSliceEntries uses explicit weighted sample prediction, then VkVideoEncodeH264NaluSliceInfoKHR::pStdSliceHeader->pWeightTable must not be NULL for that element of pNaluSliceEntries", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264PictureInfoKHR-flags-08315", "If VkVideoEncodeH264CapabilitiesKHR::flags, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile, does not include VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR, then VkVideoEncodeH264NaluSliceInfoKHR::pStdSliceHeader->slice_type must be identical for all elements of pNaluSliceEntries", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264PictureInfoKHR-naluSliceEntryCount-08301", "naluSliceEntryCount must be between 1 and VkVideoEncodeH264CapabilitiesKHR::maxSliceCount, inclusive, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264PictureInfoKHR-naluSliceEntryCount-arraylength", "naluSliceEntryCount must be greater than 0", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264PictureInfoKHR-pNaluSliceEntries-parameter", "pNaluSliceEntries must be a valid pointer to an array of naluSliceEntryCount valid VkVideoEncodeH264NaluSliceInfoKHR structures", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264PictureInfoKHR-pStdPictureInfo-parameter", "pStdPictureInfo must be a valid pointer to a valid StdVideoEncodeH264PictureInfo value", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264PictureInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264ProfileInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264QualityLevelPropertiesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264RateControlInfoKHR-consecutiveBFrameCount-08285", "If consecutiveBFrameCount is not 0, then it must be less than gopFrameCount", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264RateControlInfoKHR-flags-08280", "If VkVideoEncodeH264CapabilitiesKHR::flags, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile, does not include VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR, then flags must not contain VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264RateControlInfoKHR-flags-08281", "If flags contains VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR or VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR, then it must also contain VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264RateControlInfoKHR-flags-08282", "If flags contains VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR, then it must not also contain VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264RateControlInfoKHR-flags-08283", "If flags contains VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR, then gopFrameCount must be greater than 0", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264RateControlInfoKHR-flags-parameter", "flags must be a valid combination of VkVideoEncodeH264RateControlFlagBitsKHR values", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264RateControlInfoKHR-idrPeriod-08284", "If idrPeriod is not 0, then it must be greater than or equal to gopFrameCount", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264RateControlInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264RateControlLayerInfoKHR-maxFrameSize-parameter", "maxFrameSize must be a valid VkVideoEncodeH264FrameSizeKHR structure", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264RateControlLayerInfoKHR-maxQp-parameter", "maxQp must be a valid VkVideoEncodeH264QpKHR structure", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264RateControlLayerInfoKHR-minQp-parameter", "minQp must be a valid VkVideoEncodeH264QpKHR structure", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264RateControlLayerInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264RateControlLayerInfoKHR-useMaxQp-08287", "If useMaxQp is VK_TRUE, then the qpI, qpP, and qpB members of maxQp must all be between VkVideoEncodeH264CapabilitiesKHR::minQp and VkVideoEncodeH264CapabilitiesKHR::maxQp, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264RateControlLayerInfoKHR-useMaxQp-08289", "If useMaxQp is VK_TRUE and VkVideoEncodeH264CapabilitiesKHR::flags, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile, does not include VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR, then the qpI, qpP, and qpB members of maxQp must all specify the same value", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264RateControlLayerInfoKHR-useMinQp-08286", "If useMinQp is VK_TRUE, then the qpI, qpP, and qpB members of minQp must all be between VkVideoEncodeH264CapabilitiesKHR::minQp and VkVideoEncodeH264CapabilitiesKHR::maxQp, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264RateControlLayerInfoKHR-useMinQp-08288", "If useMinQp is VK_TRUE and VkVideoEncodeH264CapabilitiesKHR::flags, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile, does not include VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR, then the qpI, qpP, and qpB members of minQp must all specify the same value", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264RateControlLayerInfoKHR-useMinQp-08374", "If useMinQp and useMaxQp are both VK_TRUE, then the qpI, qpP, and qpB members of minQp must all be less than or equal to the respective members of maxQp", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264SessionCreateInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264SessionParametersAddInfoKHR-None-04837", "The seq_parameter_set_id member of each StdVideoH264SequenceParameterSet structure specified in the elements of pStdSPSs must be unique within pStdSPSs", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264SessionParametersAddInfoKHR-None-04838", "The pair constructed from the seq_parameter_set_id and pic_parameter_set_id members of each StdVideoH264PictureParameterSet structure specified in the elements of pStdPPSs must be unique within pStdPPSs", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264SessionParametersAddInfoKHR-pStdPPSs-parameter", "If stdPPSCount is not 0, and pStdPPSs is not NULL, pStdPPSs must be a valid pointer to an array of stdPPSCount StdVideoH264PictureParameterSet values", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264SessionParametersAddInfoKHR-pStdSPSs-parameter", "If stdSPSCount is not 0, and pStdSPSs is not NULL, pStdSPSs must be a valid pointer to an array of stdSPSCount StdVideoH264SequenceParameterSet values", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264SessionParametersAddInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264SessionParametersCreateInfoKHR-pParametersAddInfo-parameter", "If pParametersAddInfo is not NULL, pParametersAddInfo must be a valid pointer to a valid VkVideoEncodeH264SessionParametersAddInfoKHR structure", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264SessionParametersCreateInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264SessionParametersFeedbackInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264SessionParametersGetInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH264SessionParametersGetInfoKHR-writeStdSPS-08279", "At least one of writeStdSPS and writeStdPPS must be set to VK_TRUE", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265CapabilitiesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265DpbSlotInfoKHR-pStdReferenceInfo-parameter", "pStdReferenceInfo must be a valid pointer to a valid StdVideoEncodeH265ReferenceInfo value", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265DpbSlotInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265GopRemainingFrameInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265NaluSliceSegmentInfoKHR-pNext-pNext", "pNext must be NULL", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265NaluSliceSegmentInfoKHR-pStdSliceSegmentHeader-parameter", "pStdSliceSegmentHeader must be a valid pointer to a valid StdVideoEncodeH265SliceSegmentHeader value", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265NaluSliceSegmentInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265PictureInfoKHR-flags-08316", "If VkVideoEncodeH265CapabilitiesKHR::flags, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile, does not include VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR and the slice segment corresponding to any element of pNaluSliceSegmentEntries uses explicit weighted sample prediction, then VkVideoEncodeH265NaluSliceSegmentInfoKHR::pStdSliceSegmentHeader->pWeightTable must not be NULL for that element of pNaluSliceSegmentEntries", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265PictureInfoKHR-flags-08317", "If VkVideoEncodeH265CapabilitiesKHR::flags, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile, does not include VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR, then VkVideoEncodeH265NaluSliceSegmentInfoKHR::pStdSliceSegmentHeader->slice_type must be identical for all elements of pNaluSliceSegmentEntries", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265PictureInfoKHR-flags-08323", "If VkVideoEncodeH265CapabilitiesKHR::flags, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile, does not include VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR, then naluSliceSegmentEntryCount must be greater than or equal to the number of H.265 tiles in the picture", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265PictureInfoKHR-flags-08324", "If VkVideoEncodeH265CapabilitiesKHR::flags, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile, does not include VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR, then naluSliceSegmentEntryCount must be less than or equal to the number of H.265 tiles in the picture", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265PictureInfoKHR-naluSliceSegmentEntryCount-08306", "naluSliceSegmentEntryCount must be between 1 and VkVideoEncodeH265CapabilitiesKHR::maxSliceSegmentCount, inclusive, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265PictureInfoKHR-naluSliceSegmentEntryCount-arraylength", "naluSliceSegmentEntryCount must be greater than 0", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265PictureInfoKHR-pNaluSliceSegmentEntries-parameter", "pNaluSliceSegmentEntries must be a valid pointer to an array of naluSliceSegmentEntryCount valid VkVideoEncodeH265NaluSliceSegmentInfoKHR structures", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265PictureInfoKHR-pStdPictureInfo-parameter", "pStdPictureInfo must be a valid pointer to a valid StdVideoEncodeH265PictureInfo value", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265PictureInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265ProfileInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265QualityLevelPropertiesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265RateControlInfoKHR-consecutiveBFrameCount-08296", "If consecutiveBFrameCount is not 0, then it must be less than gopFrameCount", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265RateControlInfoKHR-flags-08291", "If VkVideoEncodeH265CapabilitiesKHR::flags, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile, does not include VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR, then flags must not contain VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265RateControlInfoKHR-flags-08292", "If flags contains VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR or VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR, then it must also contain VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265RateControlInfoKHR-flags-08293", "If flags contains VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR, then it must not also contain VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265RateControlInfoKHR-flags-08294", "If flags contains VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR, then gopFrameCount must be greater than 0", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265RateControlInfoKHR-flags-parameter", "flags must be a valid combination of VkVideoEncodeH265RateControlFlagBitsKHR values", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265RateControlInfoKHR-idrPeriod-08295", "If idrPeriod is not 0, then it must be greater than or equal to gopFrameCount", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265RateControlInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265RateControlLayerInfoKHR-maxFrameSize-parameter", "maxFrameSize must be a valid VkVideoEncodeH265FrameSizeKHR structure", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265RateControlLayerInfoKHR-maxQp-parameter", "maxQp must be a valid VkVideoEncodeH265QpKHR structure", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265RateControlLayerInfoKHR-minQp-parameter", "minQp must be a valid VkVideoEncodeH265QpKHR structure", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265RateControlLayerInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265RateControlLayerInfoKHR-useMaxQp-08298", "If useMaxQp is VK_TRUE, then the qpI, qpP, and qpB members of maxQp must all be between VkVideoEncodeH265CapabilitiesKHR::minQp and VkVideoEncodeH265CapabilitiesKHR::maxQp, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265RateControlLayerInfoKHR-useMaxQp-08300", "If useMaxQp is VK_TRUE and VkVideoEncodeH265CapabilitiesKHR::flags, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile, does not include VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR, then the qpI, qpP, and qpB members of maxQp must all specify the same value", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265RateControlLayerInfoKHR-useMinQp-08297", "If useMinQp is VK_TRUE, then the qpI, qpP, and qpB members of minQp must all be between VkVideoEncodeH265CapabilitiesKHR::minQp and VkVideoEncodeH265CapabilitiesKHR::maxQp, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265RateControlLayerInfoKHR-useMinQp-08299", "If useMinQp is VK_TRUE and VkVideoEncodeH265CapabilitiesKHR::flags, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile, does not include VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR, then the qpI, qpP, and qpB members of minQp must all specify the same value", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265RateControlLayerInfoKHR-useMinQp-08375", "If useMinQp and useMaxQp are both VK_TRUE, then the qpI, qpP, and qpB members of minQp must all be less than or equal to the respective members of maxQp", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265SessionCreateInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265SessionParametersAddInfoKHR-None-06438", "The vps_video_parameter_set_id member of each StdVideoH265VideoParameterSet structure specified in the elements of pStdVPSs must be unique within pStdVPSs", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265SessionParametersAddInfoKHR-None-06439", "The pair constructed from the sps_video_parameter_set_id and sps_seq_parameter_set_id members of each StdVideoH265SequenceParameterSet structure specified in the elements of pStdSPSs must be unique within pStdSPSs", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265SessionParametersAddInfoKHR-None-06440", "The triplet constructed from the sps_video_parameter_set_id, pps_seq_parameter_set_id, and pps_pic_parameter_set_id members of each StdVideoH265PictureParameterSet structure specified in the elements of pStdPPSs must be unique within pStdPPSs", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265SessionParametersAddInfoKHR-pStdPPSs-parameter", "If stdPPSCount is not 0, and pStdPPSs is not NULL, pStdPPSs must be a valid pointer to an array of stdPPSCount StdVideoH265PictureParameterSet values", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265SessionParametersAddInfoKHR-pStdSPSs-parameter", "If stdSPSCount is not 0, and pStdSPSs is not NULL, pStdSPSs must be a valid pointer to an array of stdSPSCount StdVideoH265SequenceParameterSet values", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265SessionParametersAddInfoKHR-pStdVPSs-parameter", "If stdVPSCount is not 0, and pStdVPSs is not NULL, pStdVPSs must be a valid pointer to an array of stdVPSCount StdVideoH265VideoParameterSet values", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265SessionParametersAddInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265SessionParametersCreateInfoKHR-pParametersAddInfo-parameter", "If pParametersAddInfo is not NULL, pParametersAddInfo must be a valid pointer to a valid VkVideoEncodeH265SessionParametersAddInfoKHR structure", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265SessionParametersCreateInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265SessionParametersFeedbackInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265SessionParametersGetInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeH265SessionParametersGetInfoKHR-writeStdVPS-08290", "At least one of writeStdVPS, writeStdSPS, and writeStdPPS must be set to VK_TRUE", "1.3-extensions"}, + {"VUID-VkVideoEncodeInfoKHR-dstBuffer-08236", "dstBuffer must have been created with VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR set", "1.3-extensions"}, {"VUID-VkVideoEncodeInfoKHR-dstBuffer-parameter", "dstBuffer must be a valid VkBuffer handle", "1.3-extensions"}, + {"VUID-VkVideoEncodeInfoKHR-dstBufferOffset-08237", "dstBufferOffset must be less than the size of dstBuffer", "1.3-extensions"}, + {"VUID-VkVideoEncodeInfoKHR-dstBufferRange-08238", "dstBufferRange must be less than or equal to the size of dstBuffer minus dstBufferOffset", "1.3-extensions"}, {"VUID-VkVideoEncodeInfoKHR-flags-zerobitmask", "flags must be 0", "1.3-extensions"}, - {"VUID-VkVideoEncodeInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264PictureInfoEXT or VkVideoEncodeH265PictureInfoEXT", "1.3-extensions"}, + {"VUID-VkVideoEncodeInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264PictureInfoKHR, VkVideoEncodeH265PictureInfoKHR, or VkVideoInlineQueryInfoKHR", "1.3-extensions"}, + {"VUID-VkVideoEncodeInfoKHR-pPictureResource-08242", "The pPictureResource member of each element of pReferenceSlots must not be NULL", "1.3-extensions"}, {"VUID-VkVideoEncodeInfoKHR-pReferenceSlots-parameter", "If referenceSlotCount is not 0, pReferenceSlots must be a valid pointer to an array of referenceSlotCount valid VkVideoReferenceSlotInfoKHR structures", "1.3-extensions"}, + {"VUID-VkVideoEncodeInfoKHR-pSetupReferenceSlot-08239", "If pSetupReferenceSlot is not NULL, then its slotIndex member must not be negative", "1.3-extensions"}, + {"VUID-VkVideoEncodeInfoKHR-pSetupReferenceSlot-08240", "If pSetupReferenceSlot is not NULL, then its pPictureResource must not be NULL", "1.3-extensions"}, {"VUID-VkVideoEncodeInfoKHR-pSetupReferenceSlot-parameter", "If pSetupReferenceSlot is not NULL, pSetupReferenceSlot must be a valid pointer to a valid VkVideoReferenceSlotInfoKHR structure", "1.3-extensions"}, {"VUID-VkVideoEncodeInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR", "1.3-extensions"}, {"VUID-VkVideoEncodeInfoKHR-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, + {"VUID-VkVideoEncodeInfoKHR-slotIndex-08241", "The slotIndex member of each element of pReferenceSlots must not be negative", "1.3-extensions"}, {"VUID-VkVideoEncodeInfoKHR-srcPictureResource-parameter", "srcPictureResource must be a valid VkVideoPictureResourceInfoKHR structure", "1.3-extensions"}, + {"VUID-VkVideoEncodeQualityLevelInfoKHR-qualityLevel-08311", "qualityLevel must be less than VkVideoEncodeCapabilitiesKHR::maxQualityLevels, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile", "1.3-extensions"}, {"VUID-VkVideoEncodeQualityLevelInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR", "1.3-extensions"}, - {"VUID-VkVideoEncodeQualityLevelPropertiesKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264QualityLevelPropertiesEXT or VkVideoEncodeH265QualityLevelPropertiesEXT", "1.3-extensions"}, + {"VUID-VkVideoEncodeQualityLevelPropertiesKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264QualityLevelPropertiesKHR or VkVideoEncodeH265QualityLevelPropertiesKHR", "1.3-extensions"}, {"VUID-VkVideoEncodeQualityLevelPropertiesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR", "1.3-extensions"}, {"VUID-VkVideoEncodeQualityLevelPropertiesKHR-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, {"VUID-VkVideoEncodeRateControlInfoKHR-flags-zerobitmask", "flags must be 0", "1.3-extensions"}, + {"VUID-VkVideoEncodeRateControlInfoKHR-layerCount-08245", "layerCount member must be less than or equal to VkVideoEncodeCapabilitiesKHR::maxRateControlLayers, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile", "1.3-extensions"}, + {"VUID-VkVideoEncodeRateControlInfoKHR-layerCount-08357", "If layerCount is not zero, then virtualBufferSizeInMs must be greater than zero", "1.3-extensions"}, + {"VUID-VkVideoEncodeRateControlInfoKHR-layerCount-08358", "If layerCount is not zero, then initialVirtualBufferSizeInMs must be less than virtualBufferSizeInMs", "1.3-extensions"}, + {"VUID-VkVideoEncodeRateControlInfoKHR-pLayers-08276", "For each element of pLayers, its averageBitrate member must be between 1 and VkVideoEncodeCapabilitiesKHR::maxBitrate, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile", "1.3-extensions"}, + {"VUID-VkVideoEncodeRateControlInfoKHR-pLayers-08277", "For each element of pLayers, its maxBitrate member must be between 1 and VkVideoEncodeCapabilitiesKHR::maxBitrate, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile", "1.3-extensions"}, {"VUID-VkVideoEncodeRateControlInfoKHR-pLayers-parameter", "If layerCount is not 0, pLayers must be a valid pointer to an array of layerCount valid VkVideoEncodeRateControlLayerInfoKHR structures", "1.3-extensions"}, + {"VUID-VkVideoEncodeRateControlInfoKHR-rateControlMode-08244", "If rateControlMode is not VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR, then it must specify one of the bits included in VkVideoEncodeCapabilitiesKHR::rateControlModes, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the used video profile", "1.3-extensions"}, + {"VUID-VkVideoEncodeRateControlInfoKHR-rateControlMode-08248", "If rateControlMode is VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR or VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR, then layerCount must be 0", "1.3-extensions"}, + {"VUID-VkVideoEncodeRateControlInfoKHR-rateControlMode-08275", "If rateControlMode is VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR or VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR, then layerCount must be greater than 0", "1.3-extensions"}, + {"VUID-VkVideoEncodeRateControlInfoKHR-rateControlMode-08278", "If rateControlMode is VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR, then for each element of pLayers, its averageBitrate member must be less than or equal to its maxBitrate member", "1.3-extensions"}, + {"VUID-VkVideoEncodeRateControlInfoKHR-rateControlMode-08356", "If rateControlMode is VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR, then for each element of pLayers, its averageBitrate member must equal its maxBitrate member", "1.3-extensions"}, {"VUID-VkVideoEncodeRateControlInfoKHR-rateControlMode-parameter", "If rateControlMode is not 0, rateControlMode must be a valid VkVideoEncodeRateControlModeFlagBitsKHR value", "1.3-extensions"}, {"VUID-VkVideoEncodeRateControlInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR", "1.3-extensions"}, - {"VUID-VkVideoEncodeRateControlLayerInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264RateControlLayerInfoEXT or VkVideoEncodeH265RateControlLayerInfoEXT", "1.3-extensions"}, + {"VUID-VkVideoEncodeRateControlInfoKHR-videoCodecOperation-07022", "If the videoCodecOperation of the used video profile is VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, the pNext chain this structure is included in also includes an instance of the VkVideoEncodeH264RateControlInfoKHR structure, and layerCount is greater than 1, then layerCount must equal VkVideoEncodeH264RateControlInfoKHR::temporalLayerCount", "1.3-extensions"}, + {"VUID-VkVideoEncodeRateControlInfoKHR-videoCodecOperation-07025", "If the videoCodecOperation of the used video profile is VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, the pNext chain this structure is included in also includes an instance of the VkVideoEncodeH265RateControlInfoKHR structure, and layerCount is greater than 1, then layerCount must equal VkVideoEncodeH265RateControlInfoKHR::subLayerCount", "1.3-extensions"}, + {"VUID-VkVideoEncodeRateControlLayerInfoKHR-frameRateDenominator-08351", "frameRateDenominator must be greater than zero", "1.3-extensions"}, + {"VUID-VkVideoEncodeRateControlLayerInfoKHR-frameRateNumerator-08350", "frameRateNumerator must be greater than zero", "1.3-extensions"}, + {"VUID-VkVideoEncodeRateControlLayerInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264RateControlLayerInfoKHR or VkVideoEncodeH265RateControlLayerInfoKHR", "1.3-extensions"}, {"VUID-VkVideoEncodeRateControlLayerInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR", "1.3-extensions"}, {"VUID-VkVideoEncodeRateControlLayerInfoKHR-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, - {"VUID-VkVideoEncodeSessionParametersFeedbackInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264SessionParametersFeedbackInfoEXT or VkVideoEncodeH265SessionParametersFeedbackInfoEXT", "1.3-extensions"}, + {"VUID-VkVideoEncodeSessionParametersFeedbackInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264SessionParametersFeedbackInfoKHR or VkVideoEncodeH265SessionParametersFeedbackInfoKHR", "1.3-extensions"}, {"VUID-VkVideoEncodeSessionParametersFeedbackInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR", "1.3-extensions"}, {"VUID-VkVideoEncodeSessionParametersFeedbackInfoKHR-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, - {"VUID-VkVideoEncodeSessionParametersGetInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264SessionParametersGetInfoEXT or VkVideoEncodeH265SessionParametersGetInfoEXT", "1.3-extensions"}, + {"VUID-VkVideoEncodeSessionParametersGetInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264SessionParametersGetInfoKHR or VkVideoEncodeH265SessionParametersGetInfoKHR", "1.3-extensions"}, {"VUID-VkVideoEncodeSessionParametersGetInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR", "1.3-extensions"}, {"VUID-VkVideoEncodeSessionParametersGetInfoKHR-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, {"VUID-VkVideoEncodeSessionParametersGetInfoKHR-videoSessionParameters-parameter", "videoSessionParameters must be a valid VkVideoSessionParametersKHR handle", "1.3-extensions"}, @@ -6742,6 +6920,10 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkVideoEndCodingInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR", "1.3-extensions"}, {"VUID-VkVideoFormatPropertiesKHR-pNext-pNext", "pNext must be NULL", "1.3-extensions"}, {"VUID-VkVideoFormatPropertiesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR", "1.3-extensions"}, + {"VUID-VkVideoInlineQueryInfoKHR-queryPool-08372", "If queryPool is not VK_NULL_HANDLE, then firstQuery must be less than the number of queries in queryPool", "1.3-extensions"}, + {"VUID-VkVideoInlineQueryInfoKHR-queryPool-08373", "If queryPool is not VK_NULL_HANDLE, then the sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool", "1.3-extensions"}, + {"VUID-VkVideoInlineQueryInfoKHR-queryPool-parameter", "If queryPool is not VK_NULL_HANDLE, queryPool must be a valid VkQueryPool handle", "1.3-extensions"}, + {"VUID-VkVideoInlineQueryInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR", "1.3-extensions"}, {"VUID-VkVideoPictureResourceInfoKHR-baseArrayLayer-07175", "baseArrayLayer must be less than the VkImageViewCreateInfo::subresourceRange.layerCount specified when the image view imageViewBinding was created", "1.3-extensions"}, {"VUID-VkVideoPictureResourceInfoKHR-imageViewBinding-parameter", "imageViewBinding must be a valid VkImageView handle", "1.3-extensions"}, {"VUID-VkVideoPictureResourceInfoKHR-pNext-pNext", "pNext must be NULL", "1.3-extensions"}, @@ -6757,26 +6939,29 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkVideoProfileInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR", "1.3-extensions"}, {"VUID-VkVideoProfileInfoKHR-videoCodecOperation-07179", "If videoCodecOperation is VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR, then the pNext chain must include a VkVideoDecodeH264ProfileInfoKHR structure", "1.3-extensions"}, {"VUID-VkVideoProfileInfoKHR-videoCodecOperation-07180", "If videoCodecOperation is VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, then the pNext chain must include a VkVideoDecodeH265ProfileInfoKHR structure", "1.3-extensions"}, - {"VUID-VkVideoProfileInfoKHR-videoCodecOperation-07181", "If videoCodecOperation is VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT, then the pNext chain must include a VkVideoEncodeH264ProfileInfoEXT structure", "1.3-extensions"}, - {"VUID-VkVideoProfileInfoKHR-videoCodecOperation-07182", "If videoCodecOperation is VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT, then the pNext chain must include a VkVideoEncodeH265ProfileInfoEXT structure", "1.3-extensions"}, + {"VUID-VkVideoProfileInfoKHR-videoCodecOperation-07181", "If videoCodecOperation is VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then the pNext chain must include a VkVideoEncodeH264ProfileInfoKHR structure", "1.3-extensions"}, + {"VUID-VkVideoProfileInfoKHR-videoCodecOperation-07182", "If videoCodecOperation is VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then the pNext chain must include a VkVideoEncodeH265ProfileInfoKHR structure", "1.3-extensions"}, {"VUID-VkVideoProfileInfoKHR-videoCodecOperation-parameter", "videoCodecOperation must be a valid VkVideoCodecOperationFlagBitsKHR value", "1.3-extensions"}, {"VUID-VkVideoProfileListInfoKHR-pProfiles-06813", "pProfiles must not contain more than one element whose videoCodecOperation member specifies a decode operation", "1.3-extensions"}, {"VUID-VkVideoProfileListInfoKHR-pProfiles-parameter", "If profileCount is not 0, pProfiles must be a valid pointer to an array of profileCount valid VkVideoProfileInfoKHR structures", "1.3-extensions"}, {"VUID-VkVideoProfileListInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR", "1.3-extensions"}, - {"VUID-VkVideoReferenceSlotInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeH264DpbSlotInfoKHR, VkVideoDecodeH265DpbSlotInfoKHR, VkVideoEncodeH264DpbSlotInfoEXT, or VkVideoEncodeH265DpbSlotInfoEXT", "1.3-extensions"}, + {"VUID-VkVideoReferenceSlotInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeH264DpbSlotInfoKHR, VkVideoDecodeH265DpbSlotInfoKHR, VkVideoEncodeH264DpbSlotInfoKHR, or VkVideoEncodeH265DpbSlotInfoKHR", "1.3-extensions"}, {"VUID-VkVideoReferenceSlotInfoKHR-pPictureResource-parameter", "If pPictureResource is not NULL, pPictureResource must be a valid pointer to a valid VkVideoPictureResourceInfoKHR structure", "1.3-extensions"}, {"VUID-VkVideoReferenceSlotInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR", "1.3-extensions"}, {"VUID-VkVideoReferenceSlotInfoKHR-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, + {"VUID-VkVideoSessionCreateInfoKHR-flags-08371", "If flags includes VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR, then videoMaintenance1 must be enabled", "1.3-extensions"}, {"VUID-VkVideoSessionCreateInfoKHR-flags-parameter", "flags must be a valid combination of VkVideoSessionCreateFlagBitsKHR values", "1.3-extensions"}, {"VUID-VkVideoSessionCreateInfoKHR-maxActiveReferencePictures-04849", "maxActiveReferencePictures must be less than or equal to VkVideoCapabilitiesKHR::maxActiveReferencePictures, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile specified by pVideoProfile", "1.3-extensions"}, {"VUID-VkVideoSessionCreateInfoKHR-maxCodedExtent-04851", "maxCodedExtent must be between VkVideoCapabilitiesKHR::minCodedExtent and VkVideoCapabilitiesKHR::maxCodedExtent, inclusive, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile specified by pVideoProfile", "1.3-extensions"}, {"VUID-VkVideoSessionCreateInfoKHR-maxDpbSlots-04847", "maxDpbSlots must be less than or equal to VkVideoCapabilitiesKHR::maxDpbSlots, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile specified by pVideoProfile", "1.3-extensions"}, {"VUID-VkVideoSessionCreateInfoKHR-maxDpbSlots-04850", "If either maxDpbSlots or maxActiveReferencePictures is 0, then both must be 0", "1.3-extensions"}, - {"VUID-VkVideoSessionCreateInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264SessionCreateInfoEXT or VkVideoEncodeH265SessionCreateInfoEXT", "1.3-extensions"}, + {"VUID-VkVideoSessionCreateInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264SessionCreateInfoKHR or VkVideoEncodeH265SessionCreateInfoKHR", "1.3-extensions"}, {"VUID-VkVideoSessionCreateInfoKHR-pStdHeaderVersion-07190", "pStdHeaderVersion->extensionName must match VkVideoCapabilitiesKHR::stdHeaderVersion.extensionName, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile specified by pVideoProfile", "1.3-extensions"}, {"VUID-VkVideoSessionCreateInfoKHR-pStdHeaderVersion-07191", "pStdHeaderVersion->specVersion must be less than or equal to VkVideoCapabilitiesKHR::stdHeaderVersion.specVersion, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile specified by pVideoProfile", "1.3-extensions"}, {"VUID-VkVideoSessionCreateInfoKHR-pStdHeaderVersion-parameter", "pStdHeaderVersion must be a valid pointer to a valid VkExtensionProperties structure", "1.3-extensions"}, {"VUID-VkVideoSessionCreateInfoKHR-pVideoProfile-04845", "pVideoProfile must be a supported video profile", "1.3-extensions"}, + {"VUID-VkVideoSessionCreateInfoKHR-pVideoProfile-08251", "If pVideoProfile->videoCodecOperation is VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR and the pNext chain of this structure includes a VkVideoEncodeH264SessionCreateInfoKHR structure, then its maxLevelIdc member must be less than or equal to VkVideoEncodeH264CapabilitiesKHR::maxLevelIdc, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile specified in pVideoProfile", "1.3-extensions"}, + {"VUID-VkVideoSessionCreateInfoKHR-pVideoProfile-08252", "If pVideoProfile->videoCodecOperation is VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR and the pNext chain of this structure includes a VkVideoEncodeH265SessionCreateInfoKHR structure, then its maxLevelIdc member must be less than or equal to VkVideoEncodeH265CapabilitiesKHR::maxLevelIdc, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile specified in pVideoProfile", "1.3-extensions"}, {"VUID-VkVideoSessionCreateInfoKHR-pVideoProfile-parameter", "pVideoProfile must be a valid pointer to a valid VkVideoProfileInfoKHR structure", "1.3-extensions"}, {"VUID-VkVideoSessionCreateInfoKHR-pictureFormat-04853", "If pVideoProfile->videoCodecOperation specifies a decode operation, then pictureFormat must be one of the supported decode output formats, as returned by vkGetPhysicalDeviceVideoFormatPropertiesKHR in VkVideoFormatPropertiesKHR::format when called with the imageUsage member of its pVideoFormatInfo parameter containing VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR, and with a VkVideoProfileListInfoKHR structure specified in the pNext chain of its pVideoFormatInfo parameter whose pProfiles member contains an element matching pVideoProfile", "1.3-extensions"}, {"VUID-VkVideoSessionCreateInfoKHR-pictureFormat-04854", "If pVideoProfile->videoCodecOperation specifies an encode operation, then pictureFormat must be one of the supported encode input formats, as returned by vkGetPhysicalDeviceVideoFormatPropertiesKHR in VkVideoFormatPropertiesKHR::format when called with the imageUsage member of its pVideoFormatInfo parameter containing VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, and with a VkVideoProfileListInfoKHR structure specified in the pNext chain of its pVideoFormatInfo parameter whose pProfiles member contains an element matching pVideoProfile", "1.3-extensions"}, @@ -6791,9 +6976,14 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkVideoSessionMemoryRequirementsKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR", "1.3-extensions"}, {"VUID-VkVideoSessionParametersCreateInfoKHR-commonparent", "Both of videoSession, and videoSessionParametersTemplate that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice", "1.3-extensions"}, {"VUID-VkVideoSessionParametersCreateInfoKHR-flags-zerobitmask", "flags must be 0", "1.3-extensions"}, - {"VUID-VkVideoSessionParametersCreateInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeH264SessionParametersCreateInfoKHR, VkVideoDecodeH265SessionParametersCreateInfoKHR, VkVideoEncodeH264SessionParametersCreateInfoEXT, VkVideoEncodeH265SessionParametersCreateInfoEXT, or VkVideoEncodeQualityLevelInfoKHR", "1.3-extensions"}, + {"VUID-VkVideoSessionParametersCreateInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeH264SessionParametersCreateInfoKHR, VkVideoDecodeH265SessionParametersCreateInfoKHR, VkVideoEncodeH264SessionParametersCreateInfoKHR, VkVideoEncodeH265SessionParametersCreateInfoKHR, or VkVideoEncodeQualityLevelInfoKHR", "1.3-extensions"}, {"VUID-VkVideoSessionParametersCreateInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR", "1.3-extensions"}, {"VUID-VkVideoSessionParametersCreateInfoKHR-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, + {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-04839", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then the number of elements of spsAddList must be less than or equal to the maxStdSPSCount specified in the VkVideoEncodeH264SessionParametersCreateInfoKHR structure included in the pNext chain", "1.3-extensions"}, + {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-04840", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then the number of elements of ppsAddList must be less than or equal to the maxStdPPSCount specified in the VkVideoEncodeH264SessionParametersCreateInfoKHR structure included in the pNext chain", "1.3-extensions"}, + {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-04841", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then the number of elements of vpsAddList must be less than or equal to the maxStdVPSCount specified in the VkVideoEncodeH265SessionParametersCreateInfoKHR structure included in the pNext chain", "1.3-extensions"}, + {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-04842", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then the number of elements of spsAddList must be less than or equal to the maxStdSPSCount specified in the VkVideoEncodeH265SessionParametersCreateInfoKHR structure included in the pNext chain", "1.3-extensions"}, + {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-04843", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then the number of elements of ppsAddList must be less than or equal to the maxStdPPSCount specified in the VkVideoEncodeH265SessionParametersCreateInfoKHR structure included in the pNext chain", "1.3-extensions"}, {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-07203", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR, then the pNext chain must include a VkVideoDecodeH264SessionParametersCreateInfoKHR structure", "1.3-extensions"}, {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-07204", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR, then the number of elements of spsAddList must be less than or equal to the maxStdSPSCount specified in the VkVideoDecodeH264SessionParametersCreateInfoKHR structure included in the pNext chain", "1.3-extensions"}, {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-07205", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR, then the number of elements of ppsAddList must be less than or equal to the maxStdPPSCount specified in the VkVideoDecodeH264SessionParametersCreateInfoKHR structure included in the pNext chain", "1.3-extensions"}, @@ -6801,13 +6991,16 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-07207", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, then the number of elements of vpsAddList must be less than or equal to the maxStdVPSCount specified in the VkVideoDecodeH265SessionParametersCreateInfoKHR structure included in the pNext chain", "1.3-extensions"}, {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-07208", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, then the number of elements of spsAddList must be less than or equal to the maxStdSPSCount specified in the VkVideoDecodeH265SessionParametersCreateInfoKHR structure included in the pNext chain", "1.3-extensions"}, {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-07209", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, then the number of elements of ppsAddList must be less than or equal to the maxStdPPSCount specified in the VkVideoDecodeH265SessionParametersCreateInfoKHR structure included in the pNext chain", "1.3-extensions"}, - {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-07210", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT, then the pNext chain must include a VkVideoEncodeH264SessionParametersCreateInfoEXT structure", "1.3-extensions"}, - {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-07211", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT, then the pNext chain must include a VkVideoEncodeH265SessionParametersCreateInfoEXT structure", "1.3-extensions"}, + {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-07210", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then the pNext chain must include a VkVideoEncodeH264SessionParametersCreateInfoKHR structure", "1.3-extensions"}, + {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-07211", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then the pNext chain must include a VkVideoEncodeH265SessionParametersCreateInfoKHR structure", "1.3-extensions"}, + {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-08319", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then num_tile_columns_minus1 must be less than VkVideoEncodeH265CapabilitiesKHR::maxTiles.width, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile videoSession was created with, for each element of ppsAddList", "1.3-extensions"}, + {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-08320", "If videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then num_tile_rows_minus1 must be less than VkVideoEncodeH265CapabilitiesKHR::maxTiles.height, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile videoSession was created with, for each element of ppsAddList", "1.3-extensions"}, {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSession-parameter", "videoSession must be a valid VkVideoSessionKHR handle", "1.3-extensions"}, - {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSessionParametersTemplate-04855", "If videoSessionParametersTemplate represents a valid handle, it must have been created against videoSession", "1.3-extensions"}, + {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSessionParametersTemplate-04855", "If videoSessionParametersTemplate is not VK_NULL_HANDLE, it must have been created against videoSession", "1.3-extensions"}, + {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSessionParametersTemplate-08310", "If videoSessionParametersTemplate is not VK_NULL_HANDLE and videoSession was created with an encode operation, then qualityLevel must equal the video encode quality level videoSessionParametersTemplate was created with", "1.3-extensions"}, {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSessionParametersTemplate-parameter", "If videoSessionParametersTemplate is not VK_NULL_HANDLE, videoSessionParametersTemplate must be a valid VkVideoSessionParametersKHR handle", "1.3-extensions"}, {"VUID-VkVideoSessionParametersCreateInfoKHR-videoSessionParametersTemplate-parent", "If videoSessionParametersTemplate is a valid handle, it must have been created, allocated, or retrieved from videoSession", "1.3-extensions"}, - {"VUID-VkVideoSessionParametersUpdateInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeH264SessionParametersAddInfoKHR, VkVideoDecodeH265SessionParametersAddInfoKHR, VkVideoEncodeH264SessionParametersAddInfoEXT, or VkVideoEncodeH265SessionParametersAddInfoEXT", "1.3-extensions"}, + {"VUID-VkVideoSessionParametersUpdateInfoKHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeH264SessionParametersAddInfoKHR, VkVideoDecodeH265SessionParametersAddInfoKHR, VkVideoEncodeH264SessionParametersAddInfoKHR, or VkVideoEncodeH265SessionParametersAddInfoKHR", "1.3-extensions"}, {"VUID-VkVideoSessionParametersUpdateInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR", "1.3-extensions"}, {"VUID-VkVideoSessionParametersUpdateInfoKHR-sType-unique", "The sType value of each struct in the pNext chain must be unique", "1.3-extensions"}, {"VUID-VkViewport-apiVersion-07917", "If the VK_KHR_maintenance1 extension is not enabled, the VK_AMD_negative_viewport_height extension is not enabled, and VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.1, height must be greater than 0.0", "1.3-extensions"}, @@ -7183,6 +7376,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCmdBeginQuery-None-00807", "All queries used by the command must be unavailable", "1.3-extensions"}, {"VUID-vkCmdBeginQuery-None-02863", "If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, this command must not be recorded in a command buffer that, either directly or through secondary command buffers, also contains a vkCmdResetQueryPool command affecting the same query", "1.3-extensions"}, {"VUID-vkCmdBeginQuery-None-07127", "If there is a bound video session, then there must be no active queries", "1.3-extensions"}, + {"VUID-vkCmdBeginQuery-None-08370", "If there is a bound video session, then it must not have been created with VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR", "1.3-extensions"}, {"VUID-vkCmdBeginQuery-commandBuffer-01885", "commandBuffer must not be a protected command buffer", "1.3-extensions"}, {"VUID-vkCmdBeginQuery-commandBuffer-cmdpool", "The VkCommandPool that commandBuffer was allocated from must support graphics, compute, decode, or encode operations", "1.3-extensions"}, {"VUID-vkCmdBeginQuery-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle", "1.3-extensions"}, @@ -7207,7 +7401,6 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCmdBeginQuery-queryType-02804", "The queryType used to create queryPool must not be VK_QUERY_TYPE_TIMESTAMP", "1.3-extensions"}, {"VUID-vkCmdBeginQuery-queryType-04728", "The queryType used to create queryPool must not be VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR or VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR", "1.3-extensions"}, {"VUID-vkCmdBeginQuery-queryType-04729", "The queryType used to create queryPool must not be VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV", "1.3-extensions"}, - {"VUID-vkCmdBeginQuery-queryType-04862", "If the queryType used to create queryPool was VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR, then the VkCommandPool that commandBuffer was allocated from must support video encode operations", "1.3-extensions"}, {"VUID-vkCmdBeginQuery-queryType-06687", "If the queryType used to create queryPool was VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT the VkCommandPool that commandBuffer was allocated from must support graphics operations", "1.3-extensions"}, {"VUID-vkCmdBeginQuery-queryType-06688", "If the queryType used to create queryPool was VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT then primitivesGeneratedQuery must be enabled", "1.3-extensions"}, {"VUID-vkCmdBeginQuery-queryType-06741", "The queryType used to create queryPool must not be VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR or VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR", "1.3-extensions"}, @@ -7220,6 +7413,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCmdBeginQueryIndexedEXT-None-00807", "All queries used by the command must be unavailable", "1.3-extensions"}, {"VUID-vkCmdBeginQueryIndexedEXT-None-02863", "If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, this command must not be recorded in a command buffer that, either directly or through secondary command buffers, also contains a vkCmdResetQueryPool command affecting the same query", "1.3-extensions"}, {"VUID-vkCmdBeginQueryIndexedEXT-None-07127", "If there is a bound video session, then there must be no active queries", "1.3-extensions"}, + {"VUID-vkCmdBeginQueryIndexedEXT-None-08370", "If there is a bound video session, then it must not have been created with VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR", "1.3-extensions"}, {"VUID-vkCmdBeginQueryIndexedEXT-commandBuffer-01885", "commandBuffer must not be a protected command buffer", "1.3-extensions"}, {"VUID-vkCmdBeginQueryIndexedEXT-commandBuffer-cmdpool", "The VkCommandPool that commandBuffer was allocated from must support graphics, compute, decode, or encode operations", "1.3-extensions"}, {"VUID-vkCmdBeginQueryIndexedEXT-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle", "1.3-extensions"}, @@ -7245,7 +7439,6 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCmdBeginQueryIndexedEXT-queryType-02804", "The queryType used to create queryPool must not be VK_QUERY_TYPE_TIMESTAMP", "1.3-extensions"}, {"VUID-vkCmdBeginQueryIndexedEXT-queryType-04728", "The queryType used to create queryPool must not be VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR or VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR", "1.3-extensions"}, {"VUID-vkCmdBeginQueryIndexedEXT-queryType-04729", "The queryType used to create queryPool must not be VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV", "1.3-extensions"}, - {"VUID-vkCmdBeginQueryIndexedEXT-queryType-04862", "If the queryType used to create queryPool was VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR, then the VkCommandPool that commandBuffer was allocated from must support video encode operations", "1.3-extensions"}, {"VUID-vkCmdBeginQueryIndexedEXT-queryType-06689", "If the queryType used to create queryPool was VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT the VkCommandPool that commandBuffer was allocated from must support graphics operations", "1.3-extensions"}, {"VUID-vkCmdBeginQueryIndexedEXT-queryType-06690", "If the queryType used to create queryPool was VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT the index parameter must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreams", "1.3-extensions"}, {"VUID-vkCmdBeginQueryIndexedEXT-queryType-06691", "If the queryType used to create queryPool was VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT and the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled, the index parameter must be zero", "1.3-extensions"}, @@ -7340,11 +7533,22 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCmdBeginVideoCodingKHR-commandBuffer-cmdpool", "The VkCommandPool that commandBuffer was allocated from must support decode, or encode operations", "1.3-extensions"}, {"VUID-vkCmdBeginVideoCodingKHR-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle", "1.3-extensions"}, {"VUID-vkCmdBeginVideoCodingKHR-commandBuffer-recording", "commandBuffer must be in the recording state", "1.3-extensions"}, + {"VUID-vkCmdBeginVideoCodingKHR-pBeginInfo-08253", "If pBeginInfo->videoSession was created with a video encode operation and the pNext chain of pBeginInfo does not include an instance of the VkVideoEncodeRateControlInfoKHR structure, then the rate control mode configured for pBeginInfo->videoSession at the time the command is executed on the device must be VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR", "1.3-extensions"}, + {"VUID-vkCmdBeginVideoCodingKHR-pBeginInfo-08254", "If pBeginInfo->videoSession was created with a video encode operation and the pNext chain of pBeginInfo includes an instance of the VkVideoEncodeRateControlInfoKHR structure, then it must match the rate control state configured for pBeginInfo->videoSession at the time the command is executed on the device", "1.3-extensions"}, + {"VUID-vkCmdBeginVideoCodingKHR-pBeginInfo-08255", "If pBeginInfo->videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, the current rate control mode is not VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR or VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR, and VkVideoEncodeH264CapabilitiesKHR::requiresGopRemainingFrames is VK_TRUE, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile the pBeginInfo->videoSession was created with, then the pNext chain of pBeginInfo must include an instance of the VkVideoEncodeH264GopRemainingFrameInfoKHR with its useGopRemainingFrames member set to VK_TRUE", "1.3-extensions"}, + {"VUID-vkCmdBeginVideoCodingKHR-pBeginInfo-08256", "If pBeginInfo->videoSession was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, the current rate control mode is not VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR or VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR, and VkVideoEncodeH265CapabilitiesKHR::requiresGopRemainingFrames is VK_TRUE, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile the pBeginInfo->videoSession was created with, then the pNext chain of pBeginInfo must include an instance of the VkVideoEncodeH265GopRemainingFrameInfoKHR with its useGopRemainingFrames member set to VK_TRUE", "1.3-extensions"}, {"VUID-vkCmdBeginVideoCodingKHR-pBeginInfo-parameter", "pBeginInfo must be a valid pointer to a valid VkVideoBeginCodingInfoKHR structure", "1.3-extensions"}, {"VUID-vkCmdBeginVideoCodingKHR-pPictureResource-07265", "Each video picture resource specified by any non-NULL pPictureResource member specified in the elements of pBeginInfo->pReferenceSlots for which slotIndex is not negative must match one of the video picture resources currently associated with the DPB slot index of pBeginInfo->videoSession specified by slotIndex at the time the command is executed on the device", "1.3-extensions"}, {"VUID-vkCmdBeginVideoCodingKHR-renderpass", "This command must only be called outside of a render pass instance", "1.3-extensions"}, {"VUID-vkCmdBeginVideoCodingKHR-slotIndex-07239", "If the slotIndex member of any element of pBeginInfo->pReferenceSlots is not negative, then it must specify the index of a DPB slot that is in the active state in pBeginInfo->videoSession at the time the command is executed on the device", "1.3-extensions"}, {"VUID-vkCmdBeginVideoCodingKHR-videocoding", "This command must only be called outside of a video coding scope", "1.3-extensions"}, + {"VUID-vkCmdBindDescriptorBufferEmbeddedSamplers2EXT-commandBuffer-cmdpool", "The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations", "1.3-extensions"}, + {"VUID-vkCmdBindDescriptorBufferEmbeddedSamplers2EXT-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle", "1.3-extensions"}, + {"VUID-vkCmdBindDescriptorBufferEmbeddedSamplers2EXT-commandBuffer-recording", "commandBuffer must be in the recording state", "1.3-extensions"}, + {"VUID-vkCmdBindDescriptorBufferEmbeddedSamplers2EXT-descriptorBuffer-09472", "The descriptorBuffer feature must be enabled", "1.3-extensions"}, + {"VUID-vkCmdBindDescriptorBufferEmbeddedSamplers2EXT-pBindDescriptorBufferEmbeddedSamplersInfo-09473", "Each bit in pBindDescriptorBufferEmbeddedSamplersInfo->stageFlags must be a stage supported by the commandBuffer's parent VkCommandPool's queue family", "1.3-extensions"}, + {"VUID-vkCmdBindDescriptorBufferEmbeddedSamplers2EXT-pBindDescriptorBufferEmbeddedSamplersInfo-parameter", "pBindDescriptorBufferEmbeddedSamplersInfo must be a valid pointer to a valid VkBindDescriptorBufferEmbeddedSamplersInfoEXT structure", "1.3-extensions"}, + {"VUID-vkCmdBindDescriptorBufferEmbeddedSamplers2EXT-videocoding", "This command must only be called outside of a video coding scope", "1.3-extensions"}, {"VUID-vkCmdBindDescriptorBufferEmbeddedSamplersEXT-None-08068", "The descriptorBuffer feature must be enabled", "1.3-extensions"}, {"VUID-vkCmdBindDescriptorBufferEmbeddedSamplersEXT-commandBuffer-cmdpool", "The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations", "1.3-extensions"}, {"VUID-vkCmdBindDescriptorBufferEmbeddedSamplersEXT-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle", "1.3-extensions"}, @@ -7383,7 +7587,9 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCmdBindDescriptorSets-pDescriptorSets-00358", "Each element of pDescriptorSets must have been allocated with a VkDescriptorSetLayout that matches (is the same as, or identically defined as) the VkDescriptorSetLayout at set n in layout, where n is the sum of firstSet and the index into pDescriptorSets", "1.3-extensions"}, {"VUID-vkCmdBindDescriptorSets-pDescriptorSets-01979", "For each dynamic uniform or storage buffer binding in pDescriptorSets, the sum of the effective offset and the range of the binding must be less than or equal to the size of the buffer", "1.3-extensions"}, {"VUID-vkCmdBindDescriptorSets-pDescriptorSets-04616", "Each element of pDescriptorSets must not have been allocated from a VkDescriptorPool with the VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT flag set", "1.3-extensions"}, + {"VUID-vkCmdBindDescriptorSets-pDescriptorSets-06563", "If graphicsPipelineLibrary is not enabled, each element of pDescriptorSets must be a valid VkDescriptorSet", "1.3-extensions"}, {"VUID-vkCmdBindDescriptorSets-pDescriptorSets-06715", "For each dynamic uniform or storage buffer binding in pDescriptorSets, if the range was set with VK_WHOLE_SIZE then pDynamicOffsets which corresponds to the descriptor binding must be 0", "1.3-extensions"}, + {"VUID-vkCmdBindDescriptorSets-pDescriptorSets-08010", "Each element of pDescriptorSets must have been allocated with a VkDescriptorSetLayout which was not created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT", "1.3-extensions"}, {"VUID-vkCmdBindDescriptorSets-pDescriptorSets-parameter", "pDescriptorSets must be a valid pointer to an array of descriptorSetCount valid or VK_NULL_HANDLE VkDescriptorSet handles", "1.3-extensions"}, {"VUID-vkCmdBindDescriptorSets-pDynamicOffsets-01971", "Each element of pDynamicOffsets which corresponds to a descriptor binding with type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment", "1.3-extensions"}, {"VUID-vkCmdBindDescriptorSets-pDynamicOffsets-01972", "Each element of pDynamicOffsets which corresponds to a descriptor binding with type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment", "1.3-extensions"}, @@ -7391,26 +7597,36 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCmdBindDescriptorSets-pipelineBindPoint-00361", "pipelineBindPoint must be supported by the commandBuffer's parent VkCommandPool's queue family", "1.3-extensions"}, {"VUID-vkCmdBindDescriptorSets-pipelineBindPoint-parameter", "pipelineBindPoint must be a valid VkPipelineBindPoint value", "1.3-extensions"}, {"VUID-vkCmdBindDescriptorSets-videocoding", "This command must only be called outside of a video coding scope", "1.3-extensions"}, + {"VUID-vkCmdBindDescriptorSets2KHR-commandBuffer-cmdpool", "The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations", "1.3-extensions"}, + {"VUID-vkCmdBindDescriptorSets2KHR-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle", "1.3-extensions"}, + {"VUID-vkCmdBindDescriptorSets2KHR-commandBuffer-recording", "commandBuffer must be in the recording state", "1.3-extensions"}, + {"VUID-vkCmdBindDescriptorSets2KHR-pBindDescriptorSetsInfo-09467", "Each bit in pBindDescriptorSetsInfo->stageFlags must be a stage supported by the commandBuffer's parent VkCommandPool's queue family", "1.3-extensions"}, + {"VUID-vkCmdBindDescriptorSets2KHR-pBindDescriptorSetsInfo-parameter", "pBindDescriptorSetsInfo must be a valid pointer to a valid VkBindDescriptorSetsInfoKHR structure", "1.3-extensions"}, + {"VUID-vkCmdBindDescriptorSets2KHR-videocoding", "This command must only be called outside of a video coding scope", "1.3-extensions"}, + {"VUID-vkCmdBindIndexBuffer-None-09493", "If maintenance6 is not enabled, buffer must not be VK_NULL_HANDLE", "1.3-extensions"}, {"VUID-vkCmdBindIndexBuffer-buffer-08784", "buffer must have been created with the VK_BUFFER_USAGE_INDEX_BUFFER_BIT flag", "1.3-extensions"}, {"VUID-vkCmdBindIndexBuffer-buffer-08785", "If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", "1.3-extensions"}, - {"VUID-vkCmdBindIndexBuffer-buffer-parameter", "buffer must be a valid VkBuffer handle", "1.3-extensions"}, + {"VUID-vkCmdBindIndexBuffer-buffer-09494", "If buffer is VK_NULL_HANDLE, offset must be zero", "1.3-extensions"}, + {"VUID-vkCmdBindIndexBuffer-buffer-parameter", "If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle", "1.3-extensions"}, {"VUID-vkCmdBindIndexBuffer-commandBuffer-cmdpool", "The VkCommandPool that commandBuffer was allocated from must support graphics operations", "1.3-extensions"}, {"VUID-vkCmdBindIndexBuffer-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle", "1.3-extensions"}, {"VUID-vkCmdBindIndexBuffer-commandBuffer-recording", "commandBuffer must be in the recording state", "1.3-extensions"}, - {"VUID-vkCmdBindIndexBuffer-commonparent", "Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice", "1.3-extensions"}, + {"VUID-vkCmdBindIndexBuffer-commonparent", "Both of buffer, and commandBuffer that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice", "1.3-extensions"}, {"VUID-vkCmdBindIndexBuffer-indexType-08786", "indexType must not be VK_INDEX_TYPE_NONE_KHR", "1.3-extensions"}, {"VUID-vkCmdBindIndexBuffer-indexType-08787", "If indexType is VK_INDEX_TYPE_UINT8_EXT, the indexTypeUint8 feature must be enabled", "1.3-extensions"}, {"VUID-vkCmdBindIndexBuffer-indexType-parameter", "indexType must be a valid VkIndexType value", "1.3-extensions"}, {"VUID-vkCmdBindIndexBuffer-offset-08782", "offset must be less than the size of buffer", "1.3-extensions"}, {"VUID-vkCmdBindIndexBuffer-offset-08783", "The sum of offset and the base address of the range of VkDeviceMemory object that is backing buffer, must be a multiple of the size of the type indicated by indexType", "1.3-extensions"}, {"VUID-vkCmdBindIndexBuffer-videocoding", "This command must only be called outside of a video coding scope", "1.3-extensions"}, + {"VUID-vkCmdBindIndexBuffer2KHR-None-09493", "If maintenance6 is not enabled, buffer must not be VK_NULL_HANDLE", "1.3-extensions"}, {"VUID-vkCmdBindIndexBuffer2KHR-buffer-08784", "buffer must have been created with the VK_BUFFER_USAGE_INDEX_BUFFER_BIT flag", "1.3-extensions"}, {"VUID-vkCmdBindIndexBuffer2KHR-buffer-08785", "If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", "1.3-extensions"}, - {"VUID-vkCmdBindIndexBuffer2KHR-buffer-parameter", "buffer must be a valid VkBuffer handle", "1.3-extensions"}, + {"VUID-vkCmdBindIndexBuffer2KHR-buffer-09494", "If buffer is VK_NULL_HANDLE, offset must be zero", "1.3-extensions"}, + {"VUID-vkCmdBindIndexBuffer2KHR-buffer-parameter", "If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle", "1.3-extensions"}, {"VUID-vkCmdBindIndexBuffer2KHR-commandBuffer-cmdpool", "The VkCommandPool that commandBuffer was allocated from must support graphics operations", "1.3-extensions"}, {"VUID-vkCmdBindIndexBuffer2KHR-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle", "1.3-extensions"}, {"VUID-vkCmdBindIndexBuffer2KHR-commandBuffer-recording", "commandBuffer must be in the recording state", "1.3-extensions"}, - {"VUID-vkCmdBindIndexBuffer2KHR-commonparent", "Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice", "1.3-extensions"}, + {"VUID-vkCmdBindIndexBuffer2KHR-commonparent", "Both of buffer, and commandBuffer that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice", "1.3-extensions"}, {"VUID-vkCmdBindIndexBuffer2KHR-indexType-08786", "indexType must not be VK_INDEX_TYPE_NONE_KHR", "1.3-extensions"}, {"VUID-vkCmdBindIndexBuffer2KHR-indexType-08787", "If indexType is VK_INDEX_TYPE_UINT8_EXT, the indexTypeUint8 feature must be enabled", "1.3-extensions"}, {"VUID-vkCmdBindIndexBuffer2KHR-indexType-parameter", "indexType must be a valid VkIndexType value", "1.3-extensions"}, @@ -7908,6 +8124,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCmdControlVideoCodingKHR-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle", "1.3-extensions"}, {"VUID-vkCmdControlVideoCodingKHR-commandBuffer-recording", "commandBuffer must be in the recording state", "1.3-extensions"}, {"VUID-vkCmdControlVideoCodingKHR-flags-07017", "If pCodingControlInfo->flags does not include VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR, then the bound video session must not be in uninitialized state at the time the command is executed on the device", "1.3-extensions"}, + {"VUID-vkCmdControlVideoCodingKHR-pCodingControlInfo-08243", "If the bound video session was not created with an encode operation, then pCodingControlInfo->pNext must not include VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR or VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR", "1.3-extensions"}, {"VUID-vkCmdControlVideoCodingKHR-pCodingControlInfo-parameter", "pCodingControlInfo must be a valid pointer to a valid VkVideoCodingControlInfoKHR structure", "1.3-extensions"}, {"VUID-vkCmdControlVideoCodingKHR-renderpass", "This command must only be called outside of a render pass instance", "1.3-extensions"}, {"VUID-vkCmdControlVideoCodingKHR-videocoding", "This command must only be called inside of a video coding scope", "1.3-extensions"}, @@ -8326,6 +8543,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCmdDebugMarkerInsertEXT-videocoding", "This command must only be called outside of a video coding scope", "1.3-extensions"}, {"VUID-vkCmdDecodeVideoKHR-None-07011", "The bound video session must not be in uninitialized state at the time the command is executed on the device", "1.3-extensions"}, {"VUID-vkCmdDecodeVideoKHR-None-07258", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR but was not created with interlaced frame support, then the decode output picture must represent a frame", "1.3-extensions"}, + {"VUID-vkCmdDecodeVideoKHR-None-08249", "The bound video session must have been created with a decode operation", "1.3-extensions"}, {"VUID-vkCmdDecodeVideoKHR-StdVideoH264PictureParameterSet-07155", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR, then the bound video session parameters object must contain a StdVideoH264PictureParameterSet entry with seq_parameter_set_id and pic_parameter_set_id matching StdVideoDecodeH264PictureInfo::seq_parameter_set_id and StdVideoDecodeH264PictureInfo::pic_parameter_set_id, respectively, that are provided in the pStdPictureInfo member of the VkVideoDecodeH264PictureInfoKHR structure included in the pNext chain of pDecodeInfo", "1.3-extensions"}, {"VUID-vkCmdDecodeVideoKHR-StdVideoH264SequenceParameterSet-07154", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR, then the bound video session parameters object must contain a StdVideoH264SequenceParameterSet entry with seq_parameter_set_id matching StdVideoDecodeH264PictureInfo::seq_parameter_set_id that is provided in the pStdPictureInfo member of the VkVideoDecodeH264PictureInfoKHR structure included in the pNext chain of pDecodeInfo", "1.3-extensions"}, {"VUID-vkCmdDecodeVideoKHR-StdVideoH265PictureParameterSet-07162", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, then the bound video session parameters object must contain a StdVideoH265PictureParameterSet entry with sps_video_parameter_set_id, pps_seq_parameter_set_id, and pps_pic_parameter_set_id matching StdVideoDecodeH265PictureInfo::sps_video_parameter_set_id, StdVideoDecodeH265PictureInfo::pps_seq_parameter_set_id, and StdVideoDecodeH265PictureInfo::pps_pic_parameter_set_id, respectively, that are provided in the pStdPictureInfo member of the VkVideoDecodeH265PictureInfoKHR structure included in the pNext chain of pDecodeInfo", "1.3-extensions"}, @@ -8373,14 +8591,20 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCmdDecodeVideoKHR-pDecodeInfo-07266", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR and an active reference picture corresponding to any element of pDecodeInfo->pReferenceSlots represents a frame, then the DPB slot index of the bound video session specified by the slotIndex member of that element must be currently associated with a frame picture matching the video picture resource specified by the pPictureResource member of the same element at the time the command is executed on the device", "1.3-extensions"}, {"VUID-vkCmdDecodeVideoKHR-pDecodeInfo-07267", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR and an active reference picture corresponding to any element of pDecodeInfo->pReferenceSlots represents a top field, then the DPB slot index of the bound video session specified by the slotIndex member of that element must be currently associated with a top field picture matching the video picture resource specified by the pPictureResource member of the same element at the time the command is executed on the device", "1.3-extensions"}, {"VUID-vkCmdDecodeVideoKHR-pDecodeInfo-07268", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR and an active reference picture corresponding to any element of pDecodeInfo->pReferenceSlots represents a bottom field, then the DPB slot index of the bound video session specified by the slotIndex member of that element must be currently associated with a bottom field picture matching the video picture resource specified by the pPictureResource member of the same element at the time the command is executed on the device", "1.3-extensions"}, + {"VUID-vkCmdDecodeVideoKHR-pDecodeInfo-08376", "pDecodeInfo->pSetupReferenceSlot must not be NULL unless the bound video session was created with VkVideoSessionCreateInfoKHR::maxDpbSlots equal to zero", "1.3-extensions"}, {"VUID-vkCmdDecodeVideoKHR-pDecodeInfo-parameter", "pDecodeInfo must be a valid pointer to a valid VkVideoDecodeInfoKHR structure", "1.3-extensions"}, {"VUID-vkCmdDecodeVideoKHR-pNext-07152", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR, then the pNext chain of pDecodeInfo must include a VkVideoDecodeH264PictureInfoKHR structure", "1.3-extensions"}, {"VUID-vkCmdDecodeVideoKHR-pNext-07157", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR, then the pNext chain of each element of pDecodeInfo->pReferenceSlots must include a VkVideoDecodeH264DpbSlotInfoKHR structure", "1.3-extensions"}, {"VUID-vkCmdDecodeVideoKHR-pNext-07158", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, then the pNext chain of pDecodeInfo must include a VkVideoDecodeH265PictureInfoKHR structure", "1.3-extensions"}, {"VUID-vkCmdDecodeVideoKHR-pNext-07164", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, then the pNext chain of each element of pDecodeInfo->pReferenceSlots must include a VkVideoDecodeH265DpbSlotInfoKHR structure", "1.3-extensions"}, + {"VUID-vkCmdDecodeVideoKHR-pNext-08365", "If the bound video session was created with VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR, and the pNext chain of pDecodeInfo includes a VkVideoInlineQueryInfoKHR structure with its queryPool member specifying a valid VkQueryPool handle, then VkVideoInlineQueryInfoKHR::queryCount must equal opCount", "1.3-extensions"}, + {"VUID-vkCmdDecodeVideoKHR-pNext-08366", "If the bound video session was created with VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR, and the pNext chain of pDecodeInfo includes a VkVideoInlineQueryInfoKHR structure with its queryPool member specifying a valid VkQueryPool handle, then all the queries used by the command, as specified by the VkVideoInlineQueryInfoKHR structure, must be unavailable", "1.3-extensions"}, {"VUID-vkCmdDecodeVideoKHR-pPictureResource-07255", "The image subresource referred to by the pPictureResource member of each element of pDecodeInfo->pReferenceSlots must be in the VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR layout at the time the video decode operation is executed on the device", "1.3-extensions"}, {"VUID-vkCmdDecodeVideoKHR-pSliceOffsets-07153", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR, then all elements of the pSliceOffsets member of the VkVideoDecodeH264PictureInfoKHR structure included in the pNext chain of pDecodeInfo must be less than pDecodeInfo->srcBufferRange", "1.3-extensions"}, {"VUID-vkCmdDecodeVideoKHR-pSliceSegmentOffsets-07159", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, then all elements of the pSliceSegmentOffsets member of the VkVideoDecodeH265PictureInfoKHR structure included in the pNext chain of pDecodeInfo must be less than pDecodeInfo->srcBufferRange", "1.3-extensions"}, + {"VUID-vkCmdDecodeVideoKHR-queryPool-08368", "If the bound video session was created with VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR, then the queryPool specified in the VkVideoInlineQueryInfoKHR structure included in the pNext chain of pDecodeInfo must have been created with a VkVideoProfileInfoKHR structure included in the pNext chain of VkQueryPoolCreateInfo identical to the one specified in VkVideoSessionCreateInfoKHR::pVideoProfile the bound video session was created with", "1.3-extensions"}, + {"VUID-vkCmdDecodeVideoKHR-queryType-08367", "If the bound video session was created with VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR, then the queryType used to create the queryPool specified in the VkVideoInlineQueryInfoKHR structure included in the pNext chain of pDecodeInfo must be VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR", "1.3-extensions"}, + {"VUID-vkCmdDecodeVideoKHR-queryType-08369", "If the bound video session was created with VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR, and the queryType used to create the queryPool specified in the VkVideoInlineQueryInfoKHR structure included in the pNext chain of pDecodeInfo is VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR, then the VkCommandPool that commandBuffer was allocated from must have been created with a queue family index that supports result status queries, as indicated by VkQueueFamilyQueryResultStatusPropertiesKHR::queryResultStatusSupport", "1.3-extensions"}, {"VUID-vkCmdDecodeVideoKHR-renderpass", "This command must only be called outside of a render pass instance", "1.3-extensions"}, {"VUID-vkCmdDecodeVideoKHR-slotIndex-07256", "The slotIndex member of each element of pDecodeInfo->pReferenceSlots must be less than the VkVideoSessionCreateInfoKHR::maxDpbSlots specified when the bound video session was created", "1.3-extensions"}, {"VUID-vkCmdDecodeVideoKHR-videocoding", "This command must only be called inside of a video coding scope", "1.3-extensions"}, @@ -9966,7 +10190,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCmdDrawIndexed-None-06886", "If the current render pass instance uses a depth/stencil attachment with a read-only layout for the depth aspect, depth writes must be disabled", "1.3-extensions"}, {"VUID-vkCmdDrawIndexed-None-06887", "If the current render pass instance uses a depth/stencil attachment with a read-only layout for the stencil aspect, both front and back writeMask are not zero, and stencil test is enabled, all stencil ops must be VK_STENCIL_OP_KEEP", "1.3-extensions"}, {"VUID-vkCmdDrawIndexed-None-07288", "Any shader invocation executed by this command must terminate", "1.3-extensions"}, - {"VUID-vkCmdDrawIndexed-None-07312", "An index buffer must be bound", "1.3-extensions"}, + {"VUID-vkCmdDrawIndexed-None-07312", "If maintenance6 is not enabled, a valid index buffer must be bound", "1.3-extensions"}, {"VUID-vkCmdDrawIndexed-None-07469", "Input attachment views accessed in a subpass must be created with the same VkFormat as the corresponding subpass definition, and be created with a VkImageView that is compatible with the attachment referenced by the subpass' pInputAttachments[InputAttachmentIndex] in the currently bound VkFramebuffer as specified by Fragment Input Attachment Compatibility", "1.3-extensions"}, {"VUID-vkCmdDrawIndexed-None-07619", "If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command", "1.3-extensions"}, {"VUID-vkCmdDrawIndexed-None-07620", "If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command", "1.3-extensions"}, @@ -10327,7 +10551,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCmdDrawIndexedIndirect-None-06886", "If the current render pass instance uses a depth/stencil attachment with a read-only layout for the depth aspect, depth writes must be disabled", "1.3-extensions"}, {"VUID-vkCmdDrawIndexedIndirect-None-06887", "If the current render pass instance uses a depth/stencil attachment with a read-only layout for the stencil aspect, both front and back writeMask are not zero, and stencil test is enabled, all stencil ops must be VK_STENCIL_OP_KEEP", "1.3-extensions"}, {"VUID-vkCmdDrawIndexedIndirect-None-07288", "Any shader invocation executed by this command must terminate", "1.3-extensions"}, - {"VUID-vkCmdDrawIndexedIndirect-None-07312", "An index buffer must be bound", "1.3-extensions"}, + {"VUID-vkCmdDrawIndexedIndirect-None-07312", "If maintenance6 is not enabled, a valid index buffer must be bound", "1.3-extensions"}, {"VUID-vkCmdDrawIndexedIndirect-None-07469", "Input attachment views accessed in a subpass must be created with the same VkFormat as the corresponding subpass definition, and be created with a VkImageView that is compatible with the attachment referenced by the subpass' pInputAttachments[InputAttachmentIndex] in the currently bound VkFramebuffer as specified by Fragment Input Attachment Compatibility", "1.3-extensions"}, {"VUID-vkCmdDrawIndexedIndirect-None-07619", "If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command", "1.3-extensions"}, {"VUID-vkCmdDrawIndexedIndirect-None-07620", "If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command", "1.3-extensions"}, @@ -10694,7 +10918,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCmdDrawIndexedIndirectCount-None-06886", "If the current render pass instance uses a depth/stencil attachment with a read-only layout for the depth aspect, depth writes must be disabled", "1.3-extensions"}, {"VUID-vkCmdDrawIndexedIndirectCount-None-06887", "If the current render pass instance uses a depth/stencil attachment with a read-only layout for the stencil aspect, both front and back writeMask are not zero, and stencil test is enabled, all stencil ops must be VK_STENCIL_OP_KEEP", "1.3-extensions"}, {"VUID-vkCmdDrawIndexedIndirectCount-None-07288", "Any shader invocation executed by this command must terminate", "1.3-extensions"}, - {"VUID-vkCmdDrawIndexedIndirectCount-None-07312", "An index buffer must be bound", "1.3-extensions"}, + {"VUID-vkCmdDrawIndexedIndirectCount-None-07312", "If maintenance6 is not enabled, a valid index buffer must be bound", "1.3-extensions"}, {"VUID-vkCmdDrawIndexedIndirectCount-None-07469", "Input attachment views accessed in a subpass must be created with the same VkFormat as the corresponding subpass definition, and be created with a VkImageView that is compatible with the attachment referenced by the subpass' pInputAttachments[InputAttachmentIndex] in the currently bound VkFramebuffer as specified by Fragment Input Attachment Compatibility", "1.3-extensions"}, {"VUID-vkCmdDrawIndexedIndirectCount-None-07619", "If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command", "1.3-extensions"}, {"VUID-vkCmdDrawIndexedIndirectCount-None-07620", "If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command", "1.3-extensions"}, @@ -11651,6 +11875,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCmdDrawIndirectByteCountEXT-counterBuffer-04567", "If counterBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", "1.3-extensions"}, {"VUID-vkCmdDrawIndirectByteCountEXT-counterBuffer-parameter", "counterBuffer must be a valid VkBuffer handle", "1.3-extensions"}, {"VUID-vkCmdDrawIndirectByteCountEXT-counterBufferOffset-04568", "counterBufferOffset must be a multiple of 4", "1.3-extensions"}, + {"VUID-vkCmdDrawIndirectByteCountEXT-counterOffset-09474", "counterOffset must be a multiple of 4", "1.3-extensions"}, {"VUID-vkCmdDrawIndirectByteCountEXT-coverageModulationTableEnable-07488", "If a shader object is bound to any graphics stage or the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled, and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass", "1.3-extensions"}, {"VUID-vkCmdDrawIndirectByteCountEXT-coverageReductionMode-07491", "If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", "1.3-extensions"}, {"VUID-vkCmdDrawIndirectByteCountEXT-coverageToColorEnable-07490", "If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT", "1.3-extensions"}, @@ -11758,6 +11983,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCmdDrawIndirectByteCountEXT-transformFeedbackDraw-02288", "The implementation must support VkPhysicalDeviceTransformFeedbackPropertiesEXT::transformFeedbackDraw", "1.3-extensions"}, {"VUID-vkCmdDrawIndirectByteCountEXT-uniformBuffers-06935", "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", "1.3-extensions"}, {"VUID-vkCmdDrawIndirectByteCountEXT-vertexStride-02289", "vertexStride must be greater than 0 and less than or equal to VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBufferDataStride", "1.3-extensions"}, + {"VUID-vkCmdDrawIndirectByteCountEXT-vertexStride-09475", "vertexStride must be a multiple of 4", "1.3-extensions"}, {"VUID-vkCmdDrawIndirectByteCountEXT-videocoding", "This command must only be called outside of a video coding scope", "1.3-extensions"}, {"VUID-vkCmdDrawIndirectByteCountEXT-viewMask-06178", "If the current render pass instance was begun with vkCmdBeginRendering, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfo::viewMask equal to VkRenderingInfo::viewMask", "1.3-extensions"}, {"VUID-vkCmdDrawIndirectByteCountEXT-viewType-07752", "If a VkImageView is accessed as a result of this command, then the image view's viewType must match the Dim operand of the OpTypeImage as described in Instruction/Sampler/Image View Validation", "1.3-extensions"}, @@ -14637,7 +14863,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCmdDrawMultiIndexedEXT-None-06886", "If the current render pass instance uses a depth/stencil attachment with a read-only layout for the depth aspect, depth writes must be disabled", "1.3-extensions"}, {"VUID-vkCmdDrawMultiIndexedEXT-None-06887", "If the current render pass instance uses a depth/stencil attachment with a read-only layout for the stencil aspect, both front and back writeMask are not zero, and stencil test is enabled, all stencil ops must be VK_STENCIL_OP_KEEP", "1.3-extensions"}, {"VUID-vkCmdDrawMultiIndexedEXT-None-07288", "Any shader invocation executed by this command must terminate", "1.3-extensions"}, - {"VUID-vkCmdDrawMultiIndexedEXT-None-07312", "An index buffer must be bound", "1.3-extensions"}, + {"VUID-vkCmdDrawMultiIndexedEXT-None-07312", "If maintenance6 is not enabled, a valid index buffer must be bound", "1.3-extensions"}, {"VUID-vkCmdDrawMultiIndexedEXT-None-07469", "Input attachment views accessed in a subpass must be created with the same VkFormat as the corresponding subpass definition, and be created with a VkImageView that is compatible with the attachment referenced by the subpass' pInputAttachments[InputAttachmentIndex] in the currently bound VkFramebuffer as specified by Fragment Input Attachment Compatibility", "1.3-extensions"}, {"VUID-vkCmdDrawMultiIndexedEXT-None-07619", "If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command", "1.3-extensions"}, {"VUID-vkCmdDrawMultiIndexedEXT-None-07620", "If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command", "1.3-extensions"}, @@ -14979,13 +15205,81 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCmdDrawMultiIndexedEXT-viewportCount-07492", "If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount", "1.3-extensions"}, {"VUID-vkCmdDrawMultiIndexedEXT-viewportCount-07493", "If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount", "1.3-extensions"}, {"VUID-vkCmdDrawMultiIndexedEXT-viewportCount-09421", "If the VK_NV_viewport_swizzle extension is enabled, and a shader object is bound to any graphics stage, then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-None-07012", "The bound video session must not be in uninitialized state at the time the command is executed on the device", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-None-08250", "The bound video session must have been created with an encode operation", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-None-08318", "The bound video session parameters object must have been created with the currently set video encode quality level for the bound video session at the time the command is executed on the device", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-StdVideoH264PictureParameterSet-08227", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then the bound video session parameters object must contain a StdVideoH264PictureParameterSet entry with seq_parameter_set_id and pic_parameter_set_id matching StdVideoEncodeH264PictureInfo::seq_parameter_set_id and StdVideoEncodeH264PictureInfo::pic_parameter_set_id, respectively, that are provided in the pStdPictureInfo member of the VkVideoEncodeH264PictureInfoKHR structure included in the pNext chain of pEncodeInfo", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-StdVideoH264SequenceParameterSet-08226", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then the bound video session parameters object must contain a StdVideoH264SequenceParameterSet entry with seq_parameter_set_id matching StdVideoEncodeH264PictureInfo::seq_parameter_set_id that is provided in the pStdPictureInfo member of the VkVideoEncodeH264PictureInfoKHR structure included in the pNext chain of pEncodeInfo", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-StdVideoH265PictureParameterSet-08233", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then the bound video session parameters object must contain a StdVideoH265PictureParameterSet entry with sps_video_parameter_set_id, pps_seq_parameter_set_id, and pps_pic_parameter_set_id matching StdVideoEncodeH265PictureInfo::sps_video_parameter_set_id, StdVideoEncodeH265PictureInfo::pps_seq_parameter_set_id, and StdVideoEncodeH265PictureInfo::pps_pic_parameter_set_id, respectively, that are provided in the pStdPictureInfo member of the VkVideoEncodeH265PictureInfoKHR structure included in the pNext chain of pEncodeInfo", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-StdVideoH265SequenceParameterSet-08232", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then the bound video session parameters object must contain a StdVideoH265SequenceParameterSet entry with sps_video_parameter_set_id and sps_seq_parameter_set_id matching StdVideoEncodeH265PictureInfo::sps_video_parameter_set_id and StdVideoEncodeH265PictureInfo::pps_seq_parameter_set_id, respectively, that are provided in the pStdPictureInfo member of the VkVideoEncodeH265PictureInfoKHR structure included in the pNext chain of pEncodeInfo", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-StdVideoH265VideoParameterSet-08231", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then the bound video session parameters object must contain a StdVideoH265VideoParameterSet entry with vps_video_parameter_set_id matching StdVideoEncodeH265PictureInfo::sps_video_parameter_set_id that is provided in the pStdPictureInfo member of the VkVideoEncodeH265PictureInfoKHR structure included in the pNext chain of pEncodeInfo", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-activeReferencePictureCount-08216", "activeReferencePictureCount must be less than or equal to the VkVideoSessionCreateInfoKHR::maxActiveReferencePictures specified when the bound video session was created", "1.3-extensions"}, {"VUID-vkCmdEncodeVideoKHR-bufferlevel", "commandBuffer must be a primary VkCommandBuffer", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-codedOffset-08218", "The codedOffset member of the VkVideoPictureResourceInfoKHR structure pointed to by the pPictureResource member of each element of pEncodeInfo->pReferenceSlots must be an integer multiple of codedOffsetGranularity", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-commandBuffer-08202", "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, then pEncodeInfo->dstBuffer must not be a protected buffer", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-commandBuffer-08203", "If commandBuffer is a protected command buffer and protectedNoFault is not supported, then pEncodeInfo->dstBuffer must be a protected buffer", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-commandBuffer-08211", "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, then pEncodeInfo->srcPictureResource.imageViewBinding must not have been created from a protected image", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-commandBuffer-08212", "If commandBuffer is a protected command buffer and protectedNoFault is not supported, then pEncodeInfo->srcPictureResource.imageViewBinding must have been created from a protected image", "1.3-extensions"}, {"VUID-vkCmdEncodeVideoKHR-commandBuffer-cmdpool", "The VkCommandPool that commandBuffer was allocated from must support encode operations", "1.3-extensions"}, {"VUID-vkCmdEncodeVideoKHR-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle", "1.3-extensions"}, {"VUID-vkCmdEncodeVideoKHR-commandBuffer-recording", "commandBuffer must be in the recording state", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-constantQp-08269", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR and the current rate control mode is not VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR, then VkVideoEncodeH264NaluSliceInfoKHR::constantQp must be zero for each element of the pNaluSliceEntries member of the VkVideoEncodeH264PictureInfoKHR structure included in the pNext chain of pEncodeInfo", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-constantQp-08270", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR and the current rate control mode is VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR, then VkVideoEncodeH264NaluSliceInfoKHR::constantQp must be between VkVideoEncodeH264CapabilitiesKHR::minQp and VkVideoEncodeH264CapabilitiesKHR::maxQp, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile the bound video session was created with, for each element of the pNaluSliceEntries member of the VkVideoEncodeH264PictureInfoKHR structure included in the pNext chain of pEncodeInfo", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-constantQp-08271", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR and VkVideoEncodeH264CapabilitiesKHR::flags does not include VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile the bound video session was created with, then VkVideoEncodeH264NaluSliceInfoKHR::constantQp must have the same value for each element of the pNaluSliceEntries member of the VkVideoEncodeH264PictureInfoKHR structure included in the pNext chain of pEncodeInfo", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-constantQp-08272", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR and the current rate control mode is not VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR, then VkVideoEncodeH265NaluSliceSegmentInfoKHR::constantQp must be zero for each element of the pNaluSliceSegmentEntries member of the VkVideoEncodeH265PictureInfoKHR structure included in the pNext chain of pEncodeInfo", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-constantQp-08273", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR and the current rate control mode is VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR, then VkVideoEncodeH265NaluSliceSegmentInfoKHR::constantQp must be between VkVideoEncodeH265CapabilitiesKHR::minQp and VkVideoEncodeH265CapabilitiesKHR::maxQp, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile the bound video session was created with, for each element of the pNaluSliceSegmentEntries member of the VkVideoEncodeH265PictureInfoKHR structure included in the pNext chain of pEncodeInfo", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-constantQp-08274", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR and VkVideoEncodeH265CapabilitiesKHR::flags does not include VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile the bound video session was created with, then VkVideoEncodeH265NaluSliceSegmentInfoKHR::constantQp must have the same value for each element of the pNaluSliceSegmentEntries member of the VkVideoEncodeH264PictureInfoKHR structure included in the pNext chain of pEncodeInfo", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-dpbFrameUseCount-08221", "All elements of dpbFrameUseCount must be less than or equal to 1", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-flags-08342", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR and VkVideoEncodeH264CapabilitiesKHR::flags does not include VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile the bound video session was created with, then each element of h264L0PictureTypes must not be STD_VIDEO_H264_PICTURE_TYPE_B", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-flags-08343", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR and VkVideoEncodeH264CapabilitiesKHR::flags does not include VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile the bound video session was created with, then each element of h264L1PictureTypes must not be STD_VIDEO_H264_PICTURE_TYPE_B", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-flags-08347", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR and VkVideoEncodeH265CapabilitiesKHR::flags does not include VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile the bound video session was created with, then each element of h265L0PictureTypes must not be STD_VIDEO_H264_PICTURE_TYPE_B", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-flags-08348", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR and VkVideoEncodeH265CapabilitiesKHR::flags does not include VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile the bound video session was created with, then each element of h265L1PictureTypes must not be STD_VIDEO_H265_PICTURE_TYPE_B", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-maxBPictureL0ReferenceCount-08341", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR and VkVideoEncodeH264CapabilitiesKHR::maxBPictureL0ReferenceCount and VkVideoEncodeH264CapabilitiesKHR::maxL1ReferenceCount are both zero, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile the bound video session was created with, then h264PictureType and each element of h264L0PictureTypes and h264L1PictureTypes must not be STD_VIDEO_H264_PICTURE_TYPE_B", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-maxBPictureL0ReferenceCount-08346", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR and VkVideoEncodeH265CapabilitiesKHR::maxBPictureL0ReferenceCount and VkVideoEncodeH265CapabilitiesKHR::maxL1ReferenceCount are both zero, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile the bound video session was created with, then h265PictureType and each element of h265L0PictureTypes and h265L1PictureTypes must not be STD_VIDEO_H265_PICTURE_TYPE_B", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-maxPPictureL0ReferenceCount-08340", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR and VkVideoEncodeH264CapabilitiesKHR::maxPPictureL0ReferenceCount is zero, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile the bound video session was created with, then h264PictureType and each element of h264L0PictureTypes and h264L1PictureTypes must not be STD_VIDEO_H264_PICTURE_TYPE_P", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-maxPPictureL0ReferenceCount-08345", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR and VkVideoEncodeH265CapabilitiesKHR::maxPPictureL0ReferenceCount is zero, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile the bound video session was created with, then h265PictureType and each element of h265L0PictureTypes and h265L1PictureTypes must not be STD_VIDEO_H265_PICTURE_TYPE_P", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-naluSliceEntryCount-08302", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then the naluSliceEntryCount member of the VkVideoEncodeH264PictureInfoKHR structure included in the pNext chain of pEncodeInfo must be less than or equal to minCodingBlockExtent.width multiplied by minCodingBlockExtent.height", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-naluSliceEntryCount-08312", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR and VkVideoEncodeH264CapabilitiesKHR::flags does not include VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile the bound video session was created with, then the naluSliceEntryCount member of the VkVideoEncodeH264PictureInfoKHR structure included in the pNext chain of pEncodeInfo must be less than or equal to minCodingBlockExtent.height", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-naluSliceSegmentEntryCount-08307", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then the naluSliceSegmentEntryCount member of the VkVideoEncodeH265PictureInfoKHR structure included in the pNext chain of pEncodeInfo must be less than or equal to minCodingBlockExtent.width multiplied by minCodingBlockExtent.height", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-naluSliceSegmentEntryCount-08313", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR and VkVideoEncodeH265CapabilitiesKHR::flags does not include VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile the bound video session was created with, then the naluSliceSegmentEntryCount member of the VkVideoEncodeH265PictureInfoKHR structure included in the pNext chain of pEncodeInfo must be less than or equal to minCodingBlockExtent.height", "1.3-extensions"}, {"VUID-vkCmdEncodeVideoKHR-opCount-07174", "For each active query, the active query index corresponding to the query type of that query plus opCount must be less than or equal to the last activatable query index corresponding to the query type of that query plus one", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pEncodeInfo-08201", "pEncodeInfo->dstBuffer must be compatible with the video profile the bound video session was created with", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pEncodeInfo-08204", "pEncodeInfo->dstBufferOffset must be an integer multiple of VkVideoCapabilitiesKHR::minBitstreamBufferOffsetAlignment, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile the bound video session was created with", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pEncodeInfo-08205", "pEncodeInfo->dstBufferRange must be an integer multiple of VkVideoCapabilitiesKHR::minBitstreamBufferSizeAlignment, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile the bound video session was created with", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pEncodeInfo-08206", "pEncodeInfo->srcPictureResource.imageViewBinding must be compatible with the video profile the bound video session was created with", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pEncodeInfo-08207", "The format of pEncodeInfo->srcPictureResource.imageViewBinding must match the VkVideoSessionCreateInfoKHR::pictureFormat the bound video session was created with", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pEncodeInfo-08208", "pEncodeInfo->srcPictureResource.codedOffset must be an integer multiple of codedOffsetGranularity", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pEncodeInfo-08209", "pEncodeInfo->srcPictureResource.codedExtent must be between minCodedExtent and maxCodedExtent, inclusive, the bound video session was created with", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pEncodeInfo-08210", "pEncodeInfo->srcPictureResource.imageViewBinding must have been created with VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pEncodeInfo-08213", "If pEncodeInfo->pSetupReferenceSlot is not NULL, then pEncodeInfo->pSetupReferenceSlot->slotIndex must be less than the VkVideoSessionCreateInfoKHR::maxDpbSlots specified when the bound video session was created", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pEncodeInfo-08214", "If pEncodeInfo->pSetupReferenceSlot is not NULL, then pEncodeInfo->pSetupReferenceSlot->pPictureResource->codedOffset must be an integer multiple of codedOffsetGranularity", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pEncodeInfo-08215", "If pEncodeInfo->pSetupReferenceSlot is not NULL, then pEncodeInfo->pSetupReferenceSlot->pPictureResource must match one of the bound reference picture resource", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pEncodeInfo-08222", "The image subresource referred to by pEncodeInfo->srcPictureResource must be in the VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR layout at the time the video encode operation is executed on the device", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pEncodeInfo-08223", "If pEncodeInfo->pSetupReferenceSlot is not NULL, then the image subresource referred to by pEncodeInfo->pSetupReferenceSlot->pPictureResource must be in the VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR layout at the time the video encode operation is executed on the device", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pEncodeInfo-08228", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR and pEncodeInfo->pSetupReferenceSlot is not NULL, then the pNext chain of pEncodeInfo->pSetupReferenceSlot must include a VkVideoEncodeH264DpbSlotInfoKHR structure", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pEncodeInfo-08234", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR and pEncodeInfo->pSetupReferenceSlot is not NULL, then the pNext chain of pEncodeInfo->pSetupReferenceSlot must include a VkVideoEncodeH265DpbSlotInfoKHR structure", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pEncodeInfo-08377", "pEncodeInfo->pSetupReferenceSlot must not be NULL unless the bound video session was created with VkVideoSessionCreateInfoKHR::maxDpbSlots equal to zero", "1.3-extensions"}, {"VUID-vkCmdEncodeVideoKHR-pEncodeInfo-parameter", "pEncodeInfo must be a valid pointer to a valid VkVideoEncodeInfoKHR structure", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pNext-08225", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then the pNext chain of pEncodeInfo must include a VkVideoEncodeH264PictureInfoKHR structure", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pNext-08229", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then the pNext chain of each element of pEncodeInfo->pReferenceSlots must include a VkVideoEncodeH264DpbSlotInfoKHR structure", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pNext-08230", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then the pNext chain of pEncodeInfo must include a VkVideoEncodeH265PictureInfoKHR structure", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pNext-08235", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then the pNext chain of each element of pEncodeInfo->pReferenceSlots must include a VkVideoEncodeH265DpbSlotInfoKHR structure", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pNext-08339", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, the pNext chain of pEncodeInfo includes a VkVideoEncodeH264PictureInfoKHR structure, and VkVideoEncodeH264PictureInfoKHR::pStdPictureInfo->pRefLists is not NULL, then each element of the RefPicList0 and RefPicList1 array members of the StdVideoEncodeH264ReferenceListsInfo structure pointed to by VkVideoEncodeH264PictureInfoKHR::pStdPictureInfo->pRefLists must either be STD_VIDEO_H264_NO_REFERENCE_PICTURE or must equal the slotIndex member of one of the elements of pEncodeInfo->pReferenceSlots", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pNext-08344", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, the pNext chain of pEncodeInfo includes a VkVideoEncodeH265PictureInfoKHR structure, and VkVideoEncodeH265PictureInfoKHR::pStdPictureInfo->pRefLists is not NULL, then each element of the RefPicList0 and RefPicList1 array members of the StdVideoEncodeH265ReferenceListsInfo structure pointed to by VkVideoEncodeH265PictureInfoKHR::pStdPictureInfo->pRefLists must either be STD_VIDEO_H265_NO_REFERENCE_PICTURE or must equal the slotIndex member of one of the elements of pEncodeInfo->pReferenceSlots", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pNext-08352", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, the pNext chain of pEncodeInfo includes a VkVideoEncodeH264PictureInfoKHR structure, and pEncodeInfo->referenceSlotCount is greater than zero, then VkVideoEncodeH264PictureInfoKHR::pStdPictureInfo->pRefLists must not be NULL", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pNext-08353", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, the pNext chain of pEncodeInfo includes a VkVideoEncodeH264PictureInfoKHR structure, and pEncodeInfo->referenceSlotCount is greater than zero, then the slotIndex member of each element of pEncodeInfo->pReferenceSlots must equal one of the elements of the RefPicList0 or RefPicList1 array members of the StdVideoEncodeH264ReferenceListsInfo structure pointed to by VkVideoEncodeH264PictureInfoKHR::pStdPictureInfo->pRefLists", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pNext-08354", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, the pNext chain of pEncodeInfo includes a VkVideoEncodeH265PictureInfoKHR structure, and pEncodeInfo->referenceSlotCount is greater than zero, then VkVideoEncodeH265PictureInfoKHR::pStdPictureInfo->pRefLists must not be NULL", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pNext-08355", "If the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, the pNext chain of pEncodeInfo includes a VkVideoEncodeH265PictureInfoKHR structure, and pEncodeInfo->referenceSlotCount is greater than zero, then the slotIndex member of each element of pEncodeInfo->pReferenceSlots must equal one of the elements of the RefPicList0 or RefPicList1 array members of the StdVideoEncodeH265ReferenceListsInfo structure pointed to by VkVideoEncodeH265PictureInfoKHR::pStdPictureInfo->pRefLists", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pNext-08360", "If the bound video session was created with VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR, and the pNext chain of pEncodeInfo includes a VkVideoInlineQueryInfoKHR structure with its queryPool member specifying a valid VkQueryPool handle, then VkVideoInlineQueryInfoKHR::queryCount must equal opCount", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pNext-08361", "If the bound video session was created with VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR, and the pNext chain of pEncodeInfo includes a VkVideoInlineQueryInfoKHR structure with its queryPool member specifying a valid VkQueryPool handle, then all the queries used by the command, as specified by the VkVideoInlineQueryInfoKHR structure, must be unavailable", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pPictureResource-08219", "The pPictureResource member of each element of pEncodeInfo->pReferenceSlots must match one of the bound reference picture resource associated with the DPB slot index specified in the slotIndex member of that element", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pPictureResource-08220", "Each video picture resource corresponding to the pPictureResource member specified in the elements of pEncodeInfo->pReferenceSlots must be unique within pEncodeInfo->pReferenceSlots", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-pPictureResource-08224", "The image subresource referred to by the pPictureResource member of each element of pEncodeInfo->pReferenceSlots must be in the VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR layout at the time the video encode operation is executed on the device", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-queryPool-08363", "If the bound video session was created with VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR, then the queryPool specified in the VkVideoInlineQueryInfoKHR structure included in the pNext chain of pEncodeInfo must have been created with a VkVideoProfileInfoKHR structure included in the pNext chain of VkQueryPoolCreateInfo identical to the one specified in VkVideoSessionCreateInfoKHR::pVideoProfile the bound video session was created with", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-queryType-08362", "If the bound video session was created with VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR, then the queryType used to create the queryPool specified in the VkVideoInlineQueryInfoKHR structure included in the pNext chain of pEncodeInfo must be VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR or VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-queryType-08364", "If the bound video session was created with VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR, and the queryType used to create the queryPool specified in the VkVideoInlineQueryInfoKHR structure included in the pNext chain of pEncodeInfo is VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR, then the VkCommandPool that commandBuffer was allocated from must have been created with a queue family index that supports result status queries, as indicated by VkQueueFamilyQueryResultStatusPropertiesKHR::queryResultStatusSupport", "1.3-extensions"}, {"VUID-vkCmdEncodeVideoKHR-renderpass", "This command must only be called outside of a render pass instance", "1.3-extensions"}, + {"VUID-vkCmdEncodeVideoKHR-slotIndex-08217", "The slotIndex member of each element of pEncodeInfo->pReferenceSlots must be less than the VkVideoSessionCreateInfoKHR::maxDpbSlots specified when the bound video session was created", "1.3-extensions"}, {"VUID-vkCmdEncodeVideoKHR-videocoding", "This command must only be called inside of a video coding scope", "1.3-extensions"}, {"VUID-vkCmdEndConditionalRenderingEXT-None-01985", "Conditional rendering must be active", "1.3-extensions"}, {"VUID-vkCmdEndConditionalRenderingEXT-None-01986", "If conditional rendering was made active outside of a render pass instance, it must not be ended inside a render pass instance", "1.3-extensions"}, @@ -15657,19 +15951,35 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCmdPushConstants-stageFlags-parameter", "stageFlags must be a valid combination of VkShaderStageFlagBits values", "1.3-extensions"}, {"VUID-vkCmdPushConstants-stageFlags-requiredbitmask", "stageFlags must not be 0", "1.3-extensions"}, {"VUID-vkCmdPushConstants-videocoding", "This command must only be called outside of a video coding scope", "1.3-extensions"}, + {"VUID-vkCmdPushConstants2KHR-commandBuffer-cmdpool", "The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations", "1.3-extensions"}, + {"VUID-vkCmdPushConstants2KHR-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle", "1.3-extensions"}, + {"VUID-vkCmdPushConstants2KHR-commandBuffer-recording", "commandBuffer must be in the recording state", "1.3-extensions"}, + {"VUID-vkCmdPushConstants2KHR-pPushConstantsInfo-parameter", "pPushConstantsInfo must be a valid pointer to a valid VkPushConstantsInfoKHR structure", "1.3-extensions"}, + {"VUID-vkCmdPushConstants2KHR-videocoding", "This command must only be called outside of a video coding scope", "1.3-extensions"}, + {"VUID-vkCmdPushDescriptorSet2KHR-commandBuffer-cmdpool", "The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations", "1.3-extensions"}, + {"VUID-vkCmdPushDescriptorSet2KHR-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle", "1.3-extensions"}, + {"VUID-vkCmdPushDescriptorSet2KHR-commandBuffer-recording", "commandBuffer must be in the recording state", "1.3-extensions"}, + {"VUID-vkCmdPushDescriptorSet2KHR-pPushDescriptorSetInfo-09468", "Each bit in pPushDescriptorSetInfo->stageFlags must be a stage supported by the commandBuffer's parent VkCommandPool's queue family", "1.3-extensions"}, + {"VUID-vkCmdPushDescriptorSet2KHR-pPushDescriptorSetInfo-parameter", "pPushDescriptorSetInfo must be a valid pointer to a valid VkPushDescriptorSetInfoKHR structure", "1.3-extensions"}, + {"VUID-vkCmdPushDescriptorSet2KHR-videocoding", "This command must only be called outside of a video coding scope", "1.3-extensions"}, {"VUID-vkCmdPushDescriptorSetKHR-commandBuffer-cmdpool", "The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations", "1.3-extensions"}, {"VUID-vkCmdPushDescriptorSetKHR-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle", "1.3-extensions"}, {"VUID-vkCmdPushDescriptorSetKHR-commandBuffer-recording", "commandBuffer must be in the recording state", "1.3-extensions"}, {"VUID-vkCmdPushDescriptorSetKHR-commonparent", "Both of commandBuffer, and layout must have been created, allocated, or retrieved from the same VkDevice", "1.3-extensions"}, {"VUID-vkCmdPushDescriptorSetKHR-descriptorWriteCount-arraylength", "descriptorWriteCount must be greater than 0", "1.3-extensions"}, {"VUID-vkCmdPushDescriptorSetKHR-layout-parameter", "layout must be a valid VkPipelineLayout handle", "1.3-extensions"}, - {"VUID-vkCmdPushDescriptorSetKHR-pDescriptorWrites-06494", "For each element i where pDescriptorWrites[i].descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, pDescriptorWrites[i].pImageInfo must be a valid pointer to an array of pDescriptorWrites[i].descriptorCount valid VkDescriptorImageInfo structures", "1.3-extensions"}, + {"VUID-vkCmdPushDescriptorSetKHR-pDescriptorWrites-06494", "For each element i where pDescriptorWrites[i].descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, pDescriptorWrites[i].pImageInfo must be a valid pointer to an array of pDescriptorWrites[i].descriptorCount valid VkDescriptorImageInfo structures", "1.3-extensions"}, {"VUID-vkCmdPushDescriptorSetKHR-pDescriptorWrites-parameter", "pDescriptorWrites must be a valid pointer to an array of descriptorWriteCount valid VkWriteDescriptorSet structures", "1.3-extensions"}, {"VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-00363", "pipelineBindPoint must be supported by the commandBuffer's parent VkCommandPool's queue family", "1.3-extensions"}, {"VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-parameter", "pipelineBindPoint must be a valid VkPipelineBindPoint value", "1.3-extensions"}, {"VUID-vkCmdPushDescriptorSetKHR-set-00364", "set must be less than VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created", "1.3-extensions"}, {"VUID-vkCmdPushDescriptorSetKHR-set-00365", "set must be the unique set number in the pipeline layout that uses a descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR", "1.3-extensions"}, {"VUID-vkCmdPushDescriptorSetKHR-videocoding", "This command must only be called outside of a video coding scope", "1.3-extensions"}, + {"VUID-vkCmdPushDescriptorSetWithTemplate2KHR-commandBuffer-cmdpool", "The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations", "1.3-extensions"}, + {"VUID-vkCmdPushDescriptorSetWithTemplate2KHR-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle", "1.3-extensions"}, + {"VUID-vkCmdPushDescriptorSetWithTemplate2KHR-commandBuffer-recording", "commandBuffer must be in the recording state", "1.3-extensions"}, + {"VUID-vkCmdPushDescriptorSetWithTemplate2KHR-pPushDescriptorSetWithTemplateInfo-parameter", "pPushDescriptorSetWithTemplateInfo must be a valid pointer to a valid VkPushDescriptorSetWithTemplateInfoKHR structure", "1.3-extensions"}, + {"VUID-vkCmdPushDescriptorSetWithTemplate2KHR-videocoding", "This command must only be called outside of a video coding scope", "1.3-extensions"}, {"VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-00366", "The pipelineBindPoint specified during the creation of the descriptor update template must be supported by the commandBuffer's parent VkCommandPool's queue family", "1.3-extensions"}, {"VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-cmdpool", "The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations", "1.3-extensions"}, {"VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle", "1.3-extensions"}, @@ -15974,6 +16284,13 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkCmdSetDepthWriteEnable-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle", "1.3-extensions"}, {"VUID-vkCmdSetDepthWriteEnable-commandBuffer-recording", "commandBuffer must be in the recording state", "1.3-extensions"}, {"VUID-vkCmdSetDepthWriteEnable-videocoding", "This command must only be called outside of a video coding scope", "1.3-extensions"}, + {"VUID-vkCmdSetDescriptorBufferOffsets2EXT-commandBuffer-cmdpool", "The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations", "1.3-extensions"}, + {"VUID-vkCmdSetDescriptorBufferOffsets2EXT-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle", "1.3-extensions"}, + {"VUID-vkCmdSetDescriptorBufferOffsets2EXT-commandBuffer-recording", "commandBuffer must be in the recording state", "1.3-extensions"}, + {"VUID-vkCmdSetDescriptorBufferOffsets2EXT-descriptorBuffer-09470", "The descriptorBuffer feature must be enabled", "1.3-extensions"}, + {"VUID-vkCmdSetDescriptorBufferOffsets2EXT-pSetDescriptorBufferOffsetsInfo-09471", "Each bit in pSetDescriptorBufferOffsetsInfo->stageFlags must be a stage supported by the commandBuffer's parent VkCommandPool's queue family", "1.3-extensions"}, + {"VUID-vkCmdSetDescriptorBufferOffsets2EXT-pSetDescriptorBufferOffsetsInfo-parameter", "pSetDescriptorBufferOffsetsInfo must be a valid pointer to a valid VkSetDescriptorBufferOffsetsInfoEXT structure", "1.3-extensions"}, + {"VUID-vkCmdSetDescriptorBufferOffsets2EXT-videocoding", "This command must only be called outside of a video coding scope", "1.3-extensions"}, {"VUID-vkCmdSetDescriptorBufferOffsetsEXT-None-08060", "The descriptorBuffer feature must be enabled", "1.3-extensions"}, {"VUID-vkCmdSetDescriptorBufferOffsetsEXT-commandBuffer-cmdpool", "The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations", "1.3-extensions"}, {"VUID-vkCmdSetDescriptorBufferOffsetsEXT-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle", "1.3-extensions"}, @@ -17916,8 +18233,9 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkGetDeferredOperationResultKHR-operation-parameter", "operation must be a valid VkDeferredOperationKHR handle", "1.3-extensions"}, {"VUID-vkGetDeferredOperationResultKHR-operation-parent", "operation must have been created, allocated, or retrieved from device", "1.3-extensions"}, {"VUID-vkGetDescriptorEXT-None-08015", "The descriptorBuffer feature must be enabled", "1.3-extensions"}, - {"VUID-vkGetDescriptorEXT-dataSize-08125", "dataSize must equal the size of a descriptor of type VkDescriptorGetInfoEXT::type determined by the value in VkPhysicalDeviceDescriptorBufferPropertiesEXT , or determined by VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::combinedImageSamplerDensityMapDescriptorSize if pDescriptorInfo specifies a VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER whose VkSampler was created with VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT set", "1.3-extensions"}, + {"VUID-vkGetDescriptorEXT-dataSize-08125", "If descriptorType is not VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER or pImageInfo has a imageView member that was not created with a VkSamplerYcbcrConversionInfo structure in its pNext chain, dataSize must equal the size of a descriptor of type VkDescriptorGetInfoEXT::type determined by the value in VkPhysicalDeviceDescriptorBufferPropertiesEXT , or determined by VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::combinedImageSamplerDensityMapDescriptorSize if pDescriptorInfo specifies a VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER whose VkSampler was created with VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT set", "1.3-extensions"}, {"VUID-vkGetDescriptorEXT-dataSize-arraylength", "dataSize must be greater than 0", "1.3-extensions"}, + {"VUID-vkGetDescriptorEXT-descriptorType-09469", "If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER and pImageInfo has a imageView member that was created with a VkSamplerYcbcrConversionInfo structure in its pNext chain, dataSize must equal the size of VkPhysicalDeviceDescriptorBufferPropertiesEXT::combinedImageSamplerDescriptorSize times VkSamplerYcbcrConversionImageFormatProperties::combinedImageSamplerDescriptorCount", "1.3-extensions"}, {"VUID-vkGetDescriptorEXT-device-parameter", "device must be a valid VkDevice handle", "1.3-extensions"}, {"VUID-vkGetDescriptorEXT-pDescriptor-08016", "pDescriptor must be a valid pointer to an array of at least dataSize bytes", "1.3-extensions"}, {"VUID-vkGetDescriptorEXT-pDescriptor-parameter", "pDescriptor must be a valid pointer to an array of dataSize bytes", "1.3-extensions"}, @@ -18042,6 +18360,14 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkGetEncodedVideoSessionParametersKHR-pData-parameter", "If the value referenced by pDataSize is not 0, and pData is not NULL, pData must be a valid pointer to an array of pDataSize bytes", "1.3-extensions"}, {"VUID-vkGetEncodedVideoSessionParametersKHR-pDataSize-parameter", "pDataSize must be a valid pointer to a size_t value", "1.3-extensions"}, {"VUID-vkGetEncodedVideoSessionParametersKHR-pFeedbackInfo-parameter", "If pFeedbackInfo is not NULL, pFeedbackInfo must be a valid pointer to a VkVideoEncodeSessionParametersFeedbackInfoKHR structure", "1.3-extensions"}, + {"VUID-vkGetEncodedVideoSessionParametersKHR-pVideoSessionParametersInfo-08262", "If pVideoSessionParametersInfo->videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then the pNext chain of pVideoSessionParametersInfo must include a VkVideoEncodeH264SessionParametersGetInfoKHR structure", "1.3-extensions"}, + {"VUID-vkGetEncodedVideoSessionParametersKHR-pVideoSessionParametersInfo-08263", "If pVideoSessionParametersInfo->videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then for the VkVideoEncodeH264SessionParametersGetInfoKHR structure included in the pNext chain of pVideoSessionParametersInfo, if its writeStdSPS member is VK_TRUE, then pVideoSessionParametersInfo->videoSessionParameters must contain a StdVideoH264SequenceParameterSet entry with seq_parameter_set_id matching VkVideoEncodeH264SessionParametersGetInfoKHR::stdSPSId", "1.3-extensions"}, + {"VUID-vkGetEncodedVideoSessionParametersKHR-pVideoSessionParametersInfo-08264", "If pVideoSessionParametersInfo->videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then for the VkVideoEncodeH264SessionParametersGetInfoKHR structure included in the pNext chain of pVideoSessionParametersInfo, if its writeStdPPS member is VK_TRUE, then pVideoSessionParametersInfo->videoSessionParameters must contain a StdVideoH264PictureParameterSet entry with seq_parameter_set_id and pic_parameter_set_id matching VkVideoEncodeH264SessionParametersGetInfoKHR::stdSPSId and VkVideoEncodeH264SessionParametersGetInfoKHR::stdPPSId, respectively", "1.3-extensions"}, + {"VUID-vkGetEncodedVideoSessionParametersKHR-pVideoSessionParametersInfo-08265", "If pVideoSessionParametersInfo->videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then the pNext chain of pVideoSessionParametersInfo must include a VkVideoEncodeH265SessionParametersGetInfoKHR structure", "1.3-extensions"}, + {"VUID-vkGetEncodedVideoSessionParametersKHR-pVideoSessionParametersInfo-08266", "If pVideoSessionParametersInfo->videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then for the VkVideoEncodeH265SessionParametersGetInfoKHR structure included in the pNext chain of pVideoSessionParametersInfo, if its writeStdVPS member is VK_TRUE, then pVideoSessionParametersInfo->videoSessionParameters must contain a StdVideoH265VideoParameterSet entry with vps_video_parameter_set_id matching VkVideoEncodeH265SessionParametersGetInfoKHR::stdVPSId", "1.3-extensions"}, + {"VUID-vkGetEncodedVideoSessionParametersKHR-pVideoSessionParametersInfo-08267", "If pVideoSessionParametersInfo->videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then for the VkVideoEncodeH265SessionParametersGetInfoKHR structure included in the pNext chain of pVideoSessionParametersInfo, if its writeStdSPS member is VK_TRUE, then pVideoSessionParametersInfo->videoSessionParameters must contain a StdVideoH265SequenceParameterSet entry with sps_video_parameter_set_id and sps_seq_parameter_set_id matching VkVideoEncodeH265SessionParametersGetInfoKHR::stdVPSId and VkVideoEncodeH265SessionParametersGetInfoKHR::stdSPSId, respectively", "1.3-extensions"}, + {"VUID-vkGetEncodedVideoSessionParametersKHR-pVideoSessionParametersInfo-08268", "If pVideoSessionParametersInfo->videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then for the VkVideoEncodeH265SessionParametersGetInfoKHR structure included in the pNext chain of pVideoSessionParametersInfo, if its writeStdPPS member is VK_TRUE, then pVideoSessionParametersInfo->videoSessionParameters must contain a StdVideoH265PictureParameterSet entry with sps_video_parameter_set_id, pps_seq_parameter_set_id, and pps_pic_parameter_set_id matching VkVideoEncodeH265SessionParametersGetInfoKHR::stdVPSId, VkVideoEncodeH265SessionParametersGetInfoKHR::stdSPSId, and VkVideoEncodeH265SessionParametersGetInfoKHR::stdPPSId, respectively", "1.3-extensions"}, + {"VUID-vkGetEncodedVideoSessionParametersKHR-pVideoSessionParametersInfo-08359", "pVideoSessionParametersInfo->videoSessionParameters must have been created with an encode operation", "1.3-extensions"}, {"VUID-vkGetEncodedVideoSessionParametersKHR-pVideoSessionParametersInfo-parameter", "pVideoSessionParametersInfo must be a valid pointer to a valid VkVideoEncodeSessionParametersGetInfoKHR structure", "1.3-extensions"}, {"VUID-vkGetEventStatus-device-parameter", "device must be a valid VkDevice handle", "1.3-extensions"}, {"VUID-vkGetEventStatus-event-03940", "event must not have been created with VK_EVENT_CREATE_DEVICE_ONLY_BIT", "1.3-extensions"}, @@ -18399,10 +18725,12 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkGetPhysicalDeviceVideoCapabilitiesKHR-pVideoProfile-07184", "If pVideoProfile->videoCodecOperation is VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR, then the pNext chain of pCapabilities must include a VkVideoDecodeH264CapabilitiesKHR structure", "1.3-extensions"}, {"VUID-vkGetPhysicalDeviceVideoCapabilitiesKHR-pVideoProfile-07185", "If pVideoProfile->videoCodecOperation is VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, then the pNext chain of pCapabilities must include a VkVideoDecodeH265CapabilitiesKHR structure", "1.3-extensions"}, {"VUID-vkGetPhysicalDeviceVideoCapabilitiesKHR-pVideoProfile-07186", "If pVideoProfile->videoCodecOperation specifies an encode operation, then the pNext chain of pCapabilities must include a VkVideoEncodeCapabilitiesKHR structure", "1.3-extensions"}, - {"VUID-vkGetPhysicalDeviceVideoCapabilitiesKHR-pVideoProfile-07187", "If pVideoProfile->videoCodecOperation is VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT, then the pNext chain of pCapabilities must include a VkVideoEncodeH264CapabilitiesEXT structure", "1.3-extensions"}, - {"VUID-vkGetPhysicalDeviceVideoCapabilitiesKHR-pVideoProfile-07188", "If pVideoProfile->videoCodecOperation is VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT, then the pNext chain of pCapabilities must include a VkVideoEncodeH265CapabilitiesEXT structure", "1.3-extensions"}, + {"VUID-vkGetPhysicalDeviceVideoCapabilitiesKHR-pVideoProfile-07187", "If pVideoProfile->videoCodecOperation is VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then the pNext chain of pCapabilities must include a VkVideoEncodeH264CapabilitiesKHR structure", "1.3-extensions"}, + {"VUID-vkGetPhysicalDeviceVideoCapabilitiesKHR-pVideoProfile-07188", "If pVideoProfile->videoCodecOperation is VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then the pNext chain of pCapabilities must include a VkVideoEncodeH265CapabilitiesKHR structure", "1.3-extensions"}, {"VUID-vkGetPhysicalDeviceVideoCapabilitiesKHR-pVideoProfile-parameter", "pVideoProfile must be a valid pointer to a valid VkVideoProfileInfoKHR structure", "1.3-extensions"}, {"VUID-vkGetPhysicalDeviceVideoCapabilitiesKHR-physicalDevice-parameter", "physicalDevice must be a valid VkPhysicalDevice handle", "1.3-extensions"}, + {"VUID-vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR-pQualityLevelInfo-08257", "If pQualityLevelInfo->pVideoProfile->videoCodecOperation is VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then the pNext chain of pQualityLevelProperties must include a VkVideoEncodeH264QualityLevelPropertiesKHR structure", "1.3-extensions"}, + {"VUID-vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR-pQualityLevelInfo-08258", "If pQualityLevelInfo->pVideoProfile->videoCodecOperation is VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then the pNext chain of pQualityLevelProperties must include a VkVideoEncodeH265QualityLevelPropertiesKHR structure", "1.3-extensions"}, {"VUID-vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR-pQualityLevelInfo-parameter", "pQualityLevelInfo must be a valid pointer to a valid VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR structure", "1.3-extensions"}, {"VUID-vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR-pQualityLevelProperties-parameter", "pQualityLevelProperties must be a valid pointer to a VkVideoEncodeQualityLevelPropertiesKHR structure", "1.3-extensions"}, {"VUID-vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR-physicalDevice-parameter", "physicalDevice must be a valid VkPhysicalDevice handle", "1.3-extensions"}, @@ -18888,6 +19216,11 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkUpdateVideoSessionParametersKHR-device-parameter", "device must be a valid VkDevice handle", "1.3-extensions"}, {"VUID-vkUpdateVideoSessionParametersKHR-pUpdateInfo-07215", "pUpdateInfo->updateSequenceCount must equal the current update sequence counter of videoSessionParameters plus one", "1.3-extensions"}, {"VUID-vkUpdateVideoSessionParametersKHR-pUpdateInfo-parameter", "pUpdateInfo must be a valid pointer to a valid VkVideoSessionParametersUpdateInfoKHR structure", "1.3-extensions"}, + {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-06441", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then the number of StdVideoH264SequenceParameterSet entries already stored in it plus the value of the stdSPSCount member of the VkVideoEncodeH264SessionParametersAddInfoKHR structure included in the pUpdateInfo->pNext chain must be less than or equal to the VkVideoEncodeH264SessionParametersCreateInfoKHR::maxStdSPSCount videoSessionParameters was created with", "1.3-extensions"}, + {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-06442", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, then the number of StdVideoH264PictureParameterSet entries already stored in it plus the value of the stdPPSCount member of the VkVideoEncodeH264SessionParametersAddInfoKHR structure included in the pUpdateInfo->pNext chain must be less than or equal to the VkVideoEncodeH264SessionParametersCreateInfoKHR::maxStdPPSCount videoSessionParameters was created with", "1.3-extensions"}, + {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-06443", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then the number of StdVideoH265VideoParameterSet entries already stored in it plus the value of the stdVPSCount member of the VkVideoEncodeH265SessionParametersAddInfoKHR structure included in the pUpdateInfo->pNext chain must be less than or equal to the VkVideoEncodeH265SessionParametersCreateInfoKHR::maxStdVPSCount videoSessionParameters was created with", "1.3-extensions"}, + {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-06444", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then the number of StdVideoH265SequenceParameterSet entries already stored in it plus the value of the stdSPSCount member of the VkVideoEncodeH265SessionParametersAddInfoKHR structure included in the pUpdateInfo->pNext chain must be less than or equal to the VkVideoEncodeH265SessionParametersCreateInfoKHR::maxStdSPSCount videoSessionParameters was created with", "1.3-extensions"}, + {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-06445", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, then the number of StdVideoH265PictureParameterSet entries already stored in it plus the value of the stdPPSCount member of the VkVideoEncodeH265SessionParametersAddInfoKHR structure included in the pUpdateInfo->pNext chain must be less than or equal to the VkVideoEncodeH265SessionParametersCreateInfoKHR::maxStdPPSCount videoSessionParameters was created with", "1.3-extensions"}, {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-07216", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR and the pNext chain of pUpdateInfo includes a VkVideoDecodeH264SessionParametersAddInfoKHR structure, then videoSessionParameters must not already contain a StdVideoH264SequenceParameterSet entry with seq_parameter_set_id matching any of the elements of VkVideoDecodeH264SessionParametersAddInfoKHR::pStdSPSs", "1.3-extensions"}, {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-07217", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR, then the number of StdVideoH264SequenceParameterSet entries already stored in it plus the value of the stdSPSCount member of the VkVideoDecodeH264SessionParametersAddInfoKHR structure included in the pUpdateInfo->pNext chain must be less than or equal to the VkVideoDecodeH264SessionParametersCreateInfoKHR::maxStdSPSCount videoSessionParameters was created with", "1.3-extensions"}, {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-07218", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR and the pNext chain of pUpdateInfo includes a VkVideoDecodeH264SessionParametersAddInfoKHR structure, then videoSessionParameters must not already contain a StdVideoH264PictureParameterSet entry with both seq_parameter_set_id and pic_parameter_set_id matching any of the elements of VkVideoDecodeH264SessionParametersAddInfoKHR::pStdPPSs", "1.3-extensions"}, @@ -18898,11 +19231,13 @@ static const vuid_spec_text_pair vuid_spec_text[] = { {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-07223", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, then the number of StdVideoH265SequenceParameterSet entries already stored in it plus the value of the stdSPSCount member of the VkVideoDecodeH265SessionParametersAddInfoKHR structure included in the pUpdateInfo->pNext chain must be less than or equal to the VkVideoDecodeH265SessionParametersCreateInfoKHR::maxStdSPSCount videoSessionParameters was created with", "1.3-extensions"}, {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-07224", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR and the pNext chain of pUpdateInfo includes a VkVideoDecodeH265SessionParametersAddInfoKHR structure, then videoSessionParameters must not already contain a StdVideoH265PictureParameterSet entry with sps_video_parameter_set_id, pps_seq_parameter_set_id, and pps_pic_parameter_set_id all matching any of the elements of VkVideoDecodeH265SessionParametersAddInfoKHR::pStdPPSs", "1.3-extensions"}, {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-07225", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, then the number of StdVideoH265PictureParameterSet entries already stored in it plus the value of the stdPPSCount member of the VkVideoDecodeH265SessionParametersAddInfoKHR structure included in the pUpdateInfo->pNext chain must be less than or equal to the VkVideoDecodeH265SessionParametersCreateInfoKHR::maxStdPPSCount videoSessionParameters was created with", "1.3-extensions"}, - {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-07226", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT and the pNext chain of pUpdateInfo includes a VkVideoEncodeH264SessionParametersAddInfoEXT structure, then videoSessionParameters must not already contain a StdVideoH264SequenceParameterSet entry with seq_parameter_set_id matching any of the elements of VkVideoEncodeH264SessionParametersAddInfoEXT::pStdSPSs", "1.3-extensions"}, - {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-07227", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT and the pNext chain of pUpdateInfo includes a VkVideoEncodeH264SessionParametersAddInfoEXT structure, then videoSessionParameters must not already contain a StdVideoH264PictureParameterSet entry with both seq_parameter_set_id and pic_parameter_set_id matching any of the elements of VkVideoEncodeH264SessionParametersAddInfoEXT::pStdPPSs", "1.3-extensions"}, - {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-07228", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT and the pNext chain of pUpdateInfo includes a VkVideoEncodeH265SessionParametersAddInfoEXT structure, then videoSessionParameters must not already contain a StdVideoH265VideoParameterSet entry with vps_video_parameter_set_id matching any of the elements of VkVideoEncodeH265SessionParametersAddInfoEXT::pStdVPSs", "1.3-extensions"}, - {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-07229", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT and the pNext chain of pUpdateInfo includes a VkVideoEncodeH265SessionParametersAddInfoEXT structure, then videoSessionParameters must not already contain a StdVideoH265SequenceParameterSet entry with both sps_video_parameter_set_id and sps_seq_parameter_set_id matching any of the elements of VkVideoEncodeH265SessionParametersAddInfoEXT::pStdSPSs", "1.3-extensions"}, - {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-07230", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT and the pNext chain of pUpdateInfo includes a VkVideoEncodeH265SessionParametersAddInfoEXT structure, then videoSessionParameters must not already contain a StdVideoH265PictureParameterSet entry with sps_video_parameter_set_id, pps_seq_parameter_set_id, and pps_pic_parameter_set_id all matching any of the elements of VkVideoEncodeH265SessionParametersAddInfoEXT::pStdPPSs", "1.3-extensions"}, + {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-07226", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR and the pNext chain of pUpdateInfo includes a VkVideoEncodeH264SessionParametersAddInfoKHR structure, then videoSessionParameters must not already contain a StdVideoH264SequenceParameterSet entry with seq_parameter_set_id matching any of the elements of VkVideoEncodeH264SessionParametersAddInfoKHR::pStdSPSs", "1.3-extensions"}, + {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-07227", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR and the pNext chain of pUpdateInfo includes a VkVideoEncodeH264SessionParametersAddInfoKHR structure, then videoSessionParameters must not already contain a StdVideoH264PictureParameterSet entry with both seq_parameter_set_id and pic_parameter_set_id matching any of the elements of VkVideoEncodeH264SessionParametersAddInfoKHR::pStdPPSs", "1.3-extensions"}, + {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-07228", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR and the pNext chain of pUpdateInfo includes a VkVideoEncodeH265SessionParametersAddInfoKHR structure, then videoSessionParameters must not already contain a StdVideoH265VideoParameterSet entry with vps_video_parameter_set_id matching any of the elements of VkVideoEncodeH265SessionParametersAddInfoKHR::pStdVPSs", "1.3-extensions"}, + {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-07229", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR and the pNext chain of pUpdateInfo includes a VkVideoEncodeH265SessionParametersAddInfoKHR structure, then videoSessionParameters must not already contain a StdVideoH265SequenceParameterSet entry with both sps_video_parameter_set_id and sps_seq_parameter_set_id matching any of the elements of VkVideoEncodeH265SessionParametersAddInfoKHR::pStdSPSs", "1.3-extensions"}, + {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-07230", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR and the pNext chain of pUpdateInfo includes a VkVideoEncodeH265SessionParametersAddInfoKHR structure, then videoSessionParameters must not already contain a StdVideoH265PictureParameterSet entry with sps_video_parameter_set_id, pps_seq_parameter_set_id, and pps_pic_parameter_set_id all matching any of the elements of VkVideoEncodeH265SessionParametersAddInfoKHR::pStdPPSs", "1.3-extensions"}, + {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-08321", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR and the pNext chain of pUpdateInfo includes a VkVideoEncodeH265SessionParametersAddInfoKHR structure, then num_tile_columns_minus1 must be less than VkVideoEncodeH265CapabilitiesKHR::maxTiles.width, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile videoSessionParameters was created with, for each element of VkVideoEncodeH265SessionParametersAddInfoKHR::pStdPPSs", "1.3-extensions"}, + {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-08322", "If videoSessionParameters was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR and the pNext chain of pUpdateInfo includes a VkVideoEncodeH265SessionParametersAddInfoKHR structure, then num_tile_rows_minus1 must be less than VkVideoEncodeH265CapabilitiesKHR::maxTiles.height, as returned by vkGetPhysicalDeviceVideoCapabilitiesKHR for the video profile videoSessionParameters was created with, for each element of VkVideoEncodeH265SessionParametersAddInfoKHR::pStdPPSs", "1.3-extensions"}, {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-parameter", "videoSessionParameters must be a valid VkVideoSessionParametersKHR handle", "1.3-extensions"}, {"VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-parent", "videoSessionParameters must have been created, allocated, or retrieved from device", "1.3-extensions"}, {"VUID-vkWaitForFences-device-parameter", "device must be a valid VkDevice handle", "1.3-extensions"}, diff --git a/scripts/generators/extension_helper_generator.py b/scripts/generators/extension_helper_generator.py index 222bd7d6a63..3044e52ab58 100644 --- a/scripts/generators/extension_helper_generator.py +++ b/scripts/generators/extension_helper_generator.py @@ -100,10 +100,16 @@ def generate(self): for extension in self.vk.extensions.values(): fieldName[extension.name] = extension.name.lower() requiredExpression[extension.name] = list() + print(extension.name) if extension.depends is not None: # This is a work around for https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/5372 temp = re.sub(r',VK_VERSION_1_\d+', '', extension.depends) + print(temp) + print(self.vk.versions) for reqs in exprValues(parseExpr(temp)): + if reqs == 'VK_VERSION_1_0': + # An explicit dependency on Vulkan 1.0 is meaningless + continue feature = self.vk.extensions[reqs] if reqs in self.vk.extensions else self.vk.versions[reqs] requiredExpression[extension.name].append(feature) for version in self.vk.versions.keys(): diff --git a/scripts/generators/safe_struct_generator.py b/scripts/generators/safe_struct_generator.py index af88da13848..d65c990cfd4 100644 --- a/scripts/generators/safe_struct_generator.py +++ b/scripts/generators/safe_struct_generator.py @@ -624,7 +624,11 @@ def generateSource(self): memcpy ((void *)pColorAttachmentFormats, (void *)in_struct->pColorAttachmentFormats, sizeof(VkFormat)*in_struct->colorAttachmentCount); } } - ''' + ''', + # TODO: VkPushDescriptorSetWithTemplateInfoKHR needs a custom constructor to handle pData + # https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/7169 + 'VkPushDescriptorSetWithTemplateInfoKHR': ''' + ''', } custom_copy_txt = { diff --git a/scripts/known_good.json b/scripts/known_good.json index 4d59fcdb30b..a183578236d 100755 --- 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.273" + "commit": "v1.3.274" }, { "name": "Vulkan-Utility-Libraries", @@ -15,7 +15,7 @@ "sub_dir": "Vulkan-Utility-Libraries", "build_dir": "Vulkan-Utility-Libraries/build", "install_dir": "Vulkan-Utility-Libraries/build/install", - "commit": "v1.3.273", + "commit": "v1.3.274", "deps": [ { "var_name": "VULKAN_HEADERS_INSTALL_DIR", @@ -110,7 +110,7 @@ "sub_dir": "Vulkan-Loader", "build_dir": "Vulkan-Loader/build", "install_dir": "Vulkan-Loader/build/install", - "commit": "v1.3.273", + "commit": "v1.3.274", "build_step": "skip", "optional": [ "tests" diff --git a/tests/layers/VkLayer_device_profile_api.json.in b/tests/layers/VkLayer_device_profile_api.json.in index 62f80dc2daf..ee60e7ed990 100644 --- a/tests/layers/VkLayer_device_profile_api.json.in +++ b/tests/layers/VkLayer_device_profile_api.json.in @@ -4,7 +4,7 @@ "name": "VK_LAYER_LUNARG_device_profile_api", "type": "GLOBAL", "library_path": "@JSON_LIBRARY_PATH@", - "api_version": "1.3.273", + "api_version": "1.3.274", "implementation_version": "2", "description": "LunarG Device Profile Api Layer", "device_extensions": [ diff --git a/tests/unit/descriptors.cpp b/tests/unit/descriptors.cpp index c604beaa65c..2730300c053 100644 --- a/tests/unit/descriptors.cpp +++ b/tests/unit/descriptors.cpp @@ -2826,7 +2826,7 @@ TEST_F(NegativeDescriptors, DescriptorSetLayoutStageFlags) { ds_layout_ci.pBindings = &dsl_binding; VkDescriptorSetLayout ds_layout; - m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkDescriptorSetLayoutBinding-descriptorCount-00283"); + m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkDescriptorSetLayoutBinding-descriptorCount-09465"); vk::CreateDescriptorSetLayout(device(), &ds_layout_ci, NULL, &ds_layout); m_errorMonitor->VerifyFound(); } diff --git a/tests/unit/transform_feedback.cpp b/tests/unit/transform_feedback.cpp index 6aafa6de6c8..907cabcc85f 100644 --- a/tests/unit/transform_feedback.cpp +++ b/tests/unit/transform_feedback.cpp @@ -565,7 +565,7 @@ TEST_F(NegativeTransformFeedback, DrawIndirectByteCountEXT) { vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.pipeline_); // if property is not multiple of 4 - m_errorMonitor->SetUnexpectedError("UNASSIGNED-vkCmdDrawIndirectByteCountEXT-vertexStride"); + m_errorMonitor->SetUnexpectedError("VUID-vkCmdDrawIndirectByteCountEXT-vertexStride-09475"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectByteCountEXT-vertexStride-02289"); vk::CmdDrawIndirectByteCountEXT(m_commandBuffer->handle(), 1, 0, counter_buffer.handle(), 0, 0, tf_properties.maxTransformFeedbackBufferDataStride + 4); @@ -576,11 +576,11 @@ TEST_F(NegativeTransformFeedback, DrawIndirectByteCountEXT) { vk::CmdDrawIndirectByteCountEXT(m_commandBuffer->handle(), 1, 0, counter_buffer.handle(), 1, 0, 4); m_errorMonitor->VerifyFound(); - m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "UNASSIGNED-vkCmdDrawIndirectByteCountEXT-counterOffset"); + m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectByteCountEXT-counterOffset-09474"); vk::CmdDrawIndirectByteCountEXT(m_commandBuffer->handle(), 1, 0, counter_buffer.handle(), 0, 1, 4); m_errorMonitor->VerifyFound(); - m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "UNASSIGNED-vkCmdDrawIndirectByteCountEXT-vertexStride"); + m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectByteCountEXT-vertexStride-09475"); vk::CmdDrawIndirectByteCountEXT(m_commandBuffer->handle(), 1, 0, counter_buffer.handle(), 0, 0, 1); m_errorMonitor->VerifyFound();