From 069b65827ead47a5f3fa5b4de972b709b93365a7 Mon Sep 17 00:00:00 2001 From: Jeremy Gebben Date: Tue, 19 Mar 2024 09:51:36 -0600 Subject: [PATCH] Move vk_safe_struct to VUL This code was being generated in both Vulkan-ValidationLayers and Vulkan-ExtensionLayer. Further uses are on the horizon so lets stop the copypasta. Also, add functions to manipulate extension lists and pNext chains, since many client layers have been doing that themselves. --- BUILD.gn | 10 + CMakeLists.txt | 3 +- include/CMakeLists.txt | 26 +- .../utility/vk_concurrent_unordered_map.hpp | 201 + include/vulkan/utility/vk_safe_struct.hpp | 18472 +++++++++++++++ .../vulkan/utility/vk_safe_struct_utils.hpp | 128 + scripts/common_ci.py | 54 + scripts/generate_source.py | 41 + scripts/generators/base_generator.py | 60 +- .../generators/dispatch_table_generator.py | 16 +- .../enum_string_helper_generator.py | 20 +- scripts/generators/generator_utils.py | 149 +- scripts/generators/safe_struct_generator.py | 797 + scripts/generators/struct_helper_generator.py | 8 +- scripts/generators/vulkan_object.py | 38 +- scripts/gn/stub.cpp | 9 +- src/CMakeLists.txt | 4 + src/vulkan/CMakeLists.txt | 30 + src/vulkan/vk_safe_struct_core.cpp | 18773 ++++++++++++++++ src/vulkan/vk_safe_struct_ext.cpp | 15447 +++++++++++++ src/vulkan/vk_safe_struct_khr.cpp | 15627 +++++++++++++ src/vulkan/vk_safe_struct_manual.cpp | 2209 ++ src/vulkan/vk_safe_struct_utils.cpp | 3633 +++ src/vulkan/vk_safe_struct_vendor.cpp | 15191 +++++++++++++ tests/CMakeLists.txt | 2 + tests/safe_struct.cpp | 239 + 26 files changed, 91119 insertions(+), 68 deletions(-) create mode 100644 include/vulkan/utility/vk_concurrent_unordered_map.hpp create mode 100644 include/vulkan/utility/vk_safe_struct.hpp create mode 100644 include/vulkan/utility/vk_safe_struct_utils.hpp create mode 100644 scripts/common_ci.py create mode 100644 scripts/generators/safe_struct_generator.py create mode 100644 src/vulkan/CMakeLists.txt create mode 100644 src/vulkan/vk_safe_struct_core.cpp create mode 100644 src/vulkan/vk_safe_struct_ext.cpp create mode 100644 src/vulkan/vk_safe_struct_khr.cpp create mode 100644 src/vulkan/vk_safe_struct_manual.cpp create mode 100644 src/vulkan/vk_safe_struct_utils.cpp create mode 100644 src/vulkan/vk_safe_struct_vendor.cpp create mode 100644 tests/safe_struct.cpp diff --git a/BUILD.gn b/BUILD.gn index ea46210..5096a09 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -6,6 +6,7 @@ import("//build_overrides/vulkan_utility_libraries.gni") config("vulkan_utility_libraries_config") { include_dirs = [ "include" ] + defines = [ "VK_ENABLE_BETA_EXTENSIONS" ] } static_library("vulkan_layer_settings") { @@ -14,8 +15,11 @@ static_library("vulkan_layer_settings") { sources = [ "include/vulkan/layer/vk_layer_settings.h", "include/vulkan/layer/vk_layer_settings.hpp", + "include/vulkan/utility/vk_concurrent_unordered_map.hpp", "include/vulkan/utility/vk_dispatch_table.h", "include/vulkan/utility/vk_format_utils.h", + "include/vulkan/utility/vk_safe_struct.hpp", + "include/vulkan/utility/vk_safe_struct_utils.hpp", "include/vulkan/utility/vk_struct_helper.hpp", "include/vulkan/vk_enum_string_helper.h", "scripts/gn/stub.cpp", @@ -25,5 +29,11 @@ static_library("vulkan_layer_settings") { "src/layer/layer_settings_util.hpp", "src/layer/vk_layer_settings.cpp", "src/layer/vk_layer_settings_helper.cpp", + "src/vulkan/vk_safe_struct_core.cpp", + "src/vulkan/vk_safe_struct_ext.cpp", + "src/vulkan/vk_safe_struct_khr.cpp", + "src/vulkan/vk_safe_struct_utils.cpp", + "src/vulkan/vk_safe_struct_vendor.cpp", + "src/vulkan/vk_safe_struct_manual.cpp", ] } diff --git a/CMakeLists.txt b/CMakeLists.txt index ae4bd3f..042550b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -48,9 +48,10 @@ if (VUL_IS_TOP_LEVEL) # Create VulkanUtilityLibraries-targets.cmake set_target_properties(VulkanLayerSettings PROPERTIES EXPORT_NAME "LayerSettings") set_target_properties(VulkanUtilityHeaders PROPERTIES EXPORT_NAME "UtilityHeaders") + set_target_properties(VulkanSafeStruct PROPERTIES EXPORT_NAME "SafeStruct") set_target_properties(VulkanCompilerConfiguration PROPERTIES EXPORT_NAME "CompilerConfiguration") install( - TARGETS VulkanLayerSettings VulkanUtilityHeaders VulkanCompilerConfiguration + TARGETS VulkanLayerSettings VulkanUtilityHeaders VulkanSafeStruct VulkanCompilerConfiguration EXPORT VulkanUtilityLibraries-targets INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} ) diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt index 9d045a7..58c48e9 100644 --- a/include/CMakeLists.txt +++ b/include/CMakeLists.txt @@ -6,8 +6,15 @@ target_include_directories(VulkanLayerSettings PUBLIC $) target_sources(VulkanLayerSettings PRIVATE - vulkan/layer/vk_layer_settings.h - vulkan/layer/vk_layer_settings.hpp + vulkan/layer/vk_layer_settings.h + vulkan/layer/vk_layer_settings.hpp +) + +target_include_directories(VulkanSafeStruct PUBLIC $) + +target_sources(VulkanSafeStruct PRIVATE + vulkan/utility/vk_safe_struct.hpp + vulkan/utility/vk_safe_struct_utils.hpp ) set(CMAKE_FOLDER "${CMAKE_FOLDER}/VulkanUtilityHeaders") @@ -17,15 +24,16 @@ add_library(Vulkan::UtilityHeaders ALIAS VulkanUtilityHeaders) # https://cmake.org/cmake/help/latest/release/3.19.html#other if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.19") - target_sources(VulkanUtilityHeaders PRIVATE - vulkan/utility/vk_dispatch_table.h - vulkan/vk_enum_string_helper.h - vulkan/utility/vk_format_utils.h - vulkan/utility/vk_struct_helper.hpp - ) + target_sources(VulkanUtilityHeaders PRIVATE + vulkan/vk_enum_string_helper.h + vulkan/utility/vk_concurrent_unordered_map.hpp + vulkan/utility/vk_dispatch_table.h + vulkan/utility/vk_format_utils.h + vulkan/utility/vk_struct_helper.hpp + ) endif() -target_link_Libraries(VulkanUtilityHeaders INTERFACE Vulkan::Headers) +target_link_libraries(VulkanUtilityHeaders INTERFACE Vulkan::Headers) target_include_directories(VulkanUtilityHeaders INTERFACE $) diff --git a/include/vulkan/utility/vk_concurrent_unordered_map.hpp b/include/vulkan/utility/vk_concurrent_unordered_map.hpp new file mode 100644 index 0000000..631346d --- /dev/null +++ b/include/vulkan/utility/vk_concurrent_unordered_map.hpp @@ -0,0 +1,201 @@ +/* Copyright (c) 2015-2017, 2019-2024 The Khronos Group Inc. + * Copyright (c) 2015-2017, 2019-2024 Valve Corporation + * Copyright (c) 2015-2017, 2019-2024 LunarG, Inc. + * Modifications Copyright (C) 2022 RasterGrid Kft. + * + * SPDX-License-Identifier: Apache-2.0 + * + */ + +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace vku { +namespace concurrent { +// https://en.cppreference.com/w/cpp/thread/hardware_destructive_interference_size +// https://en.wikipedia.org/wiki/False_sharing +// TODO use C++20 to check for std::hardware_destructive_interference_size feature support. +constexpr std::size_t get_hardware_destructive_interference_size() { return 64; } + +// Limited concurrent unordered_map that supports internally-synchronized +// insert/erase/access. Splits locking across N buckets and uses shared_mutex +// for read/write locking. Iterators are not supported. The following +// operations are supported: +// +// insert_or_assign: Insert a new element or update an existing element. +// insert: Insert a new element and return whether it was inserted. +// erase: Remove an element. +// contains: Returns true if the key is in the map. +// find: Returns != end() if found, value is in ret->second. +// pop: Erases and returns the erased value if found. +// +// find/end: find returns a vaguely iterator-like type that can be compared to +// end and can use iter->second to retrieve the reference. This is to ease porting +// for existing code that combines the existence check and lookup in a single +// operation (and thus a single lock). i.e.: +// +// auto iter = map.find(key); +// if (iter != map.end()) { +// T t = iter->second; +// ... +// +// snapshot: Return an array of elements (key, value pairs) that satisfy an optional +// predicate. This can be used as a substitute for iterators in exceptional cases. +template > +class unordered_map { + // Aliases to avoid excessive typing. We can't easily auto these away because + // there are virtual methods in ValidationObject which return lock guards + // and those cannot use return type deduction. + using ReadLockGuard = std::shared_lock; + using WriteLockGuard = std::unique_lock; + + public: + template + void insert_or_assign(const Key &key, Args &&...args) { + uint32_t h = ConcurrentMapHashObject(key); + WriteLockGuard lock(locks[h].lock); + maps[h][key] = {std::forward(args)...}; + } + + template + bool insert(const Key &key, Args &&...args) { + uint32_t h = ConcurrentMapHashObject(key); + WriteLockGuard lock(locks[h].lock); + auto ret = maps[h].emplace(key, std::forward(args)...); + return ret.second; + } + + // returns size_type + size_t erase(const Key &key) { + uint32_t h = ConcurrentMapHashObject(key); + WriteLockGuard lock(locks[h].lock); + return maps[h].erase(key); + } + + bool contains(const Key &key) const { + uint32_t h = ConcurrentMapHashObject(key); + ReadLockGuard lock(locks[h].lock); + return maps[h].count(key) != 0; + } + + // type returned by find() and end(). + class FindResult { + public: + FindResult(bool a, T b) : result(a, std::move(b)) {} + + // == and != only support comparing against end() + bool operator==(const FindResult &other) const { + if (result.first == false && other.result.first == false) { + return true; + } + return false; + } + bool operator!=(const FindResult &other) const { return !(*this == other); } + + // Make -> act kind of like an iterator. + std::pair *operator->() { return &result; } + const std::pair *operator->() const { return &result; } + + private: + // (found, reference to element) + std::pair result; + }; + + // find()/end() return a FindResult containing a copy of the value. For end(), + // return a default value. + FindResult end() const { return FindResult(false, T()); } + FindResult cend() const { return end(); } + + FindResult find(const Key &key) const { + uint32_t h = ConcurrentMapHashObject(key); + ReadLockGuard lock(locks[h].lock); + + auto itr = maps[h].find(key); + const bool found = itr != maps[h].end(); + + if (found) { + return FindResult(true, itr->second); + } else { + return end(); + } + } + + FindResult pop(const Key &key) { + uint32_t h = ConcurrentMapHashObject(key); + WriteLockGuard lock(locks[h].lock); + + auto itr = maps[h].find(key); + const bool found = itr != maps[h].end(); + + if (found) { + auto ret = FindResult(true, itr->second); + maps[h].erase(itr); + return ret; + } else { + return end(); + } + } + + std::vector> snapshot(std::function f = nullptr) const { + std::vector> ret; + for (int h = 0; h < BUCKETS; ++h) { + ReadLockGuard lock(locks[h].lock); + for (const auto &j : maps[h]) { + if (!f || f(j.second)) { + ret.emplace_back(j.first, j.second); + } + } + } + return ret; + } + + void clear() { + for (int h = 0; h < BUCKETS; ++h) { + WriteLockGuard lock(locks[h].lock); + maps[h].clear(); + } + } + + size_t size() const { + size_t result = 0; + for (int h = 0; h < BUCKETS; ++h) { + ReadLockGuard lock(locks[h].lock); + result += maps[h].size(); + } + return result; + } + + bool empty() const { + bool result = 0; + for (int h = 0; h < BUCKETS; ++h) { + ReadLockGuard lock(locks[h].lock); + result |= maps[h].empty(); + } + return result; + } + + private: + static const int BUCKETS = (1 << BUCKETSLOG2); + + Map maps[BUCKETS]; + struct alignas(get_hardware_destructive_interference_size()) AlignedSharedMutex { + std::shared_mutex lock; + }; + mutable std::array locks; + + uint32_t ConcurrentMapHashObject(const Key &object) const { + uint64_t u64 = (uint64_t)(uintptr_t)object; + uint32_t hash = (uint32_t)(u64 >> 32) + (uint32_t)u64; + hash ^= (hash >> BUCKETSLOG2) ^ (hash >> (2 * BUCKETSLOG2)); + hash &= (BUCKETS - 1); + return hash; + } +}; +} // namespace concurrent +} // namespace vku diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp new file mode 100644 index 0000000..4efcdcf --- /dev/null +++ b/include/vulkan/utility/vk_safe_struct.hpp @@ -0,0 +1,18472 @@ +// *** THIS FILE IS GENERATED - DO NOT EDIT *** +// See safe_struct_generator.py for modifications + +/*************************************************************************** + * + * Copyright (c) 2015-2024 The Khronos Group Inc. + * Copyright (c) 2015-2024 Valve Corporation + * Copyright (c) 2015-2024 LunarG, Inc. + * Copyright (c) 2015-2024 Google Inc. + * + * SPDX-License-Identifier: Apache-2.0 + * + ****************************************************************************/ + +// NOLINTBEGIN + +#pragma once +#include +#include + +#include + +namespace vku { + +struct safe_VkBufferMemoryBarrier { + VkStructureType sType; + const void* pNext{}; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; + + safe_VkBufferMemoryBarrier(const VkBufferMemoryBarrier* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkBufferMemoryBarrier(const safe_VkBufferMemoryBarrier& copy_src); + safe_VkBufferMemoryBarrier& operator=(const safe_VkBufferMemoryBarrier& copy_src); + safe_VkBufferMemoryBarrier(); + ~safe_VkBufferMemoryBarrier(); + void initialize(const VkBufferMemoryBarrier* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBufferMemoryBarrier* copy_src, PNextCopyState* copy_state = {}); + VkBufferMemoryBarrier* ptr() { return reinterpret_cast(this); } + VkBufferMemoryBarrier const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImageMemoryBarrier { + VkStructureType sType; + const void* pNext{}; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; + + safe_VkImageMemoryBarrier(const VkImageMemoryBarrier* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImageMemoryBarrier(const safe_VkImageMemoryBarrier& copy_src); + safe_VkImageMemoryBarrier& operator=(const safe_VkImageMemoryBarrier& copy_src); + safe_VkImageMemoryBarrier(); + ~safe_VkImageMemoryBarrier(); + void initialize(const VkImageMemoryBarrier* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageMemoryBarrier* copy_src, PNextCopyState* copy_state = {}); + VkImageMemoryBarrier* ptr() { return reinterpret_cast(this); } + VkImageMemoryBarrier const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkMemoryBarrier { + VkStructureType sType; + const void* pNext{}; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + + safe_VkMemoryBarrier(const VkMemoryBarrier* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMemoryBarrier(const safe_VkMemoryBarrier& copy_src); + safe_VkMemoryBarrier& operator=(const safe_VkMemoryBarrier& copy_src); + safe_VkMemoryBarrier(); + ~safe_VkMemoryBarrier(); + void initialize(const VkMemoryBarrier* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryBarrier* copy_src, PNextCopyState* copy_state = {}); + VkMemoryBarrier* ptr() { return reinterpret_cast(this); } + VkMemoryBarrier const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkAllocationCallbacks { + void* pUserData{}; + PFN_vkAllocationFunction pfnAllocation; + PFN_vkReallocationFunction pfnReallocation; + PFN_vkFreeFunction pfnFree; + PFN_vkInternalAllocationNotification pfnInternalAllocation; + PFN_vkInternalFreeNotification pfnInternalFree; + + safe_VkAllocationCallbacks(const VkAllocationCallbacks* in_struct, PNextCopyState* copy_state = {}); + safe_VkAllocationCallbacks(const safe_VkAllocationCallbacks& copy_src); + safe_VkAllocationCallbacks& operator=(const safe_VkAllocationCallbacks& copy_src); + safe_VkAllocationCallbacks(); + ~safe_VkAllocationCallbacks(); + void initialize(const VkAllocationCallbacks* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAllocationCallbacks* copy_src, PNextCopyState* copy_state = {}); + VkAllocationCallbacks* ptr() { return reinterpret_cast(this); } + VkAllocationCallbacks const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkApplicationInfo { + VkStructureType sType; + const void* pNext{}; + const char* pApplicationName{}; + uint32_t applicationVersion; + const char* pEngineName{}; + uint32_t engineVersion; + uint32_t apiVersion; + + safe_VkApplicationInfo(const VkApplicationInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkApplicationInfo(const safe_VkApplicationInfo& copy_src); + safe_VkApplicationInfo& operator=(const safe_VkApplicationInfo& copy_src); + safe_VkApplicationInfo(); + ~safe_VkApplicationInfo(); + void initialize(const VkApplicationInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkApplicationInfo* copy_src, PNextCopyState* copy_state = {}); + VkApplicationInfo* ptr() { return reinterpret_cast(this); } + VkApplicationInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkInstanceCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkInstanceCreateFlags flags; + safe_VkApplicationInfo* pApplicationInfo{}; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames{}; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames{}; + + safe_VkInstanceCreateInfo(const VkInstanceCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkInstanceCreateInfo(const safe_VkInstanceCreateInfo& copy_src); + safe_VkInstanceCreateInfo& operator=(const safe_VkInstanceCreateInfo& copy_src); + safe_VkInstanceCreateInfo(); + ~safe_VkInstanceCreateInfo(); + void initialize(const VkInstanceCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkInstanceCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkInstanceCreateInfo* ptr() { return reinterpret_cast(this); } + VkInstanceCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDeviceQueueCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueCount; + const float* pQueuePriorities{}; + + safe_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDeviceQueueCreateInfo(const safe_VkDeviceQueueCreateInfo& copy_src); + safe_VkDeviceQueueCreateInfo& operator=(const safe_VkDeviceQueueCreateInfo& copy_src); + safe_VkDeviceQueueCreateInfo(); + ~safe_VkDeviceQueueCreateInfo(); + void initialize(const VkDeviceQueueCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceQueueCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkDeviceQueueCreateInfo* ptr() { return reinterpret_cast(this); } + VkDeviceQueueCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDeviceCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkDeviceCreateFlags flags; + uint32_t queueCreateInfoCount; + safe_VkDeviceQueueCreateInfo* pQueueCreateInfos{}; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames{}; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames{}; + const VkPhysicalDeviceFeatures* pEnabledFeatures{}; + + safe_VkDeviceCreateInfo(const VkDeviceCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDeviceCreateInfo(const safe_VkDeviceCreateInfo& copy_src); + safe_VkDeviceCreateInfo& operator=(const safe_VkDeviceCreateInfo& copy_src); + safe_VkDeviceCreateInfo(); + ~safe_VkDeviceCreateInfo(); + void initialize(const VkDeviceCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkDeviceCreateInfo* ptr() { return reinterpret_cast(this); } + VkDeviceCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSubmitInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t waitSemaphoreCount; + VkSemaphore* pWaitSemaphores{}; + const VkPipelineStageFlags* pWaitDstStageMask{}; + uint32_t commandBufferCount; + VkCommandBuffer* pCommandBuffers{}; + uint32_t signalSemaphoreCount; + VkSemaphore* pSignalSemaphores{}; + + safe_VkSubmitInfo(const VkSubmitInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSubmitInfo(const safe_VkSubmitInfo& copy_src); + safe_VkSubmitInfo& operator=(const safe_VkSubmitInfo& copy_src); + safe_VkSubmitInfo(); + ~safe_VkSubmitInfo(); + void initialize(const VkSubmitInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSubmitInfo* copy_src, PNextCopyState* copy_state = {}); + VkSubmitInfo* ptr() { return reinterpret_cast(this); } + VkSubmitInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkMappedMemoryRange { + VkStructureType sType; + const void* pNext{}; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; + + safe_VkMappedMemoryRange(const VkMappedMemoryRange* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMappedMemoryRange(const safe_VkMappedMemoryRange& copy_src); + safe_VkMappedMemoryRange& operator=(const safe_VkMappedMemoryRange& copy_src); + safe_VkMappedMemoryRange(); + ~safe_VkMappedMemoryRange(); + void initialize(const VkMappedMemoryRange* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMappedMemoryRange* copy_src, PNextCopyState* copy_state = {}); + VkMappedMemoryRange* ptr() { return reinterpret_cast(this); } + VkMappedMemoryRange const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkMemoryAllocateInfo { + VkStructureType sType; + const void* pNext{}; + VkDeviceSize allocationSize; + uint32_t memoryTypeIndex; + + safe_VkMemoryAllocateInfo(const VkMemoryAllocateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMemoryAllocateInfo(const safe_VkMemoryAllocateInfo& copy_src); + safe_VkMemoryAllocateInfo& operator=(const safe_VkMemoryAllocateInfo& copy_src); + safe_VkMemoryAllocateInfo(); + ~safe_VkMemoryAllocateInfo(); + void initialize(const VkMemoryAllocateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryAllocateInfo* copy_src, PNextCopyState* copy_state = {}); + VkMemoryAllocateInfo* ptr() { return reinterpret_cast(this); } + VkMemoryAllocateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSparseBufferMemoryBindInfo { + VkBuffer buffer; + uint32_t bindCount; + VkSparseMemoryBind* pBinds{}; + + safe_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo* in_struct, PNextCopyState* copy_state = {}); + safe_VkSparseBufferMemoryBindInfo(const safe_VkSparseBufferMemoryBindInfo& copy_src); + safe_VkSparseBufferMemoryBindInfo& operator=(const safe_VkSparseBufferMemoryBindInfo& copy_src); + safe_VkSparseBufferMemoryBindInfo(); + ~safe_VkSparseBufferMemoryBindInfo(); + void initialize(const VkSparseBufferMemoryBindInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSparseBufferMemoryBindInfo* copy_src, PNextCopyState* copy_state = {}); + VkSparseBufferMemoryBindInfo* ptr() { return reinterpret_cast(this); } + VkSparseBufferMemoryBindInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSparseImageOpaqueMemoryBindInfo { + VkImage image; + uint32_t bindCount; + VkSparseMemoryBind* pBinds{}; + + safe_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo* in_struct, PNextCopyState* copy_state = {}); + safe_VkSparseImageOpaqueMemoryBindInfo(const safe_VkSparseImageOpaqueMemoryBindInfo& copy_src); + safe_VkSparseImageOpaqueMemoryBindInfo& operator=(const safe_VkSparseImageOpaqueMemoryBindInfo& copy_src); + safe_VkSparseImageOpaqueMemoryBindInfo(); + ~safe_VkSparseImageOpaqueMemoryBindInfo(); + void initialize(const VkSparseImageOpaqueMemoryBindInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSparseImageOpaqueMemoryBindInfo* copy_src, PNextCopyState* copy_state = {}); + VkSparseImageOpaqueMemoryBindInfo* ptr() { return reinterpret_cast(this); } + VkSparseImageOpaqueMemoryBindInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSparseImageMemoryBindInfo { + VkImage image; + uint32_t bindCount; + VkSparseImageMemoryBind* pBinds{}; + + safe_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo* in_struct, PNextCopyState* copy_state = {}); + safe_VkSparseImageMemoryBindInfo(const safe_VkSparseImageMemoryBindInfo& copy_src); + safe_VkSparseImageMemoryBindInfo& operator=(const safe_VkSparseImageMemoryBindInfo& copy_src); + safe_VkSparseImageMemoryBindInfo(); + ~safe_VkSparseImageMemoryBindInfo(); + void initialize(const VkSparseImageMemoryBindInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSparseImageMemoryBindInfo* copy_src, PNextCopyState* copy_state = {}); + VkSparseImageMemoryBindInfo* ptr() { return reinterpret_cast(this); } + VkSparseImageMemoryBindInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkBindSparseInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t waitSemaphoreCount; + VkSemaphore* pWaitSemaphores{}; + uint32_t bufferBindCount; + safe_VkSparseBufferMemoryBindInfo* pBufferBinds{}; + uint32_t imageOpaqueBindCount; + safe_VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds{}; + uint32_t imageBindCount; + safe_VkSparseImageMemoryBindInfo* pImageBinds{}; + uint32_t signalSemaphoreCount; + VkSemaphore* pSignalSemaphores{}; + + safe_VkBindSparseInfo(const VkBindSparseInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkBindSparseInfo(const safe_VkBindSparseInfo& copy_src); + safe_VkBindSparseInfo& operator=(const safe_VkBindSparseInfo& copy_src); + safe_VkBindSparseInfo(); + ~safe_VkBindSparseInfo(); + void initialize(const VkBindSparseInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBindSparseInfo* copy_src, PNextCopyState* copy_state = {}); + VkBindSparseInfo* ptr() { return reinterpret_cast(this); } + VkBindSparseInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkFenceCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkFenceCreateFlags flags; + + safe_VkFenceCreateInfo(const VkFenceCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkFenceCreateInfo(const safe_VkFenceCreateInfo& copy_src); + safe_VkFenceCreateInfo& operator=(const safe_VkFenceCreateInfo& copy_src); + safe_VkFenceCreateInfo(); + ~safe_VkFenceCreateInfo(); + void initialize(const VkFenceCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkFenceCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkFenceCreateInfo* ptr() { return reinterpret_cast(this); } + VkFenceCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSemaphoreCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkSemaphoreCreateFlags flags; + + safe_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSemaphoreCreateInfo(const safe_VkSemaphoreCreateInfo& copy_src); + safe_VkSemaphoreCreateInfo& operator=(const safe_VkSemaphoreCreateInfo& copy_src); + safe_VkSemaphoreCreateInfo(); + ~safe_VkSemaphoreCreateInfo(); + void initialize(const VkSemaphoreCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSemaphoreCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkSemaphoreCreateInfo* ptr() { return reinterpret_cast(this); } + VkSemaphoreCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkEventCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkEventCreateFlags flags; + + safe_VkEventCreateInfo(const VkEventCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkEventCreateInfo(const safe_VkEventCreateInfo& copy_src); + safe_VkEventCreateInfo& operator=(const safe_VkEventCreateInfo& copy_src); + safe_VkEventCreateInfo(); + ~safe_VkEventCreateInfo(); + void initialize(const VkEventCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkEventCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkEventCreateInfo* ptr() { return reinterpret_cast(this); } + VkEventCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkQueryPoolCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkQueryPoolCreateFlags flags; + VkQueryType queryType; + uint32_t queryCount; + VkQueryPipelineStatisticFlags pipelineStatistics; + + safe_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkQueryPoolCreateInfo(const safe_VkQueryPoolCreateInfo& copy_src); + safe_VkQueryPoolCreateInfo& operator=(const safe_VkQueryPoolCreateInfo& copy_src); + safe_VkQueryPoolCreateInfo(); + ~safe_VkQueryPoolCreateInfo(); + void initialize(const VkQueryPoolCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkQueryPoolCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkQueryPoolCreateInfo* ptr() { return reinterpret_cast(this); } + VkQueryPoolCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkBufferCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkBufferCreateFlags flags; + VkDeviceSize size; + VkBufferUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices{}; + + safe_VkBufferCreateInfo(const VkBufferCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkBufferCreateInfo(const safe_VkBufferCreateInfo& copy_src); + safe_VkBufferCreateInfo& operator=(const safe_VkBufferCreateInfo& copy_src); + safe_VkBufferCreateInfo(); + ~safe_VkBufferCreateInfo(); + void initialize(const VkBufferCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBufferCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkBufferCreateInfo* ptr() { return reinterpret_cast(this); } + VkBufferCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkBufferViewCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkBufferViewCreateFlags flags; + VkBuffer buffer; + VkFormat format; + VkDeviceSize offset; + VkDeviceSize range; + + safe_VkBufferViewCreateInfo(const VkBufferViewCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkBufferViewCreateInfo(const safe_VkBufferViewCreateInfo& copy_src); + safe_VkBufferViewCreateInfo& operator=(const safe_VkBufferViewCreateInfo& copy_src); + safe_VkBufferViewCreateInfo(); + ~safe_VkBufferViewCreateInfo(); + void initialize(const VkBufferViewCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBufferViewCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkBufferViewCreateInfo* ptr() { return reinterpret_cast(this); } + VkBufferViewCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImageCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkImageCreateFlags flags; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; + uint32_t mipLevels; + uint32_t arrayLayers; + VkSampleCountFlagBits samples; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices{}; + VkImageLayout initialLayout; + + safe_VkImageCreateInfo(const VkImageCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImageCreateInfo(const safe_VkImageCreateInfo& copy_src); + safe_VkImageCreateInfo& operator=(const safe_VkImageCreateInfo& copy_src); + safe_VkImageCreateInfo(); + ~safe_VkImageCreateInfo(); + void initialize(const VkImageCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkImageCreateInfo* ptr() { return reinterpret_cast(this); } + VkImageCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImageViewCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkImageViewCreateFlags flags; + VkImage image; + VkImageViewType viewType; + VkFormat format; + VkComponentMapping components; + VkImageSubresourceRange subresourceRange; + + safe_VkImageViewCreateInfo(const VkImageViewCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImageViewCreateInfo(const safe_VkImageViewCreateInfo& copy_src); + safe_VkImageViewCreateInfo& operator=(const safe_VkImageViewCreateInfo& copy_src); + safe_VkImageViewCreateInfo(); + ~safe_VkImageViewCreateInfo(); + void initialize(const VkImageViewCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageViewCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkImageViewCreateInfo* ptr() { return reinterpret_cast(this); } + VkImageViewCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkShaderModuleCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkShaderModuleCreateFlags flags; + size_t codeSize; + const uint32_t* pCode{}; + + safe_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkShaderModuleCreateInfo(const safe_VkShaderModuleCreateInfo& copy_src); + safe_VkShaderModuleCreateInfo& operator=(const safe_VkShaderModuleCreateInfo& copy_src); + safe_VkShaderModuleCreateInfo(); + ~safe_VkShaderModuleCreateInfo(); + void initialize(const VkShaderModuleCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkShaderModuleCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkShaderModuleCreateInfo* ptr() { return reinterpret_cast(this); } + VkShaderModuleCreateInfo const* ptr() const { return reinterpret_cast(this); } + + // Primarily intended for use by GPUAV when replacing shader module code with instrumented code + template + void SetCode(const Container& code) { + delete[] pCode; + codeSize = static_cast(code.size() * sizeof(uint32_t)); + pCode = new uint32_t[code.size()]; + std::copy(&code.front(), &code.back() + 1, const_cast(pCode)); + } +}; +struct safe_VkPipelineCacheCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkPipelineCacheCreateFlags flags; + size_t initialDataSize; + const void* pInitialData{}; + + safe_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineCacheCreateInfo(const safe_VkPipelineCacheCreateInfo& copy_src); + safe_VkPipelineCacheCreateInfo& operator=(const safe_VkPipelineCacheCreateInfo& copy_src); + safe_VkPipelineCacheCreateInfo(); + ~safe_VkPipelineCacheCreateInfo(); + void initialize(const VkPipelineCacheCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineCacheCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineCacheCreateInfo* ptr() { return reinterpret_cast(this); } + VkPipelineCacheCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSpecializationInfo { + uint32_t mapEntryCount; + const VkSpecializationMapEntry* pMapEntries{}; + size_t dataSize; + const void* pData{}; + + safe_VkSpecializationInfo(const VkSpecializationInfo* in_struct, PNextCopyState* copy_state = {}); + safe_VkSpecializationInfo(const safe_VkSpecializationInfo& copy_src); + safe_VkSpecializationInfo& operator=(const safe_VkSpecializationInfo& copy_src); + safe_VkSpecializationInfo(); + ~safe_VkSpecializationInfo(); + void initialize(const VkSpecializationInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSpecializationInfo* copy_src, PNextCopyState* copy_state = {}); + VkSpecializationInfo* ptr() { return reinterpret_cast(this); } + VkSpecializationInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPipelineShaderStageCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkPipelineShaderStageCreateFlags flags; + VkShaderStageFlagBits stage; + VkShaderModule module; + const char* pName{}; + safe_VkSpecializationInfo* pSpecializationInfo{}; + + safe_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineShaderStageCreateInfo(const safe_VkPipelineShaderStageCreateInfo& copy_src); + safe_VkPipelineShaderStageCreateInfo& operator=(const safe_VkPipelineShaderStageCreateInfo& copy_src); + safe_VkPipelineShaderStageCreateInfo(); + ~safe_VkPipelineShaderStageCreateInfo(); + void initialize(const VkPipelineShaderStageCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineShaderStageCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineShaderStageCreateInfo* ptr() { return reinterpret_cast(this); } + VkPipelineShaderStageCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkComputePipelineCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkPipelineCreateFlags flags; + safe_VkPipelineShaderStageCreateInfo stage; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; + + safe_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkComputePipelineCreateInfo(const safe_VkComputePipelineCreateInfo& copy_src); + safe_VkComputePipelineCreateInfo& operator=(const safe_VkComputePipelineCreateInfo& copy_src); + safe_VkComputePipelineCreateInfo(); + ~safe_VkComputePipelineCreateInfo(); + void initialize(const VkComputePipelineCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkComputePipelineCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkComputePipelineCreateInfo* ptr() { return reinterpret_cast(this); } + VkComputePipelineCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPipelineVertexInputStateCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkPipelineVertexInputStateCreateFlags flags; + uint32_t vertexBindingDescriptionCount; + const VkVertexInputBindingDescription* pVertexBindingDescriptions{}; + uint32_t vertexAttributeDescriptionCount; + const VkVertexInputAttributeDescription* pVertexAttributeDescriptions{}; + + safe_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineVertexInputStateCreateInfo(const safe_VkPipelineVertexInputStateCreateInfo& copy_src); + safe_VkPipelineVertexInputStateCreateInfo& operator=(const safe_VkPipelineVertexInputStateCreateInfo& copy_src); + safe_VkPipelineVertexInputStateCreateInfo(); + ~safe_VkPipelineVertexInputStateCreateInfo(); + void initialize(const VkPipelineVertexInputStateCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineVertexInputStateCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineVertexInputStateCreateInfo* ptr() { return reinterpret_cast(this); } + VkPipelineVertexInputStateCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineInputAssemblyStateCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkPipelineInputAssemblyStateCreateFlags flags; + VkPrimitiveTopology topology; + VkBool32 primitiveRestartEnable; + + safe_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineInputAssemblyStateCreateInfo(const safe_VkPipelineInputAssemblyStateCreateInfo& copy_src); + safe_VkPipelineInputAssemblyStateCreateInfo& operator=(const safe_VkPipelineInputAssemblyStateCreateInfo& copy_src); + safe_VkPipelineInputAssemblyStateCreateInfo(); + ~safe_VkPipelineInputAssemblyStateCreateInfo(); + void initialize(const VkPipelineInputAssemblyStateCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineInputAssemblyStateCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineInputAssemblyStateCreateInfo* ptr() { return reinterpret_cast(this); } + VkPipelineInputAssemblyStateCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineTessellationStateCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkPipelineTessellationStateCreateFlags flags; + uint32_t patchControlPoints; + + safe_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineTessellationStateCreateInfo(const safe_VkPipelineTessellationStateCreateInfo& copy_src); + safe_VkPipelineTessellationStateCreateInfo& operator=(const safe_VkPipelineTessellationStateCreateInfo& copy_src); + safe_VkPipelineTessellationStateCreateInfo(); + ~safe_VkPipelineTessellationStateCreateInfo(); + void initialize(const VkPipelineTessellationStateCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineTessellationStateCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineTessellationStateCreateInfo* ptr() { return reinterpret_cast(this); } + VkPipelineTessellationStateCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineViewportStateCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkPipelineViewportStateCreateFlags flags; + uint32_t viewportCount; + const VkViewport* pViewports{}; + uint32_t scissorCount; + const VkRect2D* pScissors{}; + + safe_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports, + const bool is_dynamic_scissors, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineViewportStateCreateInfo(const safe_VkPipelineViewportStateCreateInfo& copy_src); + safe_VkPipelineViewportStateCreateInfo& operator=(const safe_VkPipelineViewportStateCreateInfo& copy_src); + safe_VkPipelineViewportStateCreateInfo(); + ~safe_VkPipelineViewportStateCreateInfo(); + void initialize(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports, + const bool is_dynamic_scissors, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineViewportStateCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineViewportStateCreateInfo* ptr() { return reinterpret_cast(this); } + VkPipelineViewportStateCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineRasterizationStateCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkPipelineRasterizationStateCreateFlags flags; + VkBool32 depthClampEnable; + VkBool32 rasterizerDiscardEnable; + VkPolygonMode polygonMode; + VkCullModeFlags cullMode; + VkFrontFace frontFace; + VkBool32 depthBiasEnable; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + float lineWidth; + + safe_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineRasterizationStateCreateInfo(const safe_VkPipelineRasterizationStateCreateInfo& copy_src); + safe_VkPipelineRasterizationStateCreateInfo& operator=(const safe_VkPipelineRasterizationStateCreateInfo& copy_src); + safe_VkPipelineRasterizationStateCreateInfo(); + ~safe_VkPipelineRasterizationStateCreateInfo(); + void initialize(const VkPipelineRasterizationStateCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineRasterizationStateCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineRasterizationStateCreateInfo* ptr() { return reinterpret_cast(this); } + VkPipelineRasterizationStateCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineMultisampleStateCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkPipelineMultisampleStateCreateFlags flags; + VkSampleCountFlagBits rasterizationSamples; + VkBool32 sampleShadingEnable; + float minSampleShading; + const VkSampleMask* pSampleMask{}; + VkBool32 alphaToCoverageEnable; + VkBool32 alphaToOneEnable; + + safe_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineMultisampleStateCreateInfo(const safe_VkPipelineMultisampleStateCreateInfo& copy_src); + safe_VkPipelineMultisampleStateCreateInfo& operator=(const safe_VkPipelineMultisampleStateCreateInfo& copy_src); + safe_VkPipelineMultisampleStateCreateInfo(); + ~safe_VkPipelineMultisampleStateCreateInfo(); + void initialize(const VkPipelineMultisampleStateCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineMultisampleStateCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineMultisampleStateCreateInfo* ptr() { return reinterpret_cast(this); } + VkPipelineMultisampleStateCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineDepthStencilStateCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkPipelineDepthStencilStateCreateFlags flags; + VkBool32 depthTestEnable; + VkBool32 depthWriteEnable; + VkCompareOp depthCompareOp; + VkBool32 depthBoundsTestEnable; + VkBool32 stencilTestEnable; + VkStencilOpState front; + VkStencilOpState back; + float minDepthBounds; + float maxDepthBounds; + + safe_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineDepthStencilStateCreateInfo(const safe_VkPipelineDepthStencilStateCreateInfo& copy_src); + safe_VkPipelineDepthStencilStateCreateInfo& operator=(const safe_VkPipelineDepthStencilStateCreateInfo& copy_src); + safe_VkPipelineDepthStencilStateCreateInfo(); + ~safe_VkPipelineDepthStencilStateCreateInfo(); + void initialize(const VkPipelineDepthStencilStateCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineDepthStencilStateCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineDepthStencilStateCreateInfo* ptr() { return reinterpret_cast(this); } + VkPipelineDepthStencilStateCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineColorBlendStateCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkPipelineColorBlendStateCreateFlags flags; + VkBool32 logicOpEnable; + VkLogicOp logicOp; + uint32_t attachmentCount; + const VkPipelineColorBlendAttachmentState* pAttachments{}; + float blendConstants[4]; + + safe_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineColorBlendStateCreateInfo(const safe_VkPipelineColorBlendStateCreateInfo& copy_src); + safe_VkPipelineColorBlendStateCreateInfo& operator=(const safe_VkPipelineColorBlendStateCreateInfo& copy_src); + safe_VkPipelineColorBlendStateCreateInfo(); + ~safe_VkPipelineColorBlendStateCreateInfo(); + void initialize(const VkPipelineColorBlendStateCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineColorBlendStateCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineColorBlendStateCreateInfo* ptr() { return reinterpret_cast(this); } + VkPipelineColorBlendStateCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineDynamicStateCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkPipelineDynamicStateCreateFlags flags; + uint32_t dynamicStateCount; + const VkDynamicState* pDynamicStates{}; + + safe_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineDynamicStateCreateInfo(const safe_VkPipelineDynamicStateCreateInfo& copy_src); + safe_VkPipelineDynamicStateCreateInfo& operator=(const safe_VkPipelineDynamicStateCreateInfo& copy_src); + safe_VkPipelineDynamicStateCreateInfo(); + ~safe_VkPipelineDynamicStateCreateInfo(); + void initialize(const VkPipelineDynamicStateCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineDynamicStateCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineDynamicStateCreateInfo* ptr() { return reinterpret_cast(this); } + VkPipelineDynamicStateCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkGraphicsPipelineCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkPipelineCreateFlags flags; + uint32_t stageCount; + safe_VkPipelineShaderStageCreateInfo* pStages{}; + safe_VkPipelineVertexInputStateCreateInfo* pVertexInputState{}; + safe_VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState{}; + safe_VkPipelineTessellationStateCreateInfo* pTessellationState{}; + safe_VkPipelineViewportStateCreateInfo* pViewportState{}; + safe_VkPipelineRasterizationStateCreateInfo* pRasterizationState{}; + safe_VkPipelineMultisampleStateCreateInfo* pMultisampleState{}; + safe_VkPipelineDepthStencilStateCreateInfo* pDepthStencilState{}; + safe_VkPipelineColorBlendStateCreateInfo* pColorBlendState{}; + safe_VkPipelineDynamicStateCreateInfo* pDynamicState{}; + VkPipelineLayout layout; + VkRenderPass renderPass; + uint32_t subpass; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; + + safe_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment, + const bool uses_depthstencil_attachment, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkGraphicsPipelineCreateInfo(const safe_VkGraphicsPipelineCreateInfo& copy_src); + safe_VkGraphicsPipelineCreateInfo& operator=(const safe_VkGraphicsPipelineCreateInfo& copy_src); + safe_VkGraphicsPipelineCreateInfo(); + ~safe_VkGraphicsPipelineCreateInfo(); + void initialize(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment, + const bool uses_depthstencil_attachment, PNextCopyState* copy_state = {}); + void initialize(const safe_VkGraphicsPipelineCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkGraphicsPipelineCreateInfo* ptr() { return reinterpret_cast(this); } + VkGraphicsPipelineCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPipelineLayoutCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkPipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + VkDescriptorSetLayout* pSetLayouts{}; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges{}; + + safe_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineLayoutCreateInfo(const safe_VkPipelineLayoutCreateInfo& copy_src); + safe_VkPipelineLayoutCreateInfo& operator=(const safe_VkPipelineLayoutCreateInfo& copy_src); + safe_VkPipelineLayoutCreateInfo(); + ~safe_VkPipelineLayoutCreateInfo(); + void initialize(const VkPipelineLayoutCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineLayoutCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineLayoutCreateInfo* ptr() { return reinterpret_cast(this); } + VkPipelineLayoutCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSamplerCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkSamplerCreateFlags flags; + VkFilter magFilter; + VkFilter minFilter; + VkSamplerMipmapMode mipmapMode; + VkSamplerAddressMode addressModeU; + VkSamplerAddressMode addressModeV; + VkSamplerAddressMode addressModeW; + float mipLodBias; + VkBool32 anisotropyEnable; + float maxAnisotropy; + VkBool32 compareEnable; + VkCompareOp compareOp; + float minLod; + float maxLod; + VkBorderColor borderColor; + VkBool32 unnormalizedCoordinates; + + safe_VkSamplerCreateInfo(const VkSamplerCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSamplerCreateInfo(const safe_VkSamplerCreateInfo& copy_src); + safe_VkSamplerCreateInfo& operator=(const safe_VkSamplerCreateInfo& copy_src); + safe_VkSamplerCreateInfo(); + ~safe_VkSamplerCreateInfo(); + void initialize(const VkSamplerCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSamplerCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkSamplerCreateInfo* ptr() { return reinterpret_cast(this); } + VkSamplerCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCopyDescriptorSet { + VkStructureType sType; + const void* pNext{}; + VkDescriptorSet srcSet; + uint32_t srcBinding; + uint32_t srcArrayElement; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + + safe_VkCopyDescriptorSet(const VkCopyDescriptorSet* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkCopyDescriptorSet(const safe_VkCopyDescriptorSet& copy_src); + safe_VkCopyDescriptorSet& operator=(const safe_VkCopyDescriptorSet& copy_src); + safe_VkCopyDescriptorSet(); + ~safe_VkCopyDescriptorSet(); + void initialize(const VkCopyDescriptorSet* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyDescriptorSet* copy_src, PNextCopyState* copy_state = {}); + VkCopyDescriptorSet* ptr() { return reinterpret_cast(this); } + VkCopyDescriptorSet const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDescriptorPoolCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkDescriptorPoolCreateFlags flags; + uint32_t maxSets; + uint32_t poolSizeCount; + const VkDescriptorPoolSize* pPoolSizes{}; + + safe_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDescriptorPoolCreateInfo(const safe_VkDescriptorPoolCreateInfo& copy_src); + safe_VkDescriptorPoolCreateInfo& operator=(const safe_VkDescriptorPoolCreateInfo& copy_src); + safe_VkDescriptorPoolCreateInfo(); + ~safe_VkDescriptorPoolCreateInfo(); + void initialize(const VkDescriptorPoolCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDescriptorPoolCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkDescriptorPoolCreateInfo* ptr() { return reinterpret_cast(this); } + VkDescriptorPoolCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDescriptorSetAllocateInfo { + VkStructureType sType; + const void* pNext{}; + VkDescriptorPool descriptorPool; + uint32_t descriptorSetCount; + VkDescriptorSetLayout* pSetLayouts{}; + + safe_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDescriptorSetAllocateInfo(const safe_VkDescriptorSetAllocateInfo& copy_src); + safe_VkDescriptorSetAllocateInfo& operator=(const safe_VkDescriptorSetAllocateInfo& copy_src); + safe_VkDescriptorSetAllocateInfo(); + ~safe_VkDescriptorSetAllocateInfo(); + void initialize(const VkDescriptorSetAllocateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDescriptorSetAllocateInfo* copy_src, PNextCopyState* copy_state = {}); + VkDescriptorSetAllocateInfo* ptr() { return reinterpret_cast(this); } + VkDescriptorSetAllocateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDescriptorSetLayoutBinding { + uint32_t binding; + VkDescriptorType descriptorType; + uint32_t descriptorCount; + VkShaderStageFlags stageFlags; + VkSampler* pImmutableSamplers{}; + + safe_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding* in_struct, PNextCopyState* copy_state = {}); + safe_VkDescriptorSetLayoutBinding(const safe_VkDescriptorSetLayoutBinding& copy_src); + safe_VkDescriptorSetLayoutBinding& operator=(const safe_VkDescriptorSetLayoutBinding& copy_src); + safe_VkDescriptorSetLayoutBinding(); + ~safe_VkDescriptorSetLayoutBinding(); + void initialize(const VkDescriptorSetLayoutBinding* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDescriptorSetLayoutBinding* copy_src, PNextCopyState* copy_state = {}); + VkDescriptorSetLayoutBinding* ptr() { return reinterpret_cast(this); } + VkDescriptorSetLayoutBinding const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDescriptorSetLayoutCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkDescriptorSetLayoutCreateFlags flags; + uint32_t bindingCount; + safe_VkDescriptorSetLayoutBinding* pBindings{}; + + safe_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDescriptorSetLayoutCreateInfo(const safe_VkDescriptorSetLayoutCreateInfo& copy_src); + safe_VkDescriptorSetLayoutCreateInfo& operator=(const safe_VkDescriptorSetLayoutCreateInfo& copy_src); + safe_VkDescriptorSetLayoutCreateInfo(); + ~safe_VkDescriptorSetLayoutCreateInfo(); + void initialize(const VkDescriptorSetLayoutCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDescriptorSetLayoutCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkDescriptorSetLayoutCreateInfo* ptr() { return reinterpret_cast(this); } + VkDescriptorSetLayoutCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkWriteDescriptorSet { + VkStructureType sType; + const void* pNext{}; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + VkDescriptorImageInfo* pImageInfo{}; + VkDescriptorBufferInfo* pBufferInfo{}; + VkBufferView* pTexelBufferView{}; + + safe_VkWriteDescriptorSet(const VkWriteDescriptorSet* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkWriteDescriptorSet(const safe_VkWriteDescriptorSet& copy_src); + safe_VkWriteDescriptorSet& operator=(const safe_VkWriteDescriptorSet& copy_src); + safe_VkWriteDescriptorSet(); + ~safe_VkWriteDescriptorSet(); + void initialize(const VkWriteDescriptorSet* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkWriteDescriptorSet* copy_src, PNextCopyState* copy_state = {}); + VkWriteDescriptorSet* ptr() { return reinterpret_cast(this); } + VkWriteDescriptorSet const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkFramebufferCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkFramebufferCreateFlags flags; + VkRenderPass renderPass; + uint32_t attachmentCount; + VkImageView* pAttachments{}; + uint32_t width; + uint32_t height; + uint32_t layers; + + safe_VkFramebufferCreateInfo(const VkFramebufferCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkFramebufferCreateInfo(const safe_VkFramebufferCreateInfo& copy_src); + safe_VkFramebufferCreateInfo& operator=(const safe_VkFramebufferCreateInfo& copy_src); + safe_VkFramebufferCreateInfo(); + ~safe_VkFramebufferCreateInfo(); + void initialize(const VkFramebufferCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkFramebufferCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkFramebufferCreateInfo* ptr() { return reinterpret_cast(this); } + VkFramebufferCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSubpassDescription { + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t inputAttachmentCount; + const VkAttachmentReference* pInputAttachments{}; + uint32_t colorAttachmentCount; + const VkAttachmentReference* pColorAttachments{}; + const VkAttachmentReference* pResolveAttachments{}; + const VkAttachmentReference* pDepthStencilAttachment{}; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments{}; + + safe_VkSubpassDescription(const VkSubpassDescription* in_struct, PNextCopyState* copy_state = {}); + safe_VkSubpassDescription(const safe_VkSubpassDescription& copy_src); + safe_VkSubpassDescription& operator=(const safe_VkSubpassDescription& copy_src); + safe_VkSubpassDescription(); + ~safe_VkSubpassDescription(); + void initialize(const VkSubpassDescription* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSubpassDescription* copy_src, PNextCopyState* copy_state = {}); + VkSubpassDescription* ptr() { return reinterpret_cast(this); } + VkSubpassDescription const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkRenderPassCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + const VkAttachmentDescription* pAttachments{}; + uint32_t subpassCount; + safe_VkSubpassDescription* pSubpasses{}; + uint32_t dependencyCount; + const VkSubpassDependency* pDependencies{}; + + safe_VkRenderPassCreateInfo(const VkRenderPassCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkRenderPassCreateInfo(const safe_VkRenderPassCreateInfo& copy_src); + safe_VkRenderPassCreateInfo& operator=(const safe_VkRenderPassCreateInfo& copy_src); + safe_VkRenderPassCreateInfo(); + ~safe_VkRenderPassCreateInfo(); + void initialize(const VkRenderPassCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderPassCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkRenderPassCreateInfo* ptr() { return reinterpret_cast(this); } + VkRenderPassCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCommandPoolCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkCommandPoolCreateFlags flags; + uint32_t queueFamilyIndex; + + safe_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkCommandPoolCreateInfo(const safe_VkCommandPoolCreateInfo& copy_src); + safe_VkCommandPoolCreateInfo& operator=(const safe_VkCommandPoolCreateInfo& copy_src); + safe_VkCommandPoolCreateInfo(); + ~safe_VkCommandPoolCreateInfo(); + void initialize(const VkCommandPoolCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCommandPoolCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkCommandPoolCreateInfo* ptr() { return reinterpret_cast(this); } + VkCommandPoolCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCommandBufferAllocateInfo { + VkStructureType sType; + const void* pNext{}; + VkCommandPool commandPool; + VkCommandBufferLevel level; + uint32_t commandBufferCount; + + safe_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCommandBufferAllocateInfo(const safe_VkCommandBufferAllocateInfo& copy_src); + safe_VkCommandBufferAllocateInfo& operator=(const safe_VkCommandBufferAllocateInfo& copy_src); + safe_VkCommandBufferAllocateInfo(); + ~safe_VkCommandBufferAllocateInfo(); + void initialize(const VkCommandBufferAllocateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCommandBufferAllocateInfo* copy_src, PNextCopyState* copy_state = {}); + VkCommandBufferAllocateInfo* ptr() { return reinterpret_cast(this); } + VkCommandBufferAllocateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCommandBufferInheritanceInfo { + VkStructureType sType; + const void* pNext{}; + VkRenderPass renderPass; + uint32_t subpass; + VkFramebuffer framebuffer; + VkBool32 occlusionQueryEnable; + VkQueryControlFlags queryFlags; + VkQueryPipelineStatisticFlags pipelineStatistics; + + safe_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCommandBufferInheritanceInfo(const safe_VkCommandBufferInheritanceInfo& copy_src); + safe_VkCommandBufferInheritanceInfo& operator=(const safe_VkCommandBufferInheritanceInfo& copy_src); + safe_VkCommandBufferInheritanceInfo(); + ~safe_VkCommandBufferInheritanceInfo(); + void initialize(const VkCommandBufferInheritanceInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCommandBufferInheritanceInfo* copy_src, PNextCopyState* copy_state = {}); + VkCommandBufferInheritanceInfo* ptr() { return reinterpret_cast(this); } + VkCommandBufferInheritanceInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCommandBufferBeginInfo { + VkStructureType sType; + const void* pNext{}; + VkCommandBufferUsageFlags flags; + safe_VkCommandBufferInheritanceInfo* pInheritanceInfo{}; + + safe_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCommandBufferBeginInfo(const safe_VkCommandBufferBeginInfo& copy_src); + safe_VkCommandBufferBeginInfo& operator=(const safe_VkCommandBufferBeginInfo& copy_src); + safe_VkCommandBufferBeginInfo(); + ~safe_VkCommandBufferBeginInfo(); + void initialize(const VkCommandBufferBeginInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCommandBufferBeginInfo* copy_src, PNextCopyState* copy_state = {}); + VkCommandBufferBeginInfo* ptr() { return reinterpret_cast(this); } + VkCommandBufferBeginInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkRenderPassBeginInfo { + VkStructureType sType; + const void* pNext{}; + VkRenderPass renderPass; + VkFramebuffer framebuffer; + VkRect2D renderArea; + uint32_t clearValueCount; + const VkClearValue* pClearValues{}; + + safe_VkRenderPassBeginInfo(const VkRenderPassBeginInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkRenderPassBeginInfo(const safe_VkRenderPassBeginInfo& copy_src); + safe_VkRenderPassBeginInfo& operator=(const safe_VkRenderPassBeginInfo& copy_src); + safe_VkRenderPassBeginInfo(); + ~safe_VkRenderPassBeginInfo(); + void initialize(const VkRenderPassBeginInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderPassBeginInfo* copy_src, PNextCopyState* copy_state = {}); + VkRenderPassBeginInfo* ptr() { return reinterpret_cast(this); } + VkRenderPassBeginInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceSubgroupProperties { + VkStructureType sType; + void* pNext{}; + uint32_t subgroupSize; + VkShaderStageFlags supportedStages; + VkSubgroupFeatureFlags supportedOperations; + VkBool32 quadOperationsInAllStages; + + safe_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceSubgroupProperties(const safe_VkPhysicalDeviceSubgroupProperties& copy_src); + safe_VkPhysicalDeviceSubgroupProperties& operator=(const safe_VkPhysicalDeviceSubgroupProperties& copy_src); + safe_VkPhysicalDeviceSubgroupProperties(); + ~safe_VkPhysicalDeviceSubgroupProperties(); + void initialize(const VkPhysicalDeviceSubgroupProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceSubgroupProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceSubgroupProperties* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceSubgroupProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkBindBufferMemoryInfo { + VkStructureType sType; + const void* pNext{}; + VkBuffer buffer; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + + safe_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkBindBufferMemoryInfo(const safe_VkBindBufferMemoryInfo& copy_src); + safe_VkBindBufferMemoryInfo& operator=(const safe_VkBindBufferMemoryInfo& copy_src); + safe_VkBindBufferMemoryInfo(); + ~safe_VkBindBufferMemoryInfo(); + void initialize(const VkBindBufferMemoryInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBindBufferMemoryInfo* copy_src, PNextCopyState* copy_state = {}); + VkBindBufferMemoryInfo* ptr() { return reinterpret_cast(this); } + VkBindBufferMemoryInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkBindImageMemoryInfo { + VkStructureType sType; + const void* pNext{}; + VkImage image; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + + safe_VkBindImageMemoryInfo(const VkBindImageMemoryInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkBindImageMemoryInfo(const safe_VkBindImageMemoryInfo& copy_src); + safe_VkBindImageMemoryInfo& operator=(const safe_VkBindImageMemoryInfo& copy_src); + safe_VkBindImageMemoryInfo(); + ~safe_VkBindImageMemoryInfo(); + void initialize(const VkBindImageMemoryInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBindImageMemoryInfo* copy_src, PNextCopyState* copy_state = {}); + VkBindImageMemoryInfo* ptr() { return reinterpret_cast(this); } + VkBindImageMemoryInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDevice16BitStorageFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; + + safe_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevice16BitStorageFeatures(const safe_VkPhysicalDevice16BitStorageFeatures& copy_src); + safe_VkPhysicalDevice16BitStorageFeatures& operator=(const safe_VkPhysicalDevice16BitStorageFeatures& copy_src); + safe_VkPhysicalDevice16BitStorageFeatures(); + ~safe_VkPhysicalDevice16BitStorageFeatures(); + void initialize(const VkPhysicalDevice16BitStorageFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevice16BitStorageFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevice16BitStorageFeatures* ptr() { return reinterpret_cast(this); } + VkPhysicalDevice16BitStorageFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkMemoryDedicatedRequirements { + VkStructureType sType; + void* pNext{}; + VkBool32 prefersDedicatedAllocation; + VkBool32 requiresDedicatedAllocation; + + safe_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkMemoryDedicatedRequirements(const safe_VkMemoryDedicatedRequirements& copy_src); + safe_VkMemoryDedicatedRequirements& operator=(const safe_VkMemoryDedicatedRequirements& copy_src); + safe_VkMemoryDedicatedRequirements(); + ~safe_VkMemoryDedicatedRequirements(); + void initialize(const VkMemoryDedicatedRequirements* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryDedicatedRequirements* copy_src, PNextCopyState* copy_state = {}); + VkMemoryDedicatedRequirements* ptr() { return reinterpret_cast(this); } + VkMemoryDedicatedRequirements const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkMemoryDedicatedAllocateInfo { + VkStructureType sType; + const void* pNext{}; + VkImage image; + VkBuffer buffer; + + safe_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkMemoryDedicatedAllocateInfo(const safe_VkMemoryDedicatedAllocateInfo& copy_src); + safe_VkMemoryDedicatedAllocateInfo& operator=(const safe_VkMemoryDedicatedAllocateInfo& copy_src); + safe_VkMemoryDedicatedAllocateInfo(); + ~safe_VkMemoryDedicatedAllocateInfo(); + void initialize(const VkMemoryDedicatedAllocateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryDedicatedAllocateInfo* copy_src, PNextCopyState* copy_state = {}); + VkMemoryDedicatedAllocateInfo* ptr() { return reinterpret_cast(this); } + VkMemoryDedicatedAllocateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkMemoryAllocateFlagsInfo { + VkStructureType sType; + const void* pNext{}; + VkMemoryAllocateFlags flags; + uint32_t deviceMask; + + safe_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkMemoryAllocateFlagsInfo(const safe_VkMemoryAllocateFlagsInfo& copy_src); + safe_VkMemoryAllocateFlagsInfo& operator=(const safe_VkMemoryAllocateFlagsInfo& copy_src); + safe_VkMemoryAllocateFlagsInfo(); + ~safe_VkMemoryAllocateFlagsInfo(); + void initialize(const VkMemoryAllocateFlagsInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryAllocateFlagsInfo* copy_src, PNextCopyState* copy_state = {}); + VkMemoryAllocateFlagsInfo* ptr() { return reinterpret_cast(this); } + VkMemoryAllocateFlagsInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDeviceGroupRenderPassBeginInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t deviceMask; + uint32_t deviceRenderAreaCount; + const VkRect2D* pDeviceRenderAreas{}; + + safe_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDeviceGroupRenderPassBeginInfo(const safe_VkDeviceGroupRenderPassBeginInfo& copy_src); + safe_VkDeviceGroupRenderPassBeginInfo& operator=(const safe_VkDeviceGroupRenderPassBeginInfo& copy_src); + safe_VkDeviceGroupRenderPassBeginInfo(); + ~safe_VkDeviceGroupRenderPassBeginInfo(); + void initialize(const VkDeviceGroupRenderPassBeginInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceGroupRenderPassBeginInfo* copy_src, PNextCopyState* copy_state = {}); + VkDeviceGroupRenderPassBeginInfo* ptr() { return reinterpret_cast(this); } + VkDeviceGroupRenderPassBeginInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDeviceGroupCommandBufferBeginInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t deviceMask; + + safe_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDeviceGroupCommandBufferBeginInfo(const safe_VkDeviceGroupCommandBufferBeginInfo& copy_src); + safe_VkDeviceGroupCommandBufferBeginInfo& operator=(const safe_VkDeviceGroupCommandBufferBeginInfo& copy_src); + safe_VkDeviceGroupCommandBufferBeginInfo(); + ~safe_VkDeviceGroupCommandBufferBeginInfo(); + void initialize(const VkDeviceGroupCommandBufferBeginInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceGroupCommandBufferBeginInfo* copy_src, PNextCopyState* copy_state = {}); + VkDeviceGroupCommandBufferBeginInfo* ptr() { return reinterpret_cast(this); } + VkDeviceGroupCommandBufferBeginInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDeviceGroupSubmitInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t waitSemaphoreCount; + const uint32_t* pWaitSemaphoreDeviceIndices{}; + uint32_t commandBufferCount; + const uint32_t* pCommandBufferDeviceMasks{}; + uint32_t signalSemaphoreCount; + const uint32_t* pSignalSemaphoreDeviceIndices{}; + + safe_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDeviceGroupSubmitInfo(const safe_VkDeviceGroupSubmitInfo& copy_src); + safe_VkDeviceGroupSubmitInfo& operator=(const safe_VkDeviceGroupSubmitInfo& copy_src); + safe_VkDeviceGroupSubmitInfo(); + ~safe_VkDeviceGroupSubmitInfo(); + void initialize(const VkDeviceGroupSubmitInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceGroupSubmitInfo* copy_src, PNextCopyState* copy_state = {}); + VkDeviceGroupSubmitInfo* ptr() { return reinterpret_cast(this); } + VkDeviceGroupSubmitInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDeviceGroupBindSparseInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t resourceDeviceIndex; + uint32_t memoryDeviceIndex; + + safe_VkDeviceGroupBindSparseInfo(const VkDeviceGroupBindSparseInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDeviceGroupBindSparseInfo(const safe_VkDeviceGroupBindSparseInfo& copy_src); + safe_VkDeviceGroupBindSparseInfo& operator=(const safe_VkDeviceGroupBindSparseInfo& copy_src); + safe_VkDeviceGroupBindSparseInfo(); + ~safe_VkDeviceGroupBindSparseInfo(); + void initialize(const VkDeviceGroupBindSparseInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceGroupBindSparseInfo* copy_src, PNextCopyState* copy_state = {}); + VkDeviceGroupBindSparseInfo* ptr() { return reinterpret_cast(this); } + VkDeviceGroupBindSparseInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkBindBufferMemoryDeviceGroupInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices{}; + + safe_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkBindBufferMemoryDeviceGroupInfo(const safe_VkBindBufferMemoryDeviceGroupInfo& copy_src); + safe_VkBindBufferMemoryDeviceGroupInfo& operator=(const safe_VkBindBufferMemoryDeviceGroupInfo& copy_src); + safe_VkBindBufferMemoryDeviceGroupInfo(); + ~safe_VkBindBufferMemoryDeviceGroupInfo(); + void initialize(const VkBindBufferMemoryDeviceGroupInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBindBufferMemoryDeviceGroupInfo* copy_src, PNextCopyState* copy_state = {}); + VkBindBufferMemoryDeviceGroupInfo* ptr() { return reinterpret_cast(this); } + VkBindBufferMemoryDeviceGroupInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkBindImageMemoryDeviceGroupInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices{}; + uint32_t splitInstanceBindRegionCount; + const VkRect2D* pSplitInstanceBindRegions{}; + + safe_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkBindImageMemoryDeviceGroupInfo(const safe_VkBindImageMemoryDeviceGroupInfo& copy_src); + safe_VkBindImageMemoryDeviceGroupInfo& operator=(const safe_VkBindImageMemoryDeviceGroupInfo& copy_src); + safe_VkBindImageMemoryDeviceGroupInfo(); + ~safe_VkBindImageMemoryDeviceGroupInfo(); + void initialize(const VkBindImageMemoryDeviceGroupInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBindImageMemoryDeviceGroupInfo* copy_src, PNextCopyState* copy_state = {}); + VkBindImageMemoryDeviceGroupInfo* ptr() { return reinterpret_cast(this); } + VkBindImageMemoryDeviceGroupInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceGroupProperties { + VkStructureType sType; + void* pNext{}; + uint32_t physicalDeviceCount; + VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; + VkBool32 subsetAllocation; + + safe_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceGroupProperties(const safe_VkPhysicalDeviceGroupProperties& copy_src); + safe_VkPhysicalDeviceGroupProperties& operator=(const safe_VkPhysicalDeviceGroupProperties& copy_src); + safe_VkPhysicalDeviceGroupProperties(); + ~safe_VkPhysicalDeviceGroupProperties(); + void initialize(const VkPhysicalDeviceGroupProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceGroupProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceGroupProperties* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceGroupProperties const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDeviceGroupDeviceCreateInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t physicalDeviceCount; + VkPhysicalDevice* pPhysicalDevices{}; + + safe_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDeviceGroupDeviceCreateInfo(const safe_VkDeviceGroupDeviceCreateInfo& copy_src); + safe_VkDeviceGroupDeviceCreateInfo& operator=(const safe_VkDeviceGroupDeviceCreateInfo& copy_src); + safe_VkDeviceGroupDeviceCreateInfo(); + ~safe_VkDeviceGroupDeviceCreateInfo(); + void initialize(const VkDeviceGroupDeviceCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceGroupDeviceCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkDeviceGroupDeviceCreateInfo* ptr() { return reinterpret_cast(this); } + VkDeviceGroupDeviceCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkBufferMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext{}; + VkBuffer buffer; + + safe_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkBufferMemoryRequirementsInfo2(const safe_VkBufferMemoryRequirementsInfo2& copy_src); + safe_VkBufferMemoryRequirementsInfo2& operator=(const safe_VkBufferMemoryRequirementsInfo2& copy_src); + safe_VkBufferMemoryRequirementsInfo2(); + ~safe_VkBufferMemoryRequirementsInfo2(); + void initialize(const VkBufferMemoryRequirementsInfo2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBufferMemoryRequirementsInfo2* copy_src, PNextCopyState* copy_state = {}); + VkBufferMemoryRequirementsInfo2* ptr() { return reinterpret_cast(this); } + VkBufferMemoryRequirementsInfo2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImageMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext{}; + VkImage image; + + safe_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImageMemoryRequirementsInfo2(const safe_VkImageMemoryRequirementsInfo2& copy_src); + safe_VkImageMemoryRequirementsInfo2& operator=(const safe_VkImageMemoryRequirementsInfo2& copy_src); + safe_VkImageMemoryRequirementsInfo2(); + ~safe_VkImageMemoryRequirementsInfo2(); + void initialize(const VkImageMemoryRequirementsInfo2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageMemoryRequirementsInfo2* copy_src, PNextCopyState* copy_state = {}); + VkImageMemoryRequirementsInfo2* ptr() { return reinterpret_cast(this); } + VkImageMemoryRequirementsInfo2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImageSparseMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext{}; + VkImage image; + + safe_VkImageSparseMemoryRequirementsInfo2(const VkImageSparseMemoryRequirementsInfo2* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImageSparseMemoryRequirementsInfo2(const safe_VkImageSparseMemoryRequirementsInfo2& copy_src); + safe_VkImageSparseMemoryRequirementsInfo2& operator=(const safe_VkImageSparseMemoryRequirementsInfo2& copy_src); + safe_VkImageSparseMemoryRequirementsInfo2(); + ~safe_VkImageSparseMemoryRequirementsInfo2(); + void initialize(const VkImageSparseMemoryRequirementsInfo2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageSparseMemoryRequirementsInfo2* copy_src, PNextCopyState* copy_state = {}); + VkImageSparseMemoryRequirementsInfo2* ptr() { return reinterpret_cast(this); } + VkImageSparseMemoryRequirementsInfo2 const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkMemoryRequirements2 { + VkStructureType sType; + void* pNext{}; + VkMemoryRequirements memoryRequirements; + + safe_VkMemoryRequirements2(const VkMemoryRequirements2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMemoryRequirements2(const safe_VkMemoryRequirements2& copy_src); + safe_VkMemoryRequirements2& operator=(const safe_VkMemoryRequirements2& copy_src); + safe_VkMemoryRequirements2(); + ~safe_VkMemoryRequirements2(); + void initialize(const VkMemoryRequirements2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryRequirements2* copy_src, PNextCopyState* copy_state = {}); + VkMemoryRequirements2* ptr() { return reinterpret_cast(this); } + VkMemoryRequirements2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSparseImageMemoryRequirements2 { + VkStructureType sType; + void* pNext{}; + VkSparseImageMemoryRequirements memoryRequirements; + + safe_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSparseImageMemoryRequirements2(const safe_VkSparseImageMemoryRequirements2& copy_src); + safe_VkSparseImageMemoryRequirements2& operator=(const safe_VkSparseImageMemoryRequirements2& copy_src); + safe_VkSparseImageMemoryRequirements2(); + ~safe_VkSparseImageMemoryRequirements2(); + void initialize(const VkSparseImageMemoryRequirements2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSparseImageMemoryRequirements2* copy_src, PNextCopyState* copy_state = {}); + VkSparseImageMemoryRequirements2* ptr() { return reinterpret_cast(this); } + VkSparseImageMemoryRequirements2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceFeatures2 { + VkStructureType sType; + void* pNext{}; + VkPhysicalDeviceFeatures features; + + safe_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceFeatures2(const safe_VkPhysicalDeviceFeatures2& copy_src); + safe_VkPhysicalDeviceFeatures2& operator=(const safe_VkPhysicalDeviceFeatures2& copy_src); + safe_VkPhysicalDeviceFeatures2(); + ~safe_VkPhysicalDeviceFeatures2(); + void initialize(const VkPhysicalDeviceFeatures2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceFeatures2* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceFeatures2* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceFeatures2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceProperties2 { + VkStructureType sType; + void* pNext{}; + VkPhysicalDeviceProperties properties; + + safe_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceProperties2(const safe_VkPhysicalDeviceProperties2& copy_src); + safe_VkPhysicalDeviceProperties2& operator=(const safe_VkPhysicalDeviceProperties2& copy_src); + safe_VkPhysicalDeviceProperties2(); + ~safe_VkPhysicalDeviceProperties2(); + void initialize(const VkPhysicalDeviceProperties2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceProperties2* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceProperties2* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceProperties2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkFormatProperties2 { + VkStructureType sType; + void* pNext{}; + VkFormatProperties formatProperties; + + safe_VkFormatProperties2(const VkFormatProperties2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkFormatProperties2(const safe_VkFormatProperties2& copy_src); + safe_VkFormatProperties2& operator=(const safe_VkFormatProperties2& copy_src); + safe_VkFormatProperties2(); + ~safe_VkFormatProperties2(); + void initialize(const VkFormatProperties2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkFormatProperties2* copy_src, PNextCopyState* copy_state = {}); + VkFormatProperties2* ptr() { return reinterpret_cast(this); } + VkFormatProperties2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImageFormatProperties2 { + VkStructureType sType; + void* pNext{}; + VkImageFormatProperties imageFormatProperties; + + safe_VkImageFormatProperties2(const VkImageFormatProperties2* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImageFormatProperties2(const safe_VkImageFormatProperties2& copy_src); + safe_VkImageFormatProperties2& operator=(const safe_VkImageFormatProperties2& copy_src); + safe_VkImageFormatProperties2(); + ~safe_VkImageFormatProperties2(); + void initialize(const VkImageFormatProperties2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageFormatProperties2* copy_src, PNextCopyState* copy_state = {}); + VkImageFormatProperties2* ptr() { return reinterpret_cast(this); } + VkImageFormatProperties2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceImageFormatInfo2 { + VkStructureType sType; + const void* pNext{}; + VkFormat format; + VkImageType type; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; + + safe_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceImageFormatInfo2(const safe_VkPhysicalDeviceImageFormatInfo2& copy_src); + safe_VkPhysicalDeviceImageFormatInfo2& operator=(const safe_VkPhysicalDeviceImageFormatInfo2& copy_src); + safe_VkPhysicalDeviceImageFormatInfo2(); + ~safe_VkPhysicalDeviceImageFormatInfo2(); + void initialize(const VkPhysicalDeviceImageFormatInfo2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceImageFormatInfo2* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceImageFormatInfo2* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceImageFormatInfo2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkQueueFamilyProperties2 { + VkStructureType sType; + void* pNext{}; + VkQueueFamilyProperties queueFamilyProperties; + + safe_VkQueueFamilyProperties2(const VkQueueFamilyProperties2* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkQueueFamilyProperties2(const safe_VkQueueFamilyProperties2& copy_src); + safe_VkQueueFamilyProperties2& operator=(const safe_VkQueueFamilyProperties2& copy_src); + safe_VkQueueFamilyProperties2(); + ~safe_VkQueueFamilyProperties2(); + void initialize(const VkQueueFamilyProperties2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkQueueFamilyProperties2* copy_src, PNextCopyState* copy_state = {}); + VkQueueFamilyProperties2* ptr() { return reinterpret_cast(this); } + VkQueueFamilyProperties2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceMemoryProperties2 { + VkStructureType sType; + void* pNext{}; + VkPhysicalDeviceMemoryProperties memoryProperties; + + safe_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceMemoryProperties2(const safe_VkPhysicalDeviceMemoryProperties2& copy_src); + safe_VkPhysicalDeviceMemoryProperties2& operator=(const safe_VkPhysicalDeviceMemoryProperties2& copy_src); + safe_VkPhysicalDeviceMemoryProperties2(); + ~safe_VkPhysicalDeviceMemoryProperties2(); + void initialize(const VkPhysicalDeviceMemoryProperties2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMemoryProperties2* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMemoryProperties2* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMemoryProperties2 const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSparseImageFormatProperties2 { + VkStructureType sType; + void* pNext{}; + VkSparseImageFormatProperties properties; + + safe_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSparseImageFormatProperties2(const safe_VkSparseImageFormatProperties2& copy_src); + safe_VkSparseImageFormatProperties2& operator=(const safe_VkSparseImageFormatProperties2& copy_src); + safe_VkSparseImageFormatProperties2(); + ~safe_VkSparseImageFormatProperties2(); + void initialize(const VkSparseImageFormatProperties2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSparseImageFormatProperties2* copy_src, PNextCopyState* copy_state = {}); + VkSparseImageFormatProperties2* ptr() { return reinterpret_cast(this); } + VkSparseImageFormatProperties2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceSparseImageFormatInfo2 { + VkStructureType sType; + const void* pNext{}; + VkFormat format; + VkImageType type; + VkSampleCountFlagBits samples; + VkImageUsageFlags usage; + VkImageTiling tiling; + + safe_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceSparseImageFormatInfo2(const safe_VkPhysicalDeviceSparseImageFormatInfo2& copy_src); + safe_VkPhysicalDeviceSparseImageFormatInfo2& operator=(const safe_VkPhysicalDeviceSparseImageFormatInfo2& copy_src); + safe_VkPhysicalDeviceSparseImageFormatInfo2(); + ~safe_VkPhysicalDeviceSparseImageFormatInfo2(); + void initialize(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceSparseImageFormatInfo2* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceSparseImageFormatInfo2* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceSparseImageFormatInfo2 const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDevicePointClippingProperties { + VkStructureType sType; + void* pNext{}; + VkPointClippingBehavior pointClippingBehavior; + + safe_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePointClippingProperties(const safe_VkPhysicalDevicePointClippingProperties& copy_src); + safe_VkPhysicalDevicePointClippingProperties& operator=(const safe_VkPhysicalDevicePointClippingProperties& copy_src); + safe_VkPhysicalDevicePointClippingProperties(); + ~safe_VkPhysicalDevicePointClippingProperties(); + void initialize(const VkPhysicalDevicePointClippingProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePointClippingProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePointClippingProperties* ptr() { return reinterpret_cast(this); } + VkPhysicalDevicePointClippingProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRenderPassInputAttachmentAspectCreateInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t aspectReferenceCount; + const VkInputAttachmentAspectReference* pAspectReferences{}; + + safe_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkRenderPassInputAttachmentAspectCreateInfo(const safe_VkRenderPassInputAttachmentAspectCreateInfo& copy_src); + safe_VkRenderPassInputAttachmentAspectCreateInfo& operator=(const safe_VkRenderPassInputAttachmentAspectCreateInfo& copy_src); + safe_VkRenderPassInputAttachmentAspectCreateInfo(); + ~safe_VkRenderPassInputAttachmentAspectCreateInfo(); + void initialize(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderPassInputAttachmentAspectCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkRenderPassInputAttachmentAspectCreateInfo* ptr() { + return reinterpret_cast(this); + } + VkRenderPassInputAttachmentAspectCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImageViewUsageCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkImageUsageFlags usage; + + safe_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImageViewUsageCreateInfo(const safe_VkImageViewUsageCreateInfo& copy_src); + safe_VkImageViewUsageCreateInfo& operator=(const safe_VkImageViewUsageCreateInfo& copy_src); + safe_VkImageViewUsageCreateInfo(); + ~safe_VkImageViewUsageCreateInfo(); + void initialize(const VkImageViewUsageCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageViewUsageCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkImageViewUsageCreateInfo* ptr() { return reinterpret_cast(this); } + VkImageViewUsageCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPipelineTessellationDomainOriginStateCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkTessellationDomainOrigin domainOrigin; + + safe_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineTessellationDomainOriginStateCreateInfo(const safe_VkPipelineTessellationDomainOriginStateCreateInfo& copy_src); + safe_VkPipelineTessellationDomainOriginStateCreateInfo& operator=( + const safe_VkPipelineTessellationDomainOriginStateCreateInfo& copy_src); + safe_VkPipelineTessellationDomainOriginStateCreateInfo(); + ~safe_VkPipelineTessellationDomainOriginStateCreateInfo(); + void initialize(const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineTessellationDomainOriginStateCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineTessellationDomainOriginStateCreateInfo* ptr() { + return reinterpret_cast(this); + } + VkPipelineTessellationDomainOriginStateCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRenderPassMultiviewCreateInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t subpassCount; + const uint32_t* pViewMasks{}; + uint32_t dependencyCount; + const int32_t* pViewOffsets{}; + uint32_t correlationMaskCount; + const uint32_t* pCorrelationMasks{}; + + safe_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkRenderPassMultiviewCreateInfo(const safe_VkRenderPassMultiviewCreateInfo& copy_src); + safe_VkRenderPassMultiviewCreateInfo& operator=(const safe_VkRenderPassMultiviewCreateInfo& copy_src); + safe_VkRenderPassMultiviewCreateInfo(); + ~safe_VkRenderPassMultiviewCreateInfo(); + void initialize(const VkRenderPassMultiviewCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderPassMultiviewCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkRenderPassMultiviewCreateInfo* ptr() { return reinterpret_cast(this); } + VkRenderPassMultiviewCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceMultiviewFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; + + safe_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceMultiviewFeatures(const safe_VkPhysicalDeviceMultiviewFeatures& copy_src); + safe_VkPhysicalDeviceMultiviewFeatures& operator=(const safe_VkPhysicalDeviceMultiviewFeatures& copy_src); + safe_VkPhysicalDeviceMultiviewFeatures(); + ~safe_VkPhysicalDeviceMultiviewFeatures(); + void initialize(const VkPhysicalDeviceMultiviewFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMultiviewFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMultiviewFeatures* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMultiviewFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMultiviewProperties { + VkStructureType sType; + void* pNext{}; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; + + safe_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceMultiviewProperties(const safe_VkPhysicalDeviceMultiviewProperties& copy_src); + safe_VkPhysicalDeviceMultiviewProperties& operator=(const safe_VkPhysicalDeviceMultiviewProperties& copy_src); + safe_VkPhysicalDeviceMultiviewProperties(); + ~safe_VkPhysicalDeviceMultiviewProperties(); + void initialize(const VkPhysicalDeviceMultiviewProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMultiviewProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMultiviewProperties* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMultiviewProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceVariablePointersFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; + + safe_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceVariablePointersFeatures(const safe_VkPhysicalDeviceVariablePointersFeatures& copy_src); + safe_VkPhysicalDeviceVariablePointersFeatures& operator=(const safe_VkPhysicalDeviceVariablePointersFeatures& copy_src); + safe_VkPhysicalDeviceVariablePointersFeatures(); + ~safe_VkPhysicalDeviceVariablePointersFeatures(); + void initialize(const VkPhysicalDeviceVariablePointersFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVariablePointersFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVariablePointersFeatures* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceVariablePointersFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceProtectedMemoryFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 protectedMemory; + + safe_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceProtectedMemoryFeatures(const safe_VkPhysicalDeviceProtectedMemoryFeatures& copy_src); + safe_VkPhysicalDeviceProtectedMemoryFeatures& operator=(const safe_VkPhysicalDeviceProtectedMemoryFeatures& copy_src); + safe_VkPhysicalDeviceProtectedMemoryFeatures(); + ~safe_VkPhysicalDeviceProtectedMemoryFeatures(); + void initialize(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceProtectedMemoryFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceProtectedMemoryFeatures* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceProtectedMemoryFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceProtectedMemoryProperties { + VkStructureType sType; + void* pNext{}; + VkBool32 protectedNoFault; + + safe_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceProtectedMemoryProperties(const safe_VkPhysicalDeviceProtectedMemoryProperties& copy_src); + safe_VkPhysicalDeviceProtectedMemoryProperties& operator=(const safe_VkPhysicalDeviceProtectedMemoryProperties& copy_src); + safe_VkPhysicalDeviceProtectedMemoryProperties(); + ~safe_VkPhysicalDeviceProtectedMemoryProperties(); + void initialize(const VkPhysicalDeviceProtectedMemoryProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceProtectedMemoryProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceProtectedMemoryProperties* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceProtectedMemoryProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDeviceQueueInfo2 { + VkStructureType sType; + const void* pNext{}; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueIndex; + + safe_VkDeviceQueueInfo2(const VkDeviceQueueInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDeviceQueueInfo2(const safe_VkDeviceQueueInfo2& copy_src); + safe_VkDeviceQueueInfo2& operator=(const safe_VkDeviceQueueInfo2& copy_src); + safe_VkDeviceQueueInfo2(); + ~safe_VkDeviceQueueInfo2(); + void initialize(const VkDeviceQueueInfo2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceQueueInfo2* copy_src, PNextCopyState* copy_state = {}); + VkDeviceQueueInfo2* ptr() { return reinterpret_cast(this); } + VkDeviceQueueInfo2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkProtectedSubmitInfo { + VkStructureType sType; + const void* pNext{}; + VkBool32 protectedSubmit; + + safe_VkProtectedSubmitInfo(const VkProtectedSubmitInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkProtectedSubmitInfo(const safe_VkProtectedSubmitInfo& copy_src); + safe_VkProtectedSubmitInfo& operator=(const safe_VkProtectedSubmitInfo& copy_src); + safe_VkProtectedSubmitInfo(); + ~safe_VkProtectedSubmitInfo(); + void initialize(const VkProtectedSubmitInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkProtectedSubmitInfo* copy_src, PNextCopyState* copy_state = {}); + VkProtectedSubmitInfo* ptr() { return reinterpret_cast(this); } + VkProtectedSubmitInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSamplerYcbcrConversionCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkFormat format; + VkSamplerYcbcrModelConversion ycbcrModel; + VkSamplerYcbcrRange ycbcrRange; + VkComponentMapping components; + VkChromaLocation xChromaOffset; + VkChromaLocation yChromaOffset; + VkFilter chromaFilter; + VkBool32 forceExplicitReconstruction; + + safe_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSamplerYcbcrConversionCreateInfo(const safe_VkSamplerYcbcrConversionCreateInfo& copy_src); + safe_VkSamplerYcbcrConversionCreateInfo& operator=(const safe_VkSamplerYcbcrConversionCreateInfo& copy_src); + safe_VkSamplerYcbcrConversionCreateInfo(); + ~safe_VkSamplerYcbcrConversionCreateInfo(); + void initialize(const VkSamplerYcbcrConversionCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSamplerYcbcrConversionCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkSamplerYcbcrConversionCreateInfo* ptr() { return reinterpret_cast(this); } + VkSamplerYcbcrConversionCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSamplerYcbcrConversionInfo { + VkStructureType sType; + const void* pNext{}; + VkSamplerYcbcrConversion conversion; + + safe_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSamplerYcbcrConversionInfo(const safe_VkSamplerYcbcrConversionInfo& copy_src); + safe_VkSamplerYcbcrConversionInfo& operator=(const safe_VkSamplerYcbcrConversionInfo& copy_src); + safe_VkSamplerYcbcrConversionInfo(); + ~safe_VkSamplerYcbcrConversionInfo(); + void initialize(const VkSamplerYcbcrConversionInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSamplerYcbcrConversionInfo* copy_src, PNextCopyState* copy_state = {}); + VkSamplerYcbcrConversionInfo* ptr() { return reinterpret_cast(this); } + VkSamplerYcbcrConversionInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkBindImagePlaneMemoryInfo { + VkStructureType sType; + const void* pNext{}; + VkImageAspectFlagBits planeAspect; + + safe_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkBindImagePlaneMemoryInfo(const safe_VkBindImagePlaneMemoryInfo& copy_src); + safe_VkBindImagePlaneMemoryInfo& operator=(const safe_VkBindImagePlaneMemoryInfo& copy_src); + safe_VkBindImagePlaneMemoryInfo(); + ~safe_VkBindImagePlaneMemoryInfo(); + void initialize(const VkBindImagePlaneMemoryInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBindImagePlaneMemoryInfo* copy_src, PNextCopyState* copy_state = {}); + VkBindImagePlaneMemoryInfo* ptr() { return reinterpret_cast(this); } + VkBindImagePlaneMemoryInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImagePlaneMemoryRequirementsInfo { + VkStructureType sType; + const void* pNext{}; + VkImageAspectFlagBits planeAspect; + + safe_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImagePlaneMemoryRequirementsInfo(const safe_VkImagePlaneMemoryRequirementsInfo& copy_src); + safe_VkImagePlaneMemoryRequirementsInfo& operator=(const safe_VkImagePlaneMemoryRequirementsInfo& copy_src); + safe_VkImagePlaneMemoryRequirementsInfo(); + ~safe_VkImagePlaneMemoryRequirementsInfo(); + void initialize(const VkImagePlaneMemoryRequirementsInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImagePlaneMemoryRequirementsInfo* copy_src, PNextCopyState* copy_state = {}); + VkImagePlaneMemoryRequirementsInfo* ptr() { return reinterpret_cast(this); } + VkImagePlaneMemoryRequirementsInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 samplerYcbcrConversion; + + safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& copy_src); + safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& operator=( + const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& copy_src); + safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(); + ~safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(); + void initialize(const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceSamplerYcbcrConversionFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceSamplerYcbcrConversionFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSamplerYcbcrConversionImageFormatProperties { + VkStructureType sType; + void* pNext{}; + uint32_t combinedImageSamplerDescriptorCount; + + safe_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSamplerYcbcrConversionImageFormatProperties(const safe_VkSamplerYcbcrConversionImageFormatProperties& copy_src); + safe_VkSamplerYcbcrConversionImageFormatProperties& operator=( + const safe_VkSamplerYcbcrConversionImageFormatProperties& copy_src); + safe_VkSamplerYcbcrConversionImageFormatProperties(); + ~safe_VkSamplerYcbcrConversionImageFormatProperties(); + void initialize(const VkSamplerYcbcrConversionImageFormatProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSamplerYcbcrConversionImageFormatProperties* copy_src, PNextCopyState* copy_state = {}); + VkSamplerYcbcrConversionImageFormatProperties* ptr() { + return reinterpret_cast(this); + } + VkSamplerYcbcrConversionImageFormatProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDescriptorUpdateTemplateCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkDescriptorUpdateTemplateCreateFlags flags; + uint32_t descriptorUpdateEntryCount; + const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries{}; + VkDescriptorUpdateTemplateType templateType; + VkDescriptorSetLayout descriptorSetLayout; + VkPipelineBindPoint pipelineBindPoint; + VkPipelineLayout pipelineLayout; + uint32_t set; + + safe_VkDescriptorUpdateTemplateCreateInfo(const VkDescriptorUpdateTemplateCreateInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDescriptorUpdateTemplateCreateInfo(const safe_VkDescriptorUpdateTemplateCreateInfo& copy_src); + safe_VkDescriptorUpdateTemplateCreateInfo& operator=(const safe_VkDescriptorUpdateTemplateCreateInfo& copy_src); + safe_VkDescriptorUpdateTemplateCreateInfo(); + ~safe_VkDescriptorUpdateTemplateCreateInfo(); + void initialize(const VkDescriptorUpdateTemplateCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDescriptorUpdateTemplateCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkDescriptorUpdateTemplateCreateInfo* ptr() { return reinterpret_cast(this); } + VkDescriptorUpdateTemplateCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceExternalImageFormatInfo { + VkStructureType sType; + const void* pNext{}; + VkExternalMemoryHandleTypeFlagBits handleType; + + safe_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceExternalImageFormatInfo(const safe_VkPhysicalDeviceExternalImageFormatInfo& copy_src); + safe_VkPhysicalDeviceExternalImageFormatInfo& operator=(const safe_VkPhysicalDeviceExternalImageFormatInfo& copy_src); + safe_VkPhysicalDeviceExternalImageFormatInfo(); + ~safe_VkPhysicalDeviceExternalImageFormatInfo(); + void initialize(const VkPhysicalDeviceExternalImageFormatInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceExternalImageFormatInfo* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceExternalImageFormatInfo* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceExternalImageFormatInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkExternalImageFormatProperties { + VkStructureType sType; + void* pNext{}; + VkExternalMemoryProperties externalMemoryProperties; + + safe_VkExternalImageFormatProperties(const VkExternalImageFormatProperties* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExternalImageFormatProperties(const safe_VkExternalImageFormatProperties& copy_src); + safe_VkExternalImageFormatProperties& operator=(const safe_VkExternalImageFormatProperties& copy_src); + safe_VkExternalImageFormatProperties(); + ~safe_VkExternalImageFormatProperties(); + void initialize(const VkExternalImageFormatProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExternalImageFormatProperties* copy_src, PNextCopyState* copy_state = {}); + VkExternalImageFormatProperties* ptr() { return reinterpret_cast(this); } + VkExternalImageFormatProperties const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceExternalBufferInfo { + VkStructureType sType; + const void* pNext{}; + VkBufferCreateFlags flags; + VkBufferUsageFlags usage; + VkExternalMemoryHandleTypeFlagBits handleType; + + safe_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceExternalBufferInfo(const safe_VkPhysicalDeviceExternalBufferInfo& copy_src); + safe_VkPhysicalDeviceExternalBufferInfo& operator=(const safe_VkPhysicalDeviceExternalBufferInfo& copy_src); + safe_VkPhysicalDeviceExternalBufferInfo(); + ~safe_VkPhysicalDeviceExternalBufferInfo(); + void initialize(const VkPhysicalDeviceExternalBufferInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceExternalBufferInfo* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceExternalBufferInfo* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceExternalBufferInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkExternalBufferProperties { + VkStructureType sType; + void* pNext{}; + VkExternalMemoryProperties externalMemoryProperties; + + safe_VkExternalBufferProperties(const VkExternalBufferProperties* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExternalBufferProperties(const safe_VkExternalBufferProperties& copy_src); + safe_VkExternalBufferProperties& operator=(const safe_VkExternalBufferProperties& copy_src); + safe_VkExternalBufferProperties(); + ~safe_VkExternalBufferProperties(); + void initialize(const VkExternalBufferProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExternalBufferProperties* copy_src, PNextCopyState* copy_state = {}); + VkExternalBufferProperties* ptr() { return reinterpret_cast(this); } + VkExternalBufferProperties const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceIDProperties { + VkStructureType sType; + void* pNext{}; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; + + safe_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceIDProperties(const safe_VkPhysicalDeviceIDProperties& copy_src); + safe_VkPhysicalDeviceIDProperties& operator=(const safe_VkPhysicalDeviceIDProperties& copy_src); + safe_VkPhysicalDeviceIDProperties(); + ~safe_VkPhysicalDeviceIDProperties(); + void initialize(const VkPhysicalDeviceIDProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceIDProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceIDProperties* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceIDProperties const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkExternalMemoryImageCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkExternalMemoryHandleTypeFlags handleTypes; + + safe_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExternalMemoryImageCreateInfo(const safe_VkExternalMemoryImageCreateInfo& copy_src); + safe_VkExternalMemoryImageCreateInfo& operator=(const safe_VkExternalMemoryImageCreateInfo& copy_src); + safe_VkExternalMemoryImageCreateInfo(); + ~safe_VkExternalMemoryImageCreateInfo(); + void initialize(const VkExternalMemoryImageCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExternalMemoryImageCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkExternalMemoryImageCreateInfo* ptr() { return reinterpret_cast(this); } + VkExternalMemoryImageCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkExternalMemoryBufferCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkExternalMemoryHandleTypeFlags handleTypes; + + safe_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExternalMemoryBufferCreateInfo(const safe_VkExternalMemoryBufferCreateInfo& copy_src); + safe_VkExternalMemoryBufferCreateInfo& operator=(const safe_VkExternalMemoryBufferCreateInfo& copy_src); + safe_VkExternalMemoryBufferCreateInfo(); + ~safe_VkExternalMemoryBufferCreateInfo(); + void initialize(const VkExternalMemoryBufferCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExternalMemoryBufferCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkExternalMemoryBufferCreateInfo* ptr() { return reinterpret_cast(this); } + VkExternalMemoryBufferCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkExportMemoryAllocateInfo { + VkStructureType sType; + const void* pNext{}; + VkExternalMemoryHandleTypeFlags handleTypes; + + safe_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExportMemoryAllocateInfo(const safe_VkExportMemoryAllocateInfo& copy_src); + safe_VkExportMemoryAllocateInfo& operator=(const safe_VkExportMemoryAllocateInfo& copy_src); + safe_VkExportMemoryAllocateInfo(); + ~safe_VkExportMemoryAllocateInfo(); + void initialize(const VkExportMemoryAllocateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExportMemoryAllocateInfo* copy_src, PNextCopyState* copy_state = {}); + VkExportMemoryAllocateInfo* ptr() { return reinterpret_cast(this); } + VkExportMemoryAllocateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceExternalFenceInfo { + VkStructureType sType; + const void* pNext{}; + VkExternalFenceHandleTypeFlagBits handleType; + + safe_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceExternalFenceInfo(const safe_VkPhysicalDeviceExternalFenceInfo& copy_src); + safe_VkPhysicalDeviceExternalFenceInfo& operator=(const safe_VkPhysicalDeviceExternalFenceInfo& copy_src); + safe_VkPhysicalDeviceExternalFenceInfo(); + ~safe_VkPhysicalDeviceExternalFenceInfo(); + void initialize(const VkPhysicalDeviceExternalFenceInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceExternalFenceInfo* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceExternalFenceInfo* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceExternalFenceInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkExternalFenceProperties { + VkStructureType sType; + void* pNext{}; + VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; + VkExternalFenceHandleTypeFlags compatibleHandleTypes; + VkExternalFenceFeatureFlags externalFenceFeatures; + + safe_VkExternalFenceProperties(const VkExternalFenceProperties* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExternalFenceProperties(const safe_VkExternalFenceProperties& copy_src); + safe_VkExternalFenceProperties& operator=(const safe_VkExternalFenceProperties& copy_src); + safe_VkExternalFenceProperties(); + ~safe_VkExternalFenceProperties(); + void initialize(const VkExternalFenceProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExternalFenceProperties* copy_src, PNextCopyState* copy_state = {}); + VkExternalFenceProperties* ptr() { return reinterpret_cast(this); } + VkExternalFenceProperties const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkExportFenceCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkExternalFenceHandleTypeFlags handleTypes; + + safe_VkExportFenceCreateInfo(const VkExportFenceCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkExportFenceCreateInfo(const safe_VkExportFenceCreateInfo& copy_src); + safe_VkExportFenceCreateInfo& operator=(const safe_VkExportFenceCreateInfo& copy_src); + safe_VkExportFenceCreateInfo(); + ~safe_VkExportFenceCreateInfo(); + void initialize(const VkExportFenceCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExportFenceCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkExportFenceCreateInfo* ptr() { return reinterpret_cast(this); } + VkExportFenceCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkExportSemaphoreCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkExternalSemaphoreHandleTypeFlags handleTypes; + + safe_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExportSemaphoreCreateInfo(const safe_VkExportSemaphoreCreateInfo& copy_src); + safe_VkExportSemaphoreCreateInfo& operator=(const safe_VkExportSemaphoreCreateInfo& copy_src); + safe_VkExportSemaphoreCreateInfo(); + ~safe_VkExportSemaphoreCreateInfo(); + void initialize(const VkExportSemaphoreCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExportSemaphoreCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkExportSemaphoreCreateInfo* ptr() { return reinterpret_cast(this); } + VkExportSemaphoreCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceExternalSemaphoreInfo { + VkStructureType sType; + const void* pNext{}; + VkExternalSemaphoreHandleTypeFlagBits handleType; + + safe_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceExternalSemaphoreInfo(const safe_VkPhysicalDeviceExternalSemaphoreInfo& copy_src); + safe_VkPhysicalDeviceExternalSemaphoreInfo& operator=(const safe_VkPhysicalDeviceExternalSemaphoreInfo& copy_src); + safe_VkPhysicalDeviceExternalSemaphoreInfo(); + ~safe_VkPhysicalDeviceExternalSemaphoreInfo(); + void initialize(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceExternalSemaphoreInfo* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceExternalSemaphoreInfo* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceExternalSemaphoreInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkExternalSemaphoreProperties { + VkStructureType sType; + void* pNext{}; + VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; + VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; + VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; + + safe_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExternalSemaphoreProperties(const safe_VkExternalSemaphoreProperties& copy_src); + safe_VkExternalSemaphoreProperties& operator=(const safe_VkExternalSemaphoreProperties& copy_src); + safe_VkExternalSemaphoreProperties(); + ~safe_VkExternalSemaphoreProperties(); + void initialize(const VkExternalSemaphoreProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExternalSemaphoreProperties* copy_src, PNextCopyState* copy_state = {}); + VkExternalSemaphoreProperties* ptr() { return reinterpret_cast(this); } + VkExternalSemaphoreProperties const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceMaintenance3Properties { + VkStructureType sType; + void* pNext{}; + uint32_t maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; + + safe_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMaintenance3Properties(const safe_VkPhysicalDeviceMaintenance3Properties& copy_src); + safe_VkPhysicalDeviceMaintenance3Properties& operator=(const safe_VkPhysicalDeviceMaintenance3Properties& copy_src); + safe_VkPhysicalDeviceMaintenance3Properties(); + ~safe_VkPhysicalDeviceMaintenance3Properties(); + void initialize(const VkPhysicalDeviceMaintenance3Properties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMaintenance3Properties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMaintenance3Properties* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMaintenance3Properties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDescriptorSetLayoutSupport { + VkStructureType sType; + void* pNext{}; + VkBool32 supported; + + safe_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDescriptorSetLayoutSupport(const safe_VkDescriptorSetLayoutSupport& copy_src); + safe_VkDescriptorSetLayoutSupport& operator=(const safe_VkDescriptorSetLayoutSupport& copy_src); + safe_VkDescriptorSetLayoutSupport(); + ~safe_VkDescriptorSetLayoutSupport(); + void initialize(const VkDescriptorSetLayoutSupport* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDescriptorSetLayoutSupport* copy_src, PNextCopyState* copy_state = {}); + VkDescriptorSetLayoutSupport* ptr() { return reinterpret_cast(this); } + VkDescriptorSetLayoutSupport const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceShaderDrawParametersFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderDrawParameters; + + safe_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderDrawParametersFeatures(const safe_VkPhysicalDeviceShaderDrawParametersFeatures& copy_src); + safe_VkPhysicalDeviceShaderDrawParametersFeatures& operator=(const safe_VkPhysicalDeviceShaderDrawParametersFeatures& copy_src); + safe_VkPhysicalDeviceShaderDrawParametersFeatures(); + ~safe_VkPhysicalDeviceShaderDrawParametersFeatures(); + void initialize(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderDrawParametersFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderDrawParametersFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderDrawParametersFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceVulkan11Features { + VkStructureType sType; + void* pNext{}; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; + VkBool32 protectedMemory; + VkBool32 samplerYcbcrConversion; + VkBool32 shaderDrawParameters; + + safe_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceVulkan11Features(const safe_VkPhysicalDeviceVulkan11Features& copy_src); + safe_VkPhysicalDeviceVulkan11Features& operator=(const safe_VkPhysicalDeviceVulkan11Features& copy_src); + safe_VkPhysicalDeviceVulkan11Features(); + ~safe_VkPhysicalDeviceVulkan11Features(); + void initialize(const VkPhysicalDeviceVulkan11Features* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVulkan11Features* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVulkan11Features* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceVulkan11Features const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceVulkan11Properties { + VkStructureType sType; + void* pNext{}; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; + uint32_t subgroupSize; + VkShaderStageFlags subgroupSupportedStages; + VkSubgroupFeatureFlags subgroupSupportedOperations; + VkBool32 subgroupQuadOperationsInAllStages; + VkPointClippingBehavior pointClippingBehavior; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; + VkBool32 protectedNoFault; + uint32_t maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; + + safe_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceVulkan11Properties(const safe_VkPhysicalDeviceVulkan11Properties& copy_src); + safe_VkPhysicalDeviceVulkan11Properties& operator=(const safe_VkPhysicalDeviceVulkan11Properties& copy_src); + safe_VkPhysicalDeviceVulkan11Properties(); + ~safe_VkPhysicalDeviceVulkan11Properties(); + void initialize(const VkPhysicalDeviceVulkan11Properties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVulkan11Properties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVulkan11Properties* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceVulkan11Properties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceVulkan12Features { + VkStructureType sType; + void* pNext{}; + VkBool32 samplerMirrorClampToEdge; + VkBool32 drawIndirectCount; + VkBool32 storageBuffer8BitAccess; + VkBool32 uniformAndStorageBuffer8BitAccess; + VkBool32 storagePushConstant8; + VkBool32 shaderBufferInt64Atomics; + VkBool32 shaderSharedInt64Atomics; + VkBool32 shaderFloat16; + VkBool32 shaderInt8; + VkBool32 descriptorIndexing; + VkBool32 shaderInputAttachmentArrayDynamicIndexing; + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; + VkBool32 shaderUniformBufferArrayNonUniformIndexing; + VkBool32 shaderSampledImageArrayNonUniformIndexing; + VkBool32 shaderStorageBufferArrayNonUniformIndexing; + VkBool32 shaderStorageImageArrayNonUniformIndexing; + VkBool32 shaderInputAttachmentArrayNonUniformIndexing; + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; + VkBool32 descriptorBindingUniformBufferUpdateAfterBind; + VkBool32 descriptorBindingSampledImageUpdateAfterBind; + VkBool32 descriptorBindingStorageImageUpdateAfterBind; + VkBool32 descriptorBindingStorageBufferUpdateAfterBind; + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingUpdateUnusedWhilePending; + VkBool32 descriptorBindingPartiallyBound; + VkBool32 descriptorBindingVariableDescriptorCount; + VkBool32 runtimeDescriptorArray; + VkBool32 samplerFilterMinmax; + VkBool32 scalarBlockLayout; + VkBool32 imagelessFramebuffer; + VkBool32 uniformBufferStandardLayout; + VkBool32 shaderSubgroupExtendedTypes; + VkBool32 separateDepthStencilLayouts; + VkBool32 hostQueryReset; + VkBool32 timelineSemaphore; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; + VkBool32 shaderOutputViewportIndex; + VkBool32 shaderOutputLayer; + VkBool32 subgroupBroadcastDynamicId; + + safe_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceVulkan12Features(const safe_VkPhysicalDeviceVulkan12Features& copy_src); + safe_VkPhysicalDeviceVulkan12Features& operator=(const safe_VkPhysicalDeviceVulkan12Features& copy_src); + safe_VkPhysicalDeviceVulkan12Features(); + ~safe_VkPhysicalDeviceVulkan12Features(); + void initialize(const VkPhysicalDeviceVulkan12Features* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVulkan12Features* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVulkan12Features* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceVulkan12Features const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceVulkan12Properties { + VkStructureType sType; + void* pNext{}; + VkDriverId driverID; + char driverName[VK_MAX_DRIVER_NAME_SIZE]; + char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; + VkConformanceVersion conformanceVersion; + VkShaderFloatControlsIndependence denormBehaviorIndependence; + VkShaderFloatControlsIndependence roundingModeIndependence; + VkBool32 shaderSignedZeroInfNanPreserveFloat16; + VkBool32 shaderSignedZeroInfNanPreserveFloat32; + VkBool32 shaderSignedZeroInfNanPreserveFloat64; + VkBool32 shaderDenormPreserveFloat16; + VkBool32 shaderDenormPreserveFloat32; + VkBool32 shaderDenormPreserveFloat64; + VkBool32 shaderDenormFlushToZeroFloat16; + VkBool32 shaderDenormFlushToZeroFloat32; + VkBool32 shaderDenormFlushToZeroFloat64; + VkBool32 shaderRoundingModeRTEFloat16; + VkBool32 shaderRoundingModeRTEFloat32; + VkBool32 shaderRoundingModeRTEFloat64; + VkBool32 shaderRoundingModeRTZFloat16; + VkBool32 shaderRoundingModeRTZFloat32; + VkBool32 shaderRoundingModeRTZFloat64; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; + VkResolveModeFlags supportedDepthResolveModes; + VkResolveModeFlags supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; + uint64_t maxTimelineSemaphoreValueDifference; + VkSampleCountFlags framebufferIntegerColorSampleCounts; + + safe_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceVulkan12Properties(const safe_VkPhysicalDeviceVulkan12Properties& copy_src); + safe_VkPhysicalDeviceVulkan12Properties& operator=(const safe_VkPhysicalDeviceVulkan12Properties& copy_src); + safe_VkPhysicalDeviceVulkan12Properties(); + ~safe_VkPhysicalDeviceVulkan12Properties(); + void initialize(const VkPhysicalDeviceVulkan12Properties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVulkan12Properties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVulkan12Properties* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceVulkan12Properties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImageFormatListCreateInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t viewFormatCount; + const VkFormat* pViewFormats{}; + + safe_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImageFormatListCreateInfo(const safe_VkImageFormatListCreateInfo& copy_src); + safe_VkImageFormatListCreateInfo& operator=(const safe_VkImageFormatListCreateInfo& copy_src); + safe_VkImageFormatListCreateInfo(); + ~safe_VkImageFormatListCreateInfo(); + void initialize(const VkImageFormatListCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageFormatListCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkImageFormatListCreateInfo* ptr() { return reinterpret_cast(this); } + VkImageFormatListCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkAttachmentDescription2 { + VkStructureType sType; + const void* pNext{}; + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; + + safe_VkAttachmentDescription2(const VkAttachmentDescription2* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkAttachmentDescription2(const safe_VkAttachmentDescription2& copy_src); + safe_VkAttachmentDescription2& operator=(const safe_VkAttachmentDescription2& copy_src); + safe_VkAttachmentDescription2(); + ~safe_VkAttachmentDescription2(); + void initialize(const VkAttachmentDescription2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAttachmentDescription2* copy_src, PNextCopyState* copy_state = {}); + VkAttachmentDescription2* ptr() { return reinterpret_cast(this); } + VkAttachmentDescription2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkAttachmentReference2 { + VkStructureType sType; + const void* pNext{}; + uint32_t attachment; + VkImageLayout layout; + VkImageAspectFlags aspectMask; + + safe_VkAttachmentReference2(const VkAttachmentReference2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAttachmentReference2(const safe_VkAttachmentReference2& copy_src); + safe_VkAttachmentReference2& operator=(const safe_VkAttachmentReference2& copy_src); + safe_VkAttachmentReference2(); + ~safe_VkAttachmentReference2(); + void initialize(const VkAttachmentReference2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAttachmentReference2* copy_src, PNextCopyState* copy_state = {}); + VkAttachmentReference2* ptr() { return reinterpret_cast(this); } + VkAttachmentReference2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSubpassDescription2 { + VkStructureType sType; + const void* pNext{}; + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t viewMask; + uint32_t inputAttachmentCount; + safe_VkAttachmentReference2* pInputAttachments{}; + uint32_t colorAttachmentCount; + safe_VkAttachmentReference2* pColorAttachments{}; + safe_VkAttachmentReference2* pResolveAttachments{}; + safe_VkAttachmentReference2* pDepthStencilAttachment{}; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments{}; + + safe_VkSubpassDescription2(const VkSubpassDescription2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSubpassDescription2(const safe_VkSubpassDescription2& copy_src); + safe_VkSubpassDescription2& operator=(const safe_VkSubpassDescription2& copy_src); + safe_VkSubpassDescription2(); + ~safe_VkSubpassDescription2(); + void initialize(const VkSubpassDescription2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSubpassDescription2* copy_src, PNextCopyState* copy_state = {}); + VkSubpassDescription2* ptr() { return reinterpret_cast(this); } + VkSubpassDescription2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSubpassDependency2 { + VkStructureType sType; + const void* pNext{}; + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; + int32_t viewOffset; + + safe_VkSubpassDependency2(const VkSubpassDependency2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSubpassDependency2(const safe_VkSubpassDependency2& copy_src); + safe_VkSubpassDependency2& operator=(const safe_VkSubpassDependency2& copy_src); + safe_VkSubpassDependency2(); + ~safe_VkSubpassDependency2(); + void initialize(const VkSubpassDependency2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSubpassDependency2* copy_src, PNextCopyState* copy_state = {}); + VkSubpassDependency2* ptr() { return reinterpret_cast(this); } + VkSubpassDependency2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkRenderPassCreateInfo2 { + VkStructureType sType; + const void* pNext{}; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + safe_VkAttachmentDescription2* pAttachments{}; + uint32_t subpassCount; + safe_VkSubpassDescription2* pSubpasses{}; + uint32_t dependencyCount; + safe_VkSubpassDependency2* pDependencies{}; + uint32_t correlatedViewMaskCount; + const uint32_t* pCorrelatedViewMasks{}; + + safe_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkRenderPassCreateInfo2(const safe_VkRenderPassCreateInfo2& copy_src); + safe_VkRenderPassCreateInfo2& operator=(const safe_VkRenderPassCreateInfo2& copy_src); + safe_VkRenderPassCreateInfo2(); + ~safe_VkRenderPassCreateInfo2(); + void initialize(const VkRenderPassCreateInfo2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderPassCreateInfo2* copy_src, PNextCopyState* copy_state = {}); + VkRenderPassCreateInfo2* ptr() { return reinterpret_cast(this); } + VkRenderPassCreateInfo2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSubpassBeginInfo { + VkStructureType sType; + const void* pNext{}; + VkSubpassContents contents; + + safe_VkSubpassBeginInfo(const VkSubpassBeginInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSubpassBeginInfo(const safe_VkSubpassBeginInfo& copy_src); + safe_VkSubpassBeginInfo& operator=(const safe_VkSubpassBeginInfo& copy_src); + safe_VkSubpassBeginInfo(); + ~safe_VkSubpassBeginInfo(); + void initialize(const VkSubpassBeginInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSubpassBeginInfo* copy_src, PNextCopyState* copy_state = {}); + VkSubpassBeginInfo* ptr() { return reinterpret_cast(this); } + VkSubpassBeginInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSubpassEndInfo { + VkStructureType sType; + const void* pNext{}; + + safe_VkSubpassEndInfo(const VkSubpassEndInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSubpassEndInfo(const safe_VkSubpassEndInfo& copy_src); + safe_VkSubpassEndInfo& operator=(const safe_VkSubpassEndInfo& copy_src); + safe_VkSubpassEndInfo(); + ~safe_VkSubpassEndInfo(); + void initialize(const VkSubpassEndInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSubpassEndInfo* copy_src, PNextCopyState* copy_state = {}); + VkSubpassEndInfo* ptr() { return reinterpret_cast(this); } + VkSubpassEndInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDevice8BitStorageFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 storageBuffer8BitAccess; + VkBool32 uniformAndStorageBuffer8BitAccess; + VkBool32 storagePushConstant8; + + safe_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDevice8BitStorageFeatures(const safe_VkPhysicalDevice8BitStorageFeatures& copy_src); + safe_VkPhysicalDevice8BitStorageFeatures& operator=(const safe_VkPhysicalDevice8BitStorageFeatures& copy_src); + safe_VkPhysicalDevice8BitStorageFeatures(); + ~safe_VkPhysicalDevice8BitStorageFeatures(); + void initialize(const VkPhysicalDevice8BitStorageFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevice8BitStorageFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevice8BitStorageFeatures* ptr() { return reinterpret_cast(this); } + VkPhysicalDevice8BitStorageFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDriverProperties { + VkStructureType sType; + void* pNext{}; + VkDriverId driverID; + char driverName[VK_MAX_DRIVER_NAME_SIZE]; + char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; + VkConformanceVersion conformanceVersion; + + safe_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceDriverProperties(const safe_VkPhysicalDeviceDriverProperties& copy_src); + safe_VkPhysicalDeviceDriverProperties& operator=(const safe_VkPhysicalDeviceDriverProperties& copy_src); + safe_VkPhysicalDeviceDriverProperties(); + ~safe_VkPhysicalDeviceDriverProperties(); + void initialize(const VkPhysicalDeviceDriverProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDriverProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDriverProperties* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceDriverProperties const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceShaderAtomicInt64Features { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderBufferInt64Atomics; + VkBool32 shaderSharedInt64Atomics; + + safe_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderAtomicInt64Features(const safe_VkPhysicalDeviceShaderAtomicInt64Features& copy_src); + safe_VkPhysicalDeviceShaderAtomicInt64Features& operator=(const safe_VkPhysicalDeviceShaderAtomicInt64Features& copy_src); + safe_VkPhysicalDeviceShaderAtomicInt64Features(); + ~safe_VkPhysicalDeviceShaderAtomicInt64Features(); + void initialize(const VkPhysicalDeviceShaderAtomicInt64Features* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderAtomicInt64Features* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderAtomicInt64Features* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceShaderAtomicInt64Features const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderFloat16Int8Features { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderFloat16; + VkBool32 shaderInt8; + + safe_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderFloat16Int8Features(const safe_VkPhysicalDeviceShaderFloat16Int8Features& copy_src); + safe_VkPhysicalDeviceShaderFloat16Int8Features& operator=(const safe_VkPhysicalDeviceShaderFloat16Int8Features& copy_src); + safe_VkPhysicalDeviceShaderFloat16Int8Features(); + ~safe_VkPhysicalDeviceShaderFloat16Int8Features(); + void initialize(const VkPhysicalDeviceShaderFloat16Int8Features* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderFloat16Int8Features* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderFloat16Int8Features* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceShaderFloat16Int8Features const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceFloatControlsProperties { + VkStructureType sType; + void* pNext{}; + VkShaderFloatControlsIndependence denormBehaviorIndependence; + VkShaderFloatControlsIndependence roundingModeIndependence; + VkBool32 shaderSignedZeroInfNanPreserveFloat16; + VkBool32 shaderSignedZeroInfNanPreserveFloat32; + VkBool32 shaderSignedZeroInfNanPreserveFloat64; + VkBool32 shaderDenormPreserveFloat16; + VkBool32 shaderDenormPreserveFloat32; + VkBool32 shaderDenormPreserveFloat64; + VkBool32 shaderDenormFlushToZeroFloat16; + VkBool32 shaderDenormFlushToZeroFloat32; + VkBool32 shaderDenormFlushToZeroFloat64; + VkBool32 shaderRoundingModeRTEFloat16; + VkBool32 shaderRoundingModeRTEFloat32; + VkBool32 shaderRoundingModeRTEFloat64; + VkBool32 shaderRoundingModeRTZFloat16; + VkBool32 shaderRoundingModeRTZFloat32; + VkBool32 shaderRoundingModeRTZFloat64; + + safe_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceFloatControlsProperties(const safe_VkPhysicalDeviceFloatControlsProperties& copy_src); + safe_VkPhysicalDeviceFloatControlsProperties& operator=(const safe_VkPhysicalDeviceFloatControlsProperties& copy_src); + safe_VkPhysicalDeviceFloatControlsProperties(); + ~safe_VkPhysicalDeviceFloatControlsProperties(); + void initialize(const VkPhysicalDeviceFloatControlsProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceFloatControlsProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceFloatControlsProperties* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceFloatControlsProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDescriptorSetLayoutBindingFlagsCreateInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t bindingCount; + const VkDescriptorBindingFlags* pBindingFlags{}; + + safe_VkDescriptorSetLayoutBindingFlagsCreateInfo(const VkDescriptorSetLayoutBindingFlagsCreateInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDescriptorSetLayoutBindingFlagsCreateInfo(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& copy_src); + safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& operator=(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& copy_src); + safe_VkDescriptorSetLayoutBindingFlagsCreateInfo(); + ~safe_VkDescriptorSetLayoutBindingFlagsCreateInfo(); + void initialize(const VkDescriptorSetLayoutBindingFlagsCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkDescriptorSetLayoutBindingFlagsCreateInfo* ptr() { + return reinterpret_cast(this); + } + VkDescriptorSetLayoutBindingFlagsCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDescriptorIndexingFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderInputAttachmentArrayDynamicIndexing; + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; + VkBool32 shaderUniformBufferArrayNonUniformIndexing; + VkBool32 shaderSampledImageArrayNonUniformIndexing; + VkBool32 shaderStorageBufferArrayNonUniformIndexing; + VkBool32 shaderStorageImageArrayNonUniformIndexing; + VkBool32 shaderInputAttachmentArrayNonUniformIndexing; + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; + VkBool32 descriptorBindingUniformBufferUpdateAfterBind; + VkBool32 descriptorBindingSampledImageUpdateAfterBind; + VkBool32 descriptorBindingStorageImageUpdateAfterBind; + VkBool32 descriptorBindingStorageBufferUpdateAfterBind; + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingUpdateUnusedWhilePending; + VkBool32 descriptorBindingPartiallyBound; + VkBool32 descriptorBindingVariableDescriptorCount; + VkBool32 runtimeDescriptorArray; + + safe_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDescriptorIndexingFeatures(const safe_VkPhysicalDeviceDescriptorIndexingFeatures& copy_src); + safe_VkPhysicalDeviceDescriptorIndexingFeatures& operator=(const safe_VkPhysicalDeviceDescriptorIndexingFeatures& copy_src); + safe_VkPhysicalDeviceDescriptorIndexingFeatures(); + ~safe_VkPhysicalDeviceDescriptorIndexingFeatures(); + void initialize(const VkPhysicalDeviceDescriptorIndexingFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDescriptorIndexingFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDescriptorIndexingFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDescriptorIndexingFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDescriptorIndexingProperties { + VkStructureType sType; + void* pNext{}; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; + + safe_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDescriptorIndexingProperties(const safe_VkPhysicalDeviceDescriptorIndexingProperties& copy_src); + safe_VkPhysicalDeviceDescriptorIndexingProperties& operator=(const safe_VkPhysicalDeviceDescriptorIndexingProperties& copy_src); + safe_VkPhysicalDeviceDescriptorIndexingProperties(); + ~safe_VkPhysicalDeviceDescriptorIndexingProperties(); + void initialize(const VkPhysicalDeviceDescriptorIndexingProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDescriptorIndexingProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDescriptorIndexingProperties* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDescriptorIndexingProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDescriptorSetVariableDescriptorCountAllocateInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t descriptorSetCount; + const uint32_t* pDescriptorCounts{}; + + safe_VkDescriptorSetVariableDescriptorCountAllocateInfo(const VkDescriptorSetVariableDescriptorCountAllocateInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDescriptorSetVariableDescriptorCountAllocateInfo( + const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& copy_src); + safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& operator=( + const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& copy_src); + safe_VkDescriptorSetVariableDescriptorCountAllocateInfo(); + ~safe_VkDescriptorSetVariableDescriptorCountAllocateInfo(); + void initialize(const VkDescriptorSetVariableDescriptorCountAllocateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo* copy_src, PNextCopyState* copy_state = {}); + VkDescriptorSetVariableDescriptorCountAllocateInfo* ptr() { + return reinterpret_cast(this); + } + VkDescriptorSetVariableDescriptorCountAllocateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDescriptorSetVariableDescriptorCountLayoutSupport { + VkStructureType sType; + void* pNext{}; + uint32_t maxVariableDescriptorCount; + + safe_VkDescriptorSetVariableDescriptorCountLayoutSupport(const VkDescriptorSetVariableDescriptorCountLayoutSupport* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDescriptorSetVariableDescriptorCountLayoutSupport( + const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& copy_src); + safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& operator=( + const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& copy_src); + safe_VkDescriptorSetVariableDescriptorCountLayoutSupport(); + ~safe_VkDescriptorSetVariableDescriptorCountLayoutSupport(); + void initialize(const VkDescriptorSetVariableDescriptorCountLayoutSupport* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport* copy_src, PNextCopyState* copy_state = {}); + VkDescriptorSetVariableDescriptorCountLayoutSupport* ptr() { + return reinterpret_cast(this); + } + VkDescriptorSetVariableDescriptorCountLayoutSupport const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSubpassDescriptionDepthStencilResolve { + VkStructureType sType; + const void* pNext{}; + VkResolveModeFlagBits depthResolveMode; + VkResolveModeFlagBits stencilResolveMode; + safe_VkAttachmentReference2* pDepthStencilResolveAttachment{}; + + safe_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSubpassDescriptionDepthStencilResolve(const safe_VkSubpassDescriptionDepthStencilResolve& copy_src); + safe_VkSubpassDescriptionDepthStencilResolve& operator=(const safe_VkSubpassDescriptionDepthStencilResolve& copy_src); + safe_VkSubpassDescriptionDepthStencilResolve(); + ~safe_VkSubpassDescriptionDepthStencilResolve(); + void initialize(const VkSubpassDescriptionDepthStencilResolve* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSubpassDescriptionDepthStencilResolve* copy_src, PNextCopyState* copy_state = {}); + VkSubpassDescriptionDepthStencilResolve* ptr() { return reinterpret_cast(this); } + VkSubpassDescriptionDepthStencilResolve const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDepthStencilResolveProperties { + VkStructureType sType; + void* pNext{}; + VkResolveModeFlags supportedDepthResolveModes; + VkResolveModeFlags supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; + + safe_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDepthStencilResolveProperties(const safe_VkPhysicalDeviceDepthStencilResolveProperties& copy_src); + safe_VkPhysicalDeviceDepthStencilResolveProperties& operator=( + const safe_VkPhysicalDeviceDepthStencilResolveProperties& copy_src); + safe_VkPhysicalDeviceDepthStencilResolveProperties(); + ~safe_VkPhysicalDeviceDepthStencilResolveProperties(); + void initialize(const VkPhysicalDeviceDepthStencilResolveProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDepthStencilResolveProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDepthStencilResolveProperties* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDepthStencilResolveProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceScalarBlockLayoutFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 scalarBlockLayout; + + safe_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceScalarBlockLayoutFeatures(const safe_VkPhysicalDeviceScalarBlockLayoutFeatures& copy_src); + safe_VkPhysicalDeviceScalarBlockLayoutFeatures& operator=(const safe_VkPhysicalDeviceScalarBlockLayoutFeatures& copy_src); + safe_VkPhysicalDeviceScalarBlockLayoutFeatures(); + ~safe_VkPhysicalDeviceScalarBlockLayoutFeatures(); + void initialize(const VkPhysicalDeviceScalarBlockLayoutFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceScalarBlockLayoutFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceScalarBlockLayoutFeatures* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceScalarBlockLayoutFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImageStencilUsageCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkImageUsageFlags stencilUsage; + + safe_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImageStencilUsageCreateInfo(const safe_VkImageStencilUsageCreateInfo& copy_src); + safe_VkImageStencilUsageCreateInfo& operator=(const safe_VkImageStencilUsageCreateInfo& copy_src); + safe_VkImageStencilUsageCreateInfo(); + ~safe_VkImageStencilUsageCreateInfo(); + void initialize(const VkImageStencilUsageCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageStencilUsageCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkImageStencilUsageCreateInfo* ptr() { return reinterpret_cast(this); } + VkImageStencilUsageCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSamplerReductionModeCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkSamplerReductionMode reductionMode; + + safe_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSamplerReductionModeCreateInfo(const safe_VkSamplerReductionModeCreateInfo& copy_src); + safe_VkSamplerReductionModeCreateInfo& operator=(const safe_VkSamplerReductionModeCreateInfo& copy_src); + safe_VkSamplerReductionModeCreateInfo(); + ~safe_VkSamplerReductionModeCreateInfo(); + void initialize(const VkSamplerReductionModeCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSamplerReductionModeCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkSamplerReductionModeCreateInfo* ptr() { return reinterpret_cast(this); } + VkSamplerReductionModeCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceSamplerFilterMinmaxProperties { + VkStructureType sType; + void* pNext{}; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; + + safe_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceSamplerFilterMinmaxProperties(const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& copy_src); + safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& operator=( + const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& copy_src); + safe_VkPhysicalDeviceSamplerFilterMinmaxProperties(); + ~safe_VkPhysicalDeviceSamplerFilterMinmaxProperties(); + void initialize(const VkPhysicalDeviceSamplerFilterMinmaxProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceSamplerFilterMinmaxProperties* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceSamplerFilterMinmaxProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceVulkanMemoryModelFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; + + safe_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceVulkanMemoryModelFeatures(const safe_VkPhysicalDeviceVulkanMemoryModelFeatures& copy_src); + safe_VkPhysicalDeviceVulkanMemoryModelFeatures& operator=(const safe_VkPhysicalDeviceVulkanMemoryModelFeatures& copy_src); + safe_VkPhysicalDeviceVulkanMemoryModelFeatures(); + ~safe_VkPhysicalDeviceVulkanMemoryModelFeatures(); + void initialize(const VkPhysicalDeviceVulkanMemoryModelFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVulkanMemoryModelFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVulkanMemoryModelFeatures* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceVulkanMemoryModelFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceImagelessFramebufferFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 imagelessFramebuffer; + + safe_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceImagelessFramebufferFeatures(const safe_VkPhysicalDeviceImagelessFramebufferFeatures& copy_src); + safe_VkPhysicalDeviceImagelessFramebufferFeatures& operator=(const safe_VkPhysicalDeviceImagelessFramebufferFeatures& copy_src); + safe_VkPhysicalDeviceImagelessFramebufferFeatures(); + ~safe_VkPhysicalDeviceImagelessFramebufferFeatures(); + void initialize(const VkPhysicalDeviceImagelessFramebufferFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceImagelessFramebufferFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceImagelessFramebufferFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceImagelessFramebufferFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkFramebufferAttachmentImageInfo { + VkStructureType sType; + const void* pNext{}; + VkImageCreateFlags flags; + VkImageUsageFlags usage; + uint32_t width; + uint32_t height; + uint32_t layerCount; + uint32_t viewFormatCount; + const VkFormat* pViewFormats{}; + + safe_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkFramebufferAttachmentImageInfo(const safe_VkFramebufferAttachmentImageInfo& copy_src); + safe_VkFramebufferAttachmentImageInfo& operator=(const safe_VkFramebufferAttachmentImageInfo& copy_src); + safe_VkFramebufferAttachmentImageInfo(); + ~safe_VkFramebufferAttachmentImageInfo(); + void initialize(const VkFramebufferAttachmentImageInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkFramebufferAttachmentImageInfo* copy_src, PNextCopyState* copy_state = {}); + VkFramebufferAttachmentImageInfo* ptr() { return reinterpret_cast(this); } + VkFramebufferAttachmentImageInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkFramebufferAttachmentsCreateInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t attachmentImageInfoCount; + safe_VkFramebufferAttachmentImageInfo* pAttachmentImageInfos{}; + + safe_VkFramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkFramebufferAttachmentsCreateInfo(const safe_VkFramebufferAttachmentsCreateInfo& copy_src); + safe_VkFramebufferAttachmentsCreateInfo& operator=(const safe_VkFramebufferAttachmentsCreateInfo& copy_src); + safe_VkFramebufferAttachmentsCreateInfo(); + ~safe_VkFramebufferAttachmentsCreateInfo(); + void initialize(const VkFramebufferAttachmentsCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkFramebufferAttachmentsCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkFramebufferAttachmentsCreateInfo* ptr() { return reinterpret_cast(this); } + VkFramebufferAttachmentsCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRenderPassAttachmentBeginInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t attachmentCount; + VkImageView* pAttachments{}; + + safe_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkRenderPassAttachmentBeginInfo(const safe_VkRenderPassAttachmentBeginInfo& copy_src); + safe_VkRenderPassAttachmentBeginInfo& operator=(const safe_VkRenderPassAttachmentBeginInfo& copy_src); + safe_VkRenderPassAttachmentBeginInfo(); + ~safe_VkRenderPassAttachmentBeginInfo(); + void initialize(const VkRenderPassAttachmentBeginInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderPassAttachmentBeginInfo* copy_src, PNextCopyState* copy_state = {}); + VkRenderPassAttachmentBeginInfo* ptr() { return reinterpret_cast(this); } + VkRenderPassAttachmentBeginInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 uniformBufferStandardLayout; + + safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures( + const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& copy_src); + safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& operator=( + const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& copy_src); + safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(); + ~safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(); + void initialize(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceUniformBufferStandardLayoutFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceUniformBufferStandardLayoutFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderSubgroupExtendedTypes; + + safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures( + const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& copy_src); + safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& operator=( + const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& copy_src); + safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(); + ~safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(); + void initialize(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 separateDepthStencilLayouts; + + safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures( + const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& copy_src); + safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& operator=( + const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& copy_src); + safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(); + ~safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(); + void initialize(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAttachmentReferenceStencilLayout { + VkStructureType sType; + void* pNext{}; + VkImageLayout stencilLayout; + + safe_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkAttachmentReferenceStencilLayout(const safe_VkAttachmentReferenceStencilLayout& copy_src); + safe_VkAttachmentReferenceStencilLayout& operator=(const safe_VkAttachmentReferenceStencilLayout& copy_src); + safe_VkAttachmentReferenceStencilLayout(); + ~safe_VkAttachmentReferenceStencilLayout(); + void initialize(const VkAttachmentReferenceStencilLayout* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAttachmentReferenceStencilLayout* copy_src, PNextCopyState* copy_state = {}); + VkAttachmentReferenceStencilLayout* ptr() { return reinterpret_cast(this); } + VkAttachmentReferenceStencilLayout const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAttachmentDescriptionStencilLayout { + VkStructureType sType; + void* pNext{}; + VkImageLayout stencilInitialLayout; + VkImageLayout stencilFinalLayout; + + safe_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAttachmentDescriptionStencilLayout(const safe_VkAttachmentDescriptionStencilLayout& copy_src); + safe_VkAttachmentDescriptionStencilLayout& operator=(const safe_VkAttachmentDescriptionStencilLayout& copy_src); + safe_VkAttachmentDescriptionStencilLayout(); + ~safe_VkAttachmentDescriptionStencilLayout(); + void initialize(const VkAttachmentDescriptionStencilLayout* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAttachmentDescriptionStencilLayout* copy_src, PNextCopyState* copy_state = {}); + VkAttachmentDescriptionStencilLayout* ptr() { return reinterpret_cast(this); } + VkAttachmentDescriptionStencilLayout const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceHostQueryResetFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 hostQueryReset; + + safe_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceHostQueryResetFeatures(const safe_VkPhysicalDeviceHostQueryResetFeatures& copy_src); + safe_VkPhysicalDeviceHostQueryResetFeatures& operator=(const safe_VkPhysicalDeviceHostQueryResetFeatures& copy_src); + safe_VkPhysicalDeviceHostQueryResetFeatures(); + ~safe_VkPhysicalDeviceHostQueryResetFeatures(); + void initialize(const VkPhysicalDeviceHostQueryResetFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceHostQueryResetFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceHostQueryResetFeatures* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceHostQueryResetFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceTimelineSemaphoreFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 timelineSemaphore; + + safe_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceTimelineSemaphoreFeatures(const safe_VkPhysicalDeviceTimelineSemaphoreFeatures& copy_src); + safe_VkPhysicalDeviceTimelineSemaphoreFeatures& operator=(const safe_VkPhysicalDeviceTimelineSemaphoreFeatures& copy_src); + safe_VkPhysicalDeviceTimelineSemaphoreFeatures(); + ~safe_VkPhysicalDeviceTimelineSemaphoreFeatures(); + void initialize(const VkPhysicalDeviceTimelineSemaphoreFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceTimelineSemaphoreFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceTimelineSemaphoreFeatures* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceTimelineSemaphoreFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceTimelineSemaphoreProperties { + VkStructureType sType; + void* pNext{}; + uint64_t maxTimelineSemaphoreValueDifference; + + safe_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceTimelineSemaphoreProperties(const safe_VkPhysicalDeviceTimelineSemaphoreProperties& copy_src); + safe_VkPhysicalDeviceTimelineSemaphoreProperties& operator=(const safe_VkPhysicalDeviceTimelineSemaphoreProperties& copy_src); + safe_VkPhysicalDeviceTimelineSemaphoreProperties(); + ~safe_VkPhysicalDeviceTimelineSemaphoreProperties(); + void initialize(const VkPhysicalDeviceTimelineSemaphoreProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceTimelineSemaphoreProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceTimelineSemaphoreProperties* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceTimelineSemaphoreProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSemaphoreTypeCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkSemaphoreType semaphoreType; + uint64_t initialValue; + + safe_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSemaphoreTypeCreateInfo(const safe_VkSemaphoreTypeCreateInfo& copy_src); + safe_VkSemaphoreTypeCreateInfo& operator=(const safe_VkSemaphoreTypeCreateInfo& copy_src); + safe_VkSemaphoreTypeCreateInfo(); + ~safe_VkSemaphoreTypeCreateInfo(); + void initialize(const VkSemaphoreTypeCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSemaphoreTypeCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkSemaphoreTypeCreateInfo* ptr() { return reinterpret_cast(this); } + VkSemaphoreTypeCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkTimelineSemaphoreSubmitInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t waitSemaphoreValueCount; + const uint64_t* pWaitSemaphoreValues{}; + uint32_t signalSemaphoreValueCount; + const uint64_t* pSignalSemaphoreValues{}; + + safe_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkTimelineSemaphoreSubmitInfo(const safe_VkTimelineSemaphoreSubmitInfo& copy_src); + safe_VkTimelineSemaphoreSubmitInfo& operator=(const safe_VkTimelineSemaphoreSubmitInfo& copy_src); + safe_VkTimelineSemaphoreSubmitInfo(); + ~safe_VkTimelineSemaphoreSubmitInfo(); + void initialize(const VkTimelineSemaphoreSubmitInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkTimelineSemaphoreSubmitInfo* copy_src, PNextCopyState* copy_state = {}); + VkTimelineSemaphoreSubmitInfo* ptr() { return reinterpret_cast(this); } + VkTimelineSemaphoreSubmitInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSemaphoreWaitInfo { + VkStructureType sType; + const void* pNext{}; + VkSemaphoreWaitFlags flags; + uint32_t semaphoreCount; + VkSemaphore* pSemaphores{}; + const uint64_t* pValues{}; + + safe_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSemaphoreWaitInfo(const safe_VkSemaphoreWaitInfo& copy_src); + safe_VkSemaphoreWaitInfo& operator=(const safe_VkSemaphoreWaitInfo& copy_src); + safe_VkSemaphoreWaitInfo(); + ~safe_VkSemaphoreWaitInfo(); + void initialize(const VkSemaphoreWaitInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSemaphoreWaitInfo* copy_src, PNextCopyState* copy_state = {}); + VkSemaphoreWaitInfo* ptr() { return reinterpret_cast(this); } + VkSemaphoreWaitInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSemaphoreSignalInfo { + VkStructureType sType; + const void* pNext{}; + VkSemaphore semaphore; + uint64_t value; + + safe_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSemaphoreSignalInfo(const safe_VkSemaphoreSignalInfo& copy_src); + safe_VkSemaphoreSignalInfo& operator=(const safe_VkSemaphoreSignalInfo& copy_src); + safe_VkSemaphoreSignalInfo(); + ~safe_VkSemaphoreSignalInfo(); + void initialize(const VkSemaphoreSignalInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSemaphoreSignalInfo* copy_src, PNextCopyState* copy_state = {}); + VkSemaphoreSignalInfo* ptr() { return reinterpret_cast(this); } + VkSemaphoreSignalInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceBufferDeviceAddressFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; + + safe_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceBufferDeviceAddressFeatures(const safe_VkPhysicalDeviceBufferDeviceAddressFeatures& copy_src); + safe_VkPhysicalDeviceBufferDeviceAddressFeatures& operator=(const safe_VkPhysicalDeviceBufferDeviceAddressFeatures& copy_src); + safe_VkPhysicalDeviceBufferDeviceAddressFeatures(); + ~safe_VkPhysicalDeviceBufferDeviceAddressFeatures(); + void initialize(const VkPhysicalDeviceBufferDeviceAddressFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceBufferDeviceAddressFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceBufferDeviceAddressFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceBufferDeviceAddressFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkBufferDeviceAddressInfo { + VkStructureType sType; + const void* pNext{}; + VkBuffer buffer; + + safe_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkBufferDeviceAddressInfo(const safe_VkBufferDeviceAddressInfo& copy_src); + safe_VkBufferDeviceAddressInfo& operator=(const safe_VkBufferDeviceAddressInfo& copy_src); + safe_VkBufferDeviceAddressInfo(); + ~safe_VkBufferDeviceAddressInfo(); + void initialize(const VkBufferDeviceAddressInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBufferDeviceAddressInfo* copy_src, PNextCopyState* copy_state = {}); + VkBufferDeviceAddressInfo* ptr() { return reinterpret_cast(this); } + VkBufferDeviceAddressInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkBufferOpaqueCaptureAddressCreateInfo { + VkStructureType sType; + const void* pNext{}; + uint64_t opaqueCaptureAddress; + + safe_VkBufferOpaqueCaptureAddressCreateInfo(const VkBufferOpaqueCaptureAddressCreateInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkBufferOpaqueCaptureAddressCreateInfo(const safe_VkBufferOpaqueCaptureAddressCreateInfo& copy_src); + safe_VkBufferOpaqueCaptureAddressCreateInfo& operator=(const safe_VkBufferOpaqueCaptureAddressCreateInfo& copy_src); + safe_VkBufferOpaqueCaptureAddressCreateInfo(); + ~safe_VkBufferOpaqueCaptureAddressCreateInfo(); + void initialize(const VkBufferOpaqueCaptureAddressCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBufferOpaqueCaptureAddressCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkBufferOpaqueCaptureAddressCreateInfo* ptr() { return reinterpret_cast(this); } + VkBufferOpaqueCaptureAddressCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkMemoryOpaqueCaptureAddressAllocateInfo { + VkStructureType sType; + const void* pNext{}; + uint64_t opaqueCaptureAddress; + + safe_VkMemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMemoryOpaqueCaptureAddressAllocateInfo(const safe_VkMemoryOpaqueCaptureAddressAllocateInfo& copy_src); + safe_VkMemoryOpaqueCaptureAddressAllocateInfo& operator=(const safe_VkMemoryOpaqueCaptureAddressAllocateInfo& copy_src); + safe_VkMemoryOpaqueCaptureAddressAllocateInfo(); + ~safe_VkMemoryOpaqueCaptureAddressAllocateInfo(); + void initialize(const VkMemoryOpaqueCaptureAddressAllocateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryOpaqueCaptureAddressAllocateInfo* copy_src, PNextCopyState* copy_state = {}); + VkMemoryOpaqueCaptureAddressAllocateInfo* ptr() { return reinterpret_cast(this); } + VkMemoryOpaqueCaptureAddressAllocateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDeviceMemoryOpaqueCaptureAddressInfo { + VkStructureType sType; + const void* pNext{}; + VkDeviceMemory memory; + + safe_VkDeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDeviceMemoryOpaqueCaptureAddressInfo(const safe_VkDeviceMemoryOpaqueCaptureAddressInfo& copy_src); + safe_VkDeviceMemoryOpaqueCaptureAddressInfo& operator=(const safe_VkDeviceMemoryOpaqueCaptureAddressInfo& copy_src); + safe_VkDeviceMemoryOpaqueCaptureAddressInfo(); + ~safe_VkDeviceMemoryOpaqueCaptureAddressInfo(); + void initialize(const VkDeviceMemoryOpaqueCaptureAddressInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceMemoryOpaqueCaptureAddressInfo* copy_src, PNextCopyState* copy_state = {}); + VkDeviceMemoryOpaqueCaptureAddressInfo* ptr() { return reinterpret_cast(this); } + VkDeviceMemoryOpaqueCaptureAddressInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceVulkan13Features { + VkStructureType sType; + void* pNext{}; + VkBool32 robustImageAccess; + VkBool32 inlineUniformBlock; + VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; + VkBool32 pipelineCreationCacheControl; + VkBool32 privateData; + VkBool32 shaderDemoteToHelperInvocation; + VkBool32 shaderTerminateInvocation; + VkBool32 subgroupSizeControl; + VkBool32 computeFullSubgroups; + VkBool32 synchronization2; + VkBool32 textureCompressionASTC_HDR; + VkBool32 shaderZeroInitializeWorkgroupMemory; + VkBool32 dynamicRendering; + VkBool32 shaderIntegerDotProduct; + VkBool32 maintenance4; + + safe_VkPhysicalDeviceVulkan13Features(const VkPhysicalDeviceVulkan13Features* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceVulkan13Features(const safe_VkPhysicalDeviceVulkan13Features& copy_src); + safe_VkPhysicalDeviceVulkan13Features& operator=(const safe_VkPhysicalDeviceVulkan13Features& copy_src); + safe_VkPhysicalDeviceVulkan13Features(); + ~safe_VkPhysicalDeviceVulkan13Features(); + void initialize(const VkPhysicalDeviceVulkan13Features* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVulkan13Features* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVulkan13Features* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceVulkan13Features const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceVulkan13Properties { + VkStructureType sType; + void* pNext{}; + uint32_t minSubgroupSize; + uint32_t maxSubgroupSize; + uint32_t maxComputeWorkgroupSubgroups; + VkShaderStageFlags requiredSubgroupSizeStages; + uint32_t maxInlineUniformBlockSize; + uint32_t maxPerStageDescriptorInlineUniformBlocks; + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + uint32_t maxDescriptorSetInlineUniformBlocks; + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; + uint32_t maxInlineUniformTotalSize; + VkBool32 integerDotProduct8BitUnsignedAccelerated; + VkBool32 integerDotProduct8BitSignedAccelerated; + VkBool32 integerDotProduct8BitMixedSignednessAccelerated; + VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedSignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProduct16BitUnsignedAccelerated; + VkBool32 integerDotProduct16BitSignedAccelerated; + VkBool32 integerDotProduct16BitMixedSignednessAccelerated; + VkBool32 integerDotProduct32BitUnsignedAccelerated; + VkBool32 integerDotProduct32BitSignedAccelerated; + VkBool32 integerDotProduct32BitMixedSignednessAccelerated; + VkBool32 integerDotProduct64BitUnsignedAccelerated; + VkBool32 integerDotProduct64BitSignedAccelerated; + VkBool32 integerDotProduct64BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; + VkDeviceSize storageTexelBufferOffsetAlignmentBytes; + VkBool32 storageTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; + VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize maxBufferSize; + + safe_VkPhysicalDeviceVulkan13Properties(const VkPhysicalDeviceVulkan13Properties* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceVulkan13Properties(const safe_VkPhysicalDeviceVulkan13Properties& copy_src); + safe_VkPhysicalDeviceVulkan13Properties& operator=(const safe_VkPhysicalDeviceVulkan13Properties& copy_src); + safe_VkPhysicalDeviceVulkan13Properties(); + ~safe_VkPhysicalDeviceVulkan13Properties(); + void initialize(const VkPhysicalDeviceVulkan13Properties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVulkan13Properties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVulkan13Properties* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceVulkan13Properties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineCreationFeedbackCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkPipelineCreationFeedback* pPipelineCreationFeedback{}; + uint32_t pipelineStageCreationFeedbackCount; + VkPipelineCreationFeedback* pPipelineStageCreationFeedbacks{}; + + safe_VkPipelineCreationFeedbackCreateInfo(const VkPipelineCreationFeedbackCreateInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineCreationFeedbackCreateInfo(const safe_VkPipelineCreationFeedbackCreateInfo& copy_src); + safe_VkPipelineCreationFeedbackCreateInfo& operator=(const safe_VkPipelineCreationFeedbackCreateInfo& copy_src); + safe_VkPipelineCreationFeedbackCreateInfo(); + ~safe_VkPipelineCreationFeedbackCreateInfo(); + void initialize(const VkPipelineCreationFeedbackCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineCreationFeedbackCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineCreationFeedbackCreateInfo* ptr() { return reinterpret_cast(this); } + VkPipelineCreationFeedbackCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderTerminateInvocationFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderTerminateInvocation; + + safe_VkPhysicalDeviceShaderTerminateInvocationFeatures(const VkPhysicalDeviceShaderTerminateInvocationFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderTerminateInvocationFeatures(const safe_VkPhysicalDeviceShaderTerminateInvocationFeatures& copy_src); + safe_VkPhysicalDeviceShaderTerminateInvocationFeatures& operator=( + const safe_VkPhysicalDeviceShaderTerminateInvocationFeatures& copy_src); + safe_VkPhysicalDeviceShaderTerminateInvocationFeatures(); + ~safe_VkPhysicalDeviceShaderTerminateInvocationFeatures(); + void initialize(const VkPhysicalDeviceShaderTerminateInvocationFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderTerminateInvocationFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderTerminateInvocationFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderTerminateInvocationFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceToolProperties { + VkStructureType sType; + void* pNext{}; + char name[VK_MAX_EXTENSION_NAME_SIZE]; + char version[VK_MAX_EXTENSION_NAME_SIZE]; + VkToolPurposeFlags purposes; + char description[VK_MAX_DESCRIPTION_SIZE]; + char layer[VK_MAX_EXTENSION_NAME_SIZE]; + + safe_VkPhysicalDeviceToolProperties(const VkPhysicalDeviceToolProperties* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceToolProperties(const safe_VkPhysicalDeviceToolProperties& copy_src); + safe_VkPhysicalDeviceToolProperties& operator=(const safe_VkPhysicalDeviceToolProperties& copy_src); + safe_VkPhysicalDeviceToolProperties(); + ~safe_VkPhysicalDeviceToolProperties(); + void initialize(const VkPhysicalDeviceToolProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceToolProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceToolProperties* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceToolProperties const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderDemoteToHelperInvocation; + + safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures( + const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures( + const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& copy_src); + safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& operator=( + const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& copy_src); + safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(); + ~safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(); + void initialize(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDevicePrivateDataFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 privateData; + + safe_VkPhysicalDevicePrivateDataFeatures(const VkPhysicalDevicePrivateDataFeatures* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDevicePrivateDataFeatures(const safe_VkPhysicalDevicePrivateDataFeatures& copy_src); + safe_VkPhysicalDevicePrivateDataFeatures& operator=(const safe_VkPhysicalDevicePrivateDataFeatures& copy_src); + safe_VkPhysicalDevicePrivateDataFeatures(); + ~safe_VkPhysicalDevicePrivateDataFeatures(); + void initialize(const VkPhysicalDevicePrivateDataFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePrivateDataFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePrivateDataFeatures* ptr() { return reinterpret_cast(this); } + VkPhysicalDevicePrivateDataFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDevicePrivateDataCreateInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t privateDataSlotRequestCount; + + safe_VkDevicePrivateDataCreateInfo(const VkDevicePrivateDataCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDevicePrivateDataCreateInfo(const safe_VkDevicePrivateDataCreateInfo& copy_src); + safe_VkDevicePrivateDataCreateInfo& operator=(const safe_VkDevicePrivateDataCreateInfo& copy_src); + safe_VkDevicePrivateDataCreateInfo(); + ~safe_VkDevicePrivateDataCreateInfo(); + void initialize(const VkDevicePrivateDataCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDevicePrivateDataCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkDevicePrivateDataCreateInfo* ptr() { return reinterpret_cast(this); } + VkDevicePrivateDataCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPrivateDataSlotCreateInfo { + VkStructureType sType; + const void* pNext{}; + VkPrivateDataSlotCreateFlags flags; + + safe_VkPrivateDataSlotCreateInfo(const VkPrivateDataSlotCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPrivateDataSlotCreateInfo(const safe_VkPrivateDataSlotCreateInfo& copy_src); + safe_VkPrivateDataSlotCreateInfo& operator=(const safe_VkPrivateDataSlotCreateInfo& copy_src); + safe_VkPrivateDataSlotCreateInfo(); + ~safe_VkPrivateDataSlotCreateInfo(); + void initialize(const VkPrivateDataSlotCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPrivateDataSlotCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPrivateDataSlotCreateInfo* ptr() { return reinterpret_cast(this); } + VkPrivateDataSlotCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDevicePipelineCreationCacheControlFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 pipelineCreationCacheControl; + + safe_VkPhysicalDevicePipelineCreationCacheControlFeatures(const VkPhysicalDevicePipelineCreationCacheControlFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePipelineCreationCacheControlFeatures( + const safe_VkPhysicalDevicePipelineCreationCacheControlFeatures& copy_src); + safe_VkPhysicalDevicePipelineCreationCacheControlFeatures& operator=( + const safe_VkPhysicalDevicePipelineCreationCacheControlFeatures& copy_src); + safe_VkPhysicalDevicePipelineCreationCacheControlFeatures(); + ~safe_VkPhysicalDevicePipelineCreationCacheControlFeatures(); + void initialize(const VkPhysicalDevicePipelineCreationCacheControlFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePipelineCreationCacheControlFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePipelineCreationCacheControlFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDevicePipelineCreationCacheControlFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkMemoryBarrier2 { + VkStructureType sType; + const void* pNext{}; + VkPipelineStageFlags2 srcStageMask; + VkAccessFlags2 srcAccessMask; + VkPipelineStageFlags2 dstStageMask; + VkAccessFlags2 dstAccessMask; + + safe_VkMemoryBarrier2(const VkMemoryBarrier2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMemoryBarrier2(const safe_VkMemoryBarrier2& copy_src); + safe_VkMemoryBarrier2& operator=(const safe_VkMemoryBarrier2& copy_src); + safe_VkMemoryBarrier2(); + ~safe_VkMemoryBarrier2(); + void initialize(const VkMemoryBarrier2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryBarrier2* copy_src, PNextCopyState* copy_state = {}); + VkMemoryBarrier2* ptr() { return reinterpret_cast(this); } + VkMemoryBarrier2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkBufferMemoryBarrier2 { + VkStructureType sType; + const void* pNext{}; + VkPipelineStageFlags2 srcStageMask; + VkAccessFlags2 srcAccessMask; + VkPipelineStageFlags2 dstStageMask; + VkAccessFlags2 dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; + + safe_VkBufferMemoryBarrier2(const VkBufferMemoryBarrier2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkBufferMemoryBarrier2(const safe_VkBufferMemoryBarrier2& copy_src); + safe_VkBufferMemoryBarrier2& operator=(const safe_VkBufferMemoryBarrier2& copy_src); + safe_VkBufferMemoryBarrier2(); + ~safe_VkBufferMemoryBarrier2(); + void initialize(const VkBufferMemoryBarrier2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBufferMemoryBarrier2* copy_src, PNextCopyState* copy_state = {}); + VkBufferMemoryBarrier2* ptr() { return reinterpret_cast(this); } + VkBufferMemoryBarrier2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImageMemoryBarrier2 { + VkStructureType sType; + const void* pNext{}; + VkPipelineStageFlags2 srcStageMask; + VkAccessFlags2 srcAccessMask; + VkPipelineStageFlags2 dstStageMask; + VkAccessFlags2 dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; + + safe_VkImageMemoryBarrier2(const VkImageMemoryBarrier2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImageMemoryBarrier2(const safe_VkImageMemoryBarrier2& copy_src); + safe_VkImageMemoryBarrier2& operator=(const safe_VkImageMemoryBarrier2& copy_src); + safe_VkImageMemoryBarrier2(); + ~safe_VkImageMemoryBarrier2(); + void initialize(const VkImageMemoryBarrier2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageMemoryBarrier2* copy_src, PNextCopyState* copy_state = {}); + VkImageMemoryBarrier2* ptr() { return reinterpret_cast(this); } + VkImageMemoryBarrier2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDependencyInfo { + VkStructureType sType; + const void* pNext{}; + VkDependencyFlags dependencyFlags; + uint32_t memoryBarrierCount; + safe_VkMemoryBarrier2* pMemoryBarriers{}; + uint32_t bufferMemoryBarrierCount; + safe_VkBufferMemoryBarrier2* pBufferMemoryBarriers{}; + uint32_t imageMemoryBarrierCount; + safe_VkImageMemoryBarrier2* pImageMemoryBarriers{}; + + safe_VkDependencyInfo(const VkDependencyInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDependencyInfo(const safe_VkDependencyInfo& copy_src); + safe_VkDependencyInfo& operator=(const safe_VkDependencyInfo& copy_src); + safe_VkDependencyInfo(); + ~safe_VkDependencyInfo(); + void initialize(const VkDependencyInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDependencyInfo* copy_src, PNextCopyState* copy_state = {}); + VkDependencyInfo* ptr() { return reinterpret_cast(this); } + VkDependencyInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSemaphoreSubmitInfo { + VkStructureType sType; + const void* pNext{}; + VkSemaphore semaphore; + uint64_t value; + VkPipelineStageFlags2 stageMask; + uint32_t deviceIndex; + + safe_VkSemaphoreSubmitInfo(const VkSemaphoreSubmitInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSemaphoreSubmitInfo(const safe_VkSemaphoreSubmitInfo& copy_src); + safe_VkSemaphoreSubmitInfo& operator=(const safe_VkSemaphoreSubmitInfo& copy_src); + safe_VkSemaphoreSubmitInfo(); + ~safe_VkSemaphoreSubmitInfo(); + void initialize(const VkSemaphoreSubmitInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSemaphoreSubmitInfo* copy_src, PNextCopyState* copy_state = {}); + VkSemaphoreSubmitInfo* ptr() { return reinterpret_cast(this); } + VkSemaphoreSubmitInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCommandBufferSubmitInfo { + VkStructureType sType; + const void* pNext{}; + VkCommandBuffer commandBuffer; + uint32_t deviceMask; + + safe_VkCommandBufferSubmitInfo(const VkCommandBufferSubmitInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCommandBufferSubmitInfo(const safe_VkCommandBufferSubmitInfo& copy_src); + safe_VkCommandBufferSubmitInfo& operator=(const safe_VkCommandBufferSubmitInfo& copy_src); + safe_VkCommandBufferSubmitInfo(); + ~safe_VkCommandBufferSubmitInfo(); + void initialize(const VkCommandBufferSubmitInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCommandBufferSubmitInfo* copy_src, PNextCopyState* copy_state = {}); + VkCommandBufferSubmitInfo* ptr() { return reinterpret_cast(this); } + VkCommandBufferSubmitInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSubmitInfo2 { + VkStructureType sType; + const void* pNext{}; + VkSubmitFlags flags; + uint32_t waitSemaphoreInfoCount; + safe_VkSemaphoreSubmitInfo* pWaitSemaphoreInfos{}; + uint32_t commandBufferInfoCount; + safe_VkCommandBufferSubmitInfo* pCommandBufferInfos{}; + uint32_t signalSemaphoreInfoCount; + safe_VkSemaphoreSubmitInfo* pSignalSemaphoreInfos{}; + + safe_VkSubmitInfo2(const VkSubmitInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSubmitInfo2(const safe_VkSubmitInfo2& copy_src); + safe_VkSubmitInfo2& operator=(const safe_VkSubmitInfo2& copy_src); + safe_VkSubmitInfo2(); + ~safe_VkSubmitInfo2(); + void initialize(const VkSubmitInfo2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSubmitInfo2* copy_src, PNextCopyState* copy_state = {}); + VkSubmitInfo2* ptr() { return reinterpret_cast(this); } + VkSubmitInfo2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceSynchronization2Features { + VkStructureType sType; + void* pNext{}; + VkBool32 synchronization2; + + safe_VkPhysicalDeviceSynchronization2Features(const VkPhysicalDeviceSynchronization2Features* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceSynchronization2Features(const safe_VkPhysicalDeviceSynchronization2Features& copy_src); + safe_VkPhysicalDeviceSynchronization2Features& operator=(const safe_VkPhysicalDeviceSynchronization2Features& copy_src); + safe_VkPhysicalDeviceSynchronization2Features(); + ~safe_VkPhysicalDeviceSynchronization2Features(); + void initialize(const VkPhysicalDeviceSynchronization2Features* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceSynchronization2Features* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceSynchronization2Features* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceSynchronization2Features const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderZeroInitializeWorkgroupMemory; + + safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures( + const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures( + const safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& copy_src); + safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& operator=( + const safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& copy_src); + safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(); + ~safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(); + void initialize(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceImageRobustnessFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 robustImageAccess; + + safe_VkPhysicalDeviceImageRobustnessFeatures(const VkPhysicalDeviceImageRobustnessFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceImageRobustnessFeatures(const safe_VkPhysicalDeviceImageRobustnessFeatures& copy_src); + safe_VkPhysicalDeviceImageRobustnessFeatures& operator=(const safe_VkPhysicalDeviceImageRobustnessFeatures& copy_src); + safe_VkPhysicalDeviceImageRobustnessFeatures(); + ~safe_VkPhysicalDeviceImageRobustnessFeatures(); + void initialize(const VkPhysicalDeviceImageRobustnessFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceImageRobustnessFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceImageRobustnessFeatures* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceImageRobustnessFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkBufferCopy2 { + VkStructureType sType; + const void* pNext{}; + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; + + safe_VkBufferCopy2(const VkBufferCopy2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkBufferCopy2(const safe_VkBufferCopy2& copy_src); + safe_VkBufferCopy2& operator=(const safe_VkBufferCopy2& copy_src); + safe_VkBufferCopy2(); + ~safe_VkBufferCopy2(); + void initialize(const VkBufferCopy2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBufferCopy2* copy_src, PNextCopyState* copy_state = {}); + VkBufferCopy2* ptr() { return reinterpret_cast(this); } + VkBufferCopy2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCopyBufferInfo2 { + VkStructureType sType; + const void* pNext{}; + VkBuffer srcBuffer; + VkBuffer dstBuffer; + uint32_t regionCount; + safe_VkBufferCopy2* pRegions{}; + + safe_VkCopyBufferInfo2(const VkCopyBufferInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkCopyBufferInfo2(const safe_VkCopyBufferInfo2& copy_src); + safe_VkCopyBufferInfo2& operator=(const safe_VkCopyBufferInfo2& copy_src); + safe_VkCopyBufferInfo2(); + ~safe_VkCopyBufferInfo2(); + void initialize(const VkCopyBufferInfo2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyBufferInfo2* copy_src, PNextCopyState* copy_state = {}); + VkCopyBufferInfo2* ptr() { return reinterpret_cast(this); } + VkCopyBufferInfo2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImageCopy2 { + VkStructureType sType; + const void* pNext{}; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; + + safe_VkImageCopy2(const VkImageCopy2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImageCopy2(const safe_VkImageCopy2& copy_src); + safe_VkImageCopy2& operator=(const safe_VkImageCopy2& copy_src); + safe_VkImageCopy2(); + ~safe_VkImageCopy2(); + void initialize(const VkImageCopy2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageCopy2* copy_src, PNextCopyState* copy_state = {}); + VkImageCopy2* ptr() { return reinterpret_cast(this); } + VkImageCopy2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCopyImageInfo2 { + VkStructureType sType; + const void* pNext{}; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + safe_VkImageCopy2* pRegions{}; + + safe_VkCopyImageInfo2(const VkCopyImageInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkCopyImageInfo2(const safe_VkCopyImageInfo2& copy_src); + safe_VkCopyImageInfo2& operator=(const safe_VkCopyImageInfo2& copy_src); + safe_VkCopyImageInfo2(); + ~safe_VkCopyImageInfo2(); + void initialize(const VkCopyImageInfo2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyImageInfo2* copy_src, PNextCopyState* copy_state = {}); + VkCopyImageInfo2* ptr() { return reinterpret_cast(this); } + VkCopyImageInfo2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkBufferImageCopy2 { + VkStructureType sType; + const void* pNext{}; + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; + + safe_VkBufferImageCopy2(const VkBufferImageCopy2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkBufferImageCopy2(const safe_VkBufferImageCopy2& copy_src); + safe_VkBufferImageCopy2& operator=(const safe_VkBufferImageCopy2& copy_src); + safe_VkBufferImageCopy2(); + ~safe_VkBufferImageCopy2(); + void initialize(const VkBufferImageCopy2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBufferImageCopy2* copy_src, PNextCopyState* copy_state = {}); + VkBufferImageCopy2* ptr() { return reinterpret_cast(this); } + VkBufferImageCopy2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCopyBufferToImageInfo2 { + VkStructureType sType; + const void* pNext{}; + VkBuffer srcBuffer; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + safe_VkBufferImageCopy2* pRegions{}; + + safe_VkCopyBufferToImageInfo2(const VkCopyBufferToImageInfo2* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCopyBufferToImageInfo2(const safe_VkCopyBufferToImageInfo2& copy_src); + safe_VkCopyBufferToImageInfo2& operator=(const safe_VkCopyBufferToImageInfo2& copy_src); + safe_VkCopyBufferToImageInfo2(); + ~safe_VkCopyBufferToImageInfo2(); + void initialize(const VkCopyBufferToImageInfo2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyBufferToImageInfo2* copy_src, PNextCopyState* copy_state = {}); + VkCopyBufferToImageInfo2* ptr() { return reinterpret_cast(this); } + VkCopyBufferToImageInfo2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCopyImageToBufferInfo2 { + VkStructureType sType; + const void* pNext{}; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkBuffer dstBuffer; + uint32_t regionCount; + safe_VkBufferImageCopy2* pRegions{}; + + safe_VkCopyImageToBufferInfo2(const VkCopyImageToBufferInfo2* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCopyImageToBufferInfo2(const safe_VkCopyImageToBufferInfo2& copy_src); + safe_VkCopyImageToBufferInfo2& operator=(const safe_VkCopyImageToBufferInfo2& copy_src); + safe_VkCopyImageToBufferInfo2(); + ~safe_VkCopyImageToBufferInfo2(); + void initialize(const VkCopyImageToBufferInfo2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyImageToBufferInfo2* copy_src, PNextCopyState* copy_state = {}); + VkCopyImageToBufferInfo2* ptr() { return reinterpret_cast(this); } + VkCopyImageToBufferInfo2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImageBlit2 { + VkStructureType sType; + const void* pNext{}; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffsets[2]; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffsets[2]; + + safe_VkImageBlit2(const VkImageBlit2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImageBlit2(const safe_VkImageBlit2& copy_src); + safe_VkImageBlit2& operator=(const safe_VkImageBlit2& copy_src); + safe_VkImageBlit2(); + ~safe_VkImageBlit2(); + void initialize(const VkImageBlit2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageBlit2* copy_src, PNextCopyState* copy_state = {}); + VkImageBlit2* ptr() { return reinterpret_cast(this); } + VkImageBlit2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkBlitImageInfo2 { + VkStructureType sType; + const void* pNext{}; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + safe_VkImageBlit2* pRegions{}; + VkFilter filter; + + safe_VkBlitImageInfo2(const VkBlitImageInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkBlitImageInfo2(const safe_VkBlitImageInfo2& copy_src); + safe_VkBlitImageInfo2& operator=(const safe_VkBlitImageInfo2& copy_src); + safe_VkBlitImageInfo2(); + ~safe_VkBlitImageInfo2(); + void initialize(const VkBlitImageInfo2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBlitImageInfo2* copy_src, PNextCopyState* copy_state = {}); + VkBlitImageInfo2* ptr() { return reinterpret_cast(this); } + VkBlitImageInfo2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImageResolve2 { + VkStructureType sType; + const void* pNext{}; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; + + safe_VkImageResolve2(const VkImageResolve2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImageResolve2(const safe_VkImageResolve2& copy_src); + safe_VkImageResolve2& operator=(const safe_VkImageResolve2& copy_src); + safe_VkImageResolve2(); + ~safe_VkImageResolve2(); + void initialize(const VkImageResolve2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageResolve2* copy_src, PNextCopyState* copy_state = {}); + VkImageResolve2* ptr() { return reinterpret_cast(this); } + VkImageResolve2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkResolveImageInfo2 { + VkStructureType sType; + const void* pNext{}; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + safe_VkImageResolve2* pRegions{}; + + safe_VkResolveImageInfo2(const VkResolveImageInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkResolveImageInfo2(const safe_VkResolveImageInfo2& copy_src); + safe_VkResolveImageInfo2& operator=(const safe_VkResolveImageInfo2& copy_src); + safe_VkResolveImageInfo2(); + ~safe_VkResolveImageInfo2(); + void initialize(const VkResolveImageInfo2* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkResolveImageInfo2* copy_src, PNextCopyState* copy_state = {}); + VkResolveImageInfo2* ptr() { return reinterpret_cast(this); } + VkResolveImageInfo2 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceSubgroupSizeControlFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 subgroupSizeControl; + VkBool32 computeFullSubgroups; + + safe_VkPhysicalDeviceSubgroupSizeControlFeatures(const VkPhysicalDeviceSubgroupSizeControlFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceSubgroupSizeControlFeatures(const safe_VkPhysicalDeviceSubgroupSizeControlFeatures& copy_src); + safe_VkPhysicalDeviceSubgroupSizeControlFeatures& operator=(const safe_VkPhysicalDeviceSubgroupSizeControlFeatures& copy_src); + safe_VkPhysicalDeviceSubgroupSizeControlFeatures(); + ~safe_VkPhysicalDeviceSubgroupSizeControlFeatures(); + void initialize(const VkPhysicalDeviceSubgroupSizeControlFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceSubgroupSizeControlFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceSubgroupSizeControlFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceSubgroupSizeControlFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceSubgroupSizeControlProperties { + VkStructureType sType; + void* pNext{}; + uint32_t minSubgroupSize; + uint32_t maxSubgroupSize; + uint32_t maxComputeWorkgroupSubgroups; + VkShaderStageFlags requiredSubgroupSizeStages; + + safe_VkPhysicalDeviceSubgroupSizeControlProperties(const VkPhysicalDeviceSubgroupSizeControlProperties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceSubgroupSizeControlProperties(const safe_VkPhysicalDeviceSubgroupSizeControlProperties& copy_src); + safe_VkPhysicalDeviceSubgroupSizeControlProperties& operator=( + const safe_VkPhysicalDeviceSubgroupSizeControlProperties& copy_src); + safe_VkPhysicalDeviceSubgroupSizeControlProperties(); + ~safe_VkPhysicalDeviceSubgroupSizeControlProperties(); + void initialize(const VkPhysicalDeviceSubgroupSizeControlProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceSubgroupSizeControlProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceSubgroupSizeControlProperties* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceSubgroupSizeControlProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo { + VkStructureType sType; + void* pNext{}; + uint32_t requiredSubgroupSize; + + safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo( + const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& copy_src); + safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& operator=( + const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& copy_src); + safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(); + ~safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(); + void initialize(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* ptr() { + return reinterpret_cast(this); + } + VkPipelineShaderStageRequiredSubgroupSizeCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceInlineUniformBlockFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 inlineUniformBlock; + VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; + + safe_VkPhysicalDeviceInlineUniformBlockFeatures(const VkPhysicalDeviceInlineUniformBlockFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceInlineUniformBlockFeatures(const safe_VkPhysicalDeviceInlineUniformBlockFeatures& copy_src); + safe_VkPhysicalDeviceInlineUniformBlockFeatures& operator=(const safe_VkPhysicalDeviceInlineUniformBlockFeatures& copy_src); + safe_VkPhysicalDeviceInlineUniformBlockFeatures(); + ~safe_VkPhysicalDeviceInlineUniformBlockFeatures(); + void initialize(const VkPhysicalDeviceInlineUniformBlockFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceInlineUniformBlockFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceInlineUniformBlockFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceInlineUniformBlockFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceInlineUniformBlockProperties { + VkStructureType sType; + void* pNext{}; + uint32_t maxInlineUniformBlockSize; + uint32_t maxPerStageDescriptorInlineUniformBlocks; + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + uint32_t maxDescriptorSetInlineUniformBlocks; + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; + + safe_VkPhysicalDeviceInlineUniformBlockProperties(const VkPhysicalDeviceInlineUniformBlockProperties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceInlineUniformBlockProperties(const safe_VkPhysicalDeviceInlineUniformBlockProperties& copy_src); + safe_VkPhysicalDeviceInlineUniformBlockProperties& operator=(const safe_VkPhysicalDeviceInlineUniformBlockProperties& copy_src); + safe_VkPhysicalDeviceInlineUniformBlockProperties(); + ~safe_VkPhysicalDeviceInlineUniformBlockProperties(); + void initialize(const VkPhysicalDeviceInlineUniformBlockProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceInlineUniformBlockProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceInlineUniformBlockProperties* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceInlineUniformBlockProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkWriteDescriptorSetInlineUniformBlock { + VkStructureType sType; + const void* pNext{}; + uint32_t dataSize; + const void* pData{}; + + safe_VkWriteDescriptorSetInlineUniformBlock(const VkWriteDescriptorSetInlineUniformBlock* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkWriteDescriptorSetInlineUniformBlock(const safe_VkWriteDescriptorSetInlineUniformBlock& copy_src); + safe_VkWriteDescriptorSetInlineUniformBlock& operator=(const safe_VkWriteDescriptorSetInlineUniformBlock& copy_src); + safe_VkWriteDescriptorSetInlineUniformBlock(); + ~safe_VkWriteDescriptorSetInlineUniformBlock(); + void initialize(const VkWriteDescriptorSetInlineUniformBlock* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkWriteDescriptorSetInlineUniformBlock* copy_src, PNextCopyState* copy_state = {}); + VkWriteDescriptorSetInlineUniformBlock* ptr() { return reinterpret_cast(this); } + VkWriteDescriptorSetInlineUniformBlock const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDescriptorPoolInlineUniformBlockCreateInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t maxInlineUniformBlockBindings; + + safe_VkDescriptorPoolInlineUniformBlockCreateInfo(const VkDescriptorPoolInlineUniformBlockCreateInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDescriptorPoolInlineUniformBlockCreateInfo(const safe_VkDescriptorPoolInlineUniformBlockCreateInfo& copy_src); + safe_VkDescriptorPoolInlineUniformBlockCreateInfo& operator=(const safe_VkDescriptorPoolInlineUniformBlockCreateInfo& copy_src); + safe_VkDescriptorPoolInlineUniformBlockCreateInfo(); + ~safe_VkDescriptorPoolInlineUniformBlockCreateInfo(); + void initialize(const VkDescriptorPoolInlineUniformBlockCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDescriptorPoolInlineUniformBlockCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkDescriptorPoolInlineUniformBlockCreateInfo* ptr() { + return reinterpret_cast(this); + } + VkDescriptorPoolInlineUniformBlockCreateInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 textureCompressionASTC_HDR; + + safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures& copy_src); + safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures& operator=( + const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures& copy_src); + safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(); + ~safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(); + void initialize(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceTextureCompressionASTCHDRFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceTextureCompressionASTCHDRFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRenderingAttachmentInfo { + VkStructureType sType; + const void* pNext{}; + VkImageView imageView; + VkImageLayout imageLayout; + VkResolveModeFlagBits resolveMode; + VkImageView resolveImageView; + VkImageLayout resolveImageLayout; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkClearValue clearValue; + + safe_VkRenderingAttachmentInfo(const VkRenderingAttachmentInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkRenderingAttachmentInfo(const safe_VkRenderingAttachmentInfo& copy_src); + safe_VkRenderingAttachmentInfo& operator=(const safe_VkRenderingAttachmentInfo& copy_src); + safe_VkRenderingAttachmentInfo(); + ~safe_VkRenderingAttachmentInfo(); + void initialize(const VkRenderingAttachmentInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderingAttachmentInfo* copy_src, PNextCopyState* copy_state = {}); + VkRenderingAttachmentInfo* ptr() { return reinterpret_cast(this); } + VkRenderingAttachmentInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkRenderingInfo { + VkStructureType sType; + const void* pNext{}; + VkRenderingFlags flags; + VkRect2D renderArea; + uint32_t layerCount; + uint32_t viewMask; + uint32_t colorAttachmentCount; + safe_VkRenderingAttachmentInfo* pColorAttachments{}; + safe_VkRenderingAttachmentInfo* pDepthAttachment{}; + safe_VkRenderingAttachmentInfo* pStencilAttachment{}; + + safe_VkRenderingInfo(const VkRenderingInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkRenderingInfo(const safe_VkRenderingInfo& copy_src); + safe_VkRenderingInfo& operator=(const safe_VkRenderingInfo& copy_src); + safe_VkRenderingInfo(); + ~safe_VkRenderingInfo(); + void initialize(const VkRenderingInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderingInfo* copy_src, PNextCopyState* copy_state = {}); + VkRenderingInfo* ptr() { return reinterpret_cast(this); } + VkRenderingInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPipelineRenderingCreateInfo { + VkStructureType sType; + const void* pNext{}; + uint32_t viewMask; + uint32_t colorAttachmentCount; + const VkFormat* pColorAttachmentFormats{}; + VkFormat depthAttachmentFormat; + VkFormat stencilAttachmentFormat; + + safe_VkPipelineRenderingCreateInfo(const VkPipelineRenderingCreateInfo* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineRenderingCreateInfo(const safe_VkPipelineRenderingCreateInfo& copy_src); + safe_VkPipelineRenderingCreateInfo& operator=(const safe_VkPipelineRenderingCreateInfo& copy_src); + safe_VkPipelineRenderingCreateInfo(); + ~safe_VkPipelineRenderingCreateInfo(); + void initialize(const VkPipelineRenderingCreateInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineRenderingCreateInfo* copy_src, PNextCopyState* copy_state = {}); + VkPipelineRenderingCreateInfo* ptr() { return reinterpret_cast(this); } + VkPipelineRenderingCreateInfo const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceDynamicRenderingFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 dynamicRendering; + + safe_VkPhysicalDeviceDynamicRenderingFeatures(const VkPhysicalDeviceDynamicRenderingFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDynamicRenderingFeatures(const safe_VkPhysicalDeviceDynamicRenderingFeatures& copy_src); + safe_VkPhysicalDeviceDynamicRenderingFeatures& operator=(const safe_VkPhysicalDeviceDynamicRenderingFeatures& copy_src); + safe_VkPhysicalDeviceDynamicRenderingFeatures(); + ~safe_VkPhysicalDeviceDynamicRenderingFeatures(); + void initialize(const VkPhysicalDeviceDynamicRenderingFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDynamicRenderingFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDynamicRenderingFeatures* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceDynamicRenderingFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkCommandBufferInheritanceRenderingInfo { + VkStructureType sType; + const void* pNext{}; + VkRenderingFlags flags; + uint32_t viewMask; + uint32_t colorAttachmentCount; + const VkFormat* pColorAttachmentFormats{}; + VkFormat depthAttachmentFormat; + VkFormat stencilAttachmentFormat; + VkSampleCountFlagBits rasterizationSamples; + + safe_VkCommandBufferInheritanceRenderingInfo(const VkCommandBufferInheritanceRenderingInfo* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkCommandBufferInheritanceRenderingInfo(const safe_VkCommandBufferInheritanceRenderingInfo& copy_src); + safe_VkCommandBufferInheritanceRenderingInfo& operator=(const safe_VkCommandBufferInheritanceRenderingInfo& copy_src); + safe_VkCommandBufferInheritanceRenderingInfo(); + ~safe_VkCommandBufferInheritanceRenderingInfo(); + void initialize(const VkCommandBufferInheritanceRenderingInfo* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCommandBufferInheritanceRenderingInfo* copy_src, PNextCopyState* copy_state = {}); + VkCommandBufferInheritanceRenderingInfo* ptr() { return reinterpret_cast(this); } + VkCommandBufferInheritanceRenderingInfo const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderIntegerDotProductFeatures { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderIntegerDotProduct; + + safe_VkPhysicalDeviceShaderIntegerDotProductFeatures(const VkPhysicalDeviceShaderIntegerDotProductFeatures* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderIntegerDotProductFeatures(const safe_VkPhysicalDeviceShaderIntegerDotProductFeatures& copy_src); + safe_VkPhysicalDeviceShaderIntegerDotProductFeatures& operator=( + const safe_VkPhysicalDeviceShaderIntegerDotProductFeatures& copy_src); + safe_VkPhysicalDeviceShaderIntegerDotProductFeatures(); + ~safe_VkPhysicalDeviceShaderIntegerDotProductFeatures(); + void initialize(const VkPhysicalDeviceShaderIntegerDotProductFeatures* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderIntegerDotProductFeatures* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderIntegerDotProductFeatures* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderIntegerDotProductFeatures const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderIntegerDotProductProperties { + VkStructureType sType; + void* pNext{}; + VkBool32 integerDotProduct8BitUnsignedAccelerated; + VkBool32 integerDotProduct8BitSignedAccelerated; + VkBool32 integerDotProduct8BitMixedSignednessAccelerated; + VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedSignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProduct16BitUnsignedAccelerated; + VkBool32 integerDotProduct16BitSignedAccelerated; + VkBool32 integerDotProduct16BitMixedSignednessAccelerated; + VkBool32 integerDotProduct32BitUnsignedAccelerated; + VkBool32 integerDotProduct32BitSignedAccelerated; + VkBool32 integerDotProduct32BitMixedSignednessAccelerated; + VkBool32 integerDotProduct64BitUnsignedAccelerated; + VkBool32 integerDotProduct64BitSignedAccelerated; + VkBool32 integerDotProduct64BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; + + safe_VkPhysicalDeviceShaderIntegerDotProductProperties(const VkPhysicalDeviceShaderIntegerDotProductProperties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderIntegerDotProductProperties(const safe_VkPhysicalDeviceShaderIntegerDotProductProperties& copy_src); + safe_VkPhysicalDeviceShaderIntegerDotProductProperties& operator=( + const safe_VkPhysicalDeviceShaderIntegerDotProductProperties& copy_src); + safe_VkPhysicalDeviceShaderIntegerDotProductProperties(); + ~safe_VkPhysicalDeviceShaderIntegerDotProductProperties(); + void initialize(const VkPhysicalDeviceShaderIntegerDotProductProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderIntegerDotProductProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderIntegerDotProductProperties* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderIntegerDotProductProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceTexelBufferAlignmentProperties { + VkStructureType sType; + void* pNext{}; + VkDeviceSize storageTexelBufferOffsetAlignmentBytes; + VkBool32 storageTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; + VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; + + safe_VkPhysicalDeviceTexelBufferAlignmentProperties(const VkPhysicalDeviceTexelBufferAlignmentProperties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceTexelBufferAlignmentProperties(const safe_VkPhysicalDeviceTexelBufferAlignmentProperties& copy_src); + safe_VkPhysicalDeviceTexelBufferAlignmentProperties& operator=( + const safe_VkPhysicalDeviceTexelBufferAlignmentProperties& copy_src); + safe_VkPhysicalDeviceTexelBufferAlignmentProperties(); + ~safe_VkPhysicalDeviceTexelBufferAlignmentProperties(); + void initialize(const VkPhysicalDeviceTexelBufferAlignmentProperties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceTexelBufferAlignmentProperties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceTexelBufferAlignmentProperties* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceTexelBufferAlignmentProperties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkFormatProperties3 { + VkStructureType sType; + void* pNext{}; + VkFormatFeatureFlags2 linearTilingFeatures; + VkFormatFeatureFlags2 optimalTilingFeatures; + VkFormatFeatureFlags2 bufferFeatures; + + safe_VkFormatProperties3(const VkFormatProperties3* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkFormatProperties3(const safe_VkFormatProperties3& copy_src); + safe_VkFormatProperties3& operator=(const safe_VkFormatProperties3& copy_src); + safe_VkFormatProperties3(); + ~safe_VkFormatProperties3(); + void initialize(const VkFormatProperties3* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkFormatProperties3* copy_src, PNextCopyState* copy_state = {}); + VkFormatProperties3* ptr() { return reinterpret_cast(this); } + VkFormatProperties3 const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceMaintenance4Features { + VkStructureType sType; + void* pNext{}; + VkBool32 maintenance4; + + safe_VkPhysicalDeviceMaintenance4Features(const VkPhysicalDeviceMaintenance4Features* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMaintenance4Features(const safe_VkPhysicalDeviceMaintenance4Features& copy_src); + safe_VkPhysicalDeviceMaintenance4Features& operator=(const safe_VkPhysicalDeviceMaintenance4Features& copy_src); + safe_VkPhysicalDeviceMaintenance4Features(); + ~safe_VkPhysicalDeviceMaintenance4Features(); + void initialize(const VkPhysicalDeviceMaintenance4Features* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMaintenance4Features* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMaintenance4Features* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMaintenance4Features const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMaintenance4Properties { + VkStructureType sType; + void* pNext{}; + VkDeviceSize maxBufferSize; + + safe_VkPhysicalDeviceMaintenance4Properties(const VkPhysicalDeviceMaintenance4Properties* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMaintenance4Properties(const safe_VkPhysicalDeviceMaintenance4Properties& copy_src); + safe_VkPhysicalDeviceMaintenance4Properties& operator=(const safe_VkPhysicalDeviceMaintenance4Properties& copy_src); + safe_VkPhysicalDeviceMaintenance4Properties(); + ~safe_VkPhysicalDeviceMaintenance4Properties(); + void initialize(const VkPhysicalDeviceMaintenance4Properties* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMaintenance4Properties* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMaintenance4Properties* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMaintenance4Properties const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDeviceBufferMemoryRequirements { + VkStructureType sType; + const void* pNext{}; + safe_VkBufferCreateInfo* pCreateInfo{}; + + safe_VkDeviceBufferMemoryRequirements(const VkDeviceBufferMemoryRequirements* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDeviceBufferMemoryRequirements(const safe_VkDeviceBufferMemoryRequirements& copy_src); + safe_VkDeviceBufferMemoryRequirements& operator=(const safe_VkDeviceBufferMemoryRequirements& copy_src); + safe_VkDeviceBufferMemoryRequirements(); + ~safe_VkDeviceBufferMemoryRequirements(); + void initialize(const VkDeviceBufferMemoryRequirements* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceBufferMemoryRequirements* copy_src, PNextCopyState* copy_state = {}); + VkDeviceBufferMemoryRequirements* ptr() { return reinterpret_cast(this); } + VkDeviceBufferMemoryRequirements const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDeviceImageMemoryRequirements { + VkStructureType sType; + const void* pNext{}; + safe_VkImageCreateInfo* pCreateInfo{}; + VkImageAspectFlagBits planeAspect; + + safe_VkDeviceImageMemoryRequirements(const VkDeviceImageMemoryRequirements* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDeviceImageMemoryRequirements(const safe_VkDeviceImageMemoryRequirements& copy_src); + safe_VkDeviceImageMemoryRequirements& operator=(const safe_VkDeviceImageMemoryRequirements& copy_src); + safe_VkDeviceImageMemoryRequirements(); + ~safe_VkDeviceImageMemoryRequirements(); + void initialize(const VkDeviceImageMemoryRequirements* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceImageMemoryRequirements* copy_src, PNextCopyState* copy_state = {}); + VkDeviceImageMemoryRequirements* ptr() { return reinterpret_cast(this); } + VkDeviceImageMemoryRequirements const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkSwapchainCreateFlagsKHR flags; + VkSurfaceKHR surface; + uint32_t minImageCount; + VkFormat imageFormat; + VkColorSpaceKHR imageColorSpace; + VkExtent2D imageExtent; + uint32_t imageArrayLayers; + VkImageUsageFlags imageUsage; + VkSharingMode imageSharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices{}; + VkSurfaceTransformFlagBitsKHR preTransform; + VkCompositeAlphaFlagBitsKHR compositeAlpha; + VkPresentModeKHR presentMode; + VkBool32 clipped; + VkSwapchainKHR oldSwapchain; + + safe_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSwapchainCreateInfoKHR(const safe_VkSwapchainCreateInfoKHR& copy_src); + safe_VkSwapchainCreateInfoKHR& operator=(const safe_VkSwapchainCreateInfoKHR& copy_src); + safe_VkSwapchainCreateInfoKHR(); + ~safe_VkSwapchainCreateInfoKHR(); + void initialize(const VkSwapchainCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSwapchainCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkSwapchainCreateInfoKHR* ptr() { return reinterpret_cast(this); } + VkSwapchainCreateInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPresentInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t waitSemaphoreCount; + VkSemaphore* pWaitSemaphores{}; + uint32_t swapchainCount; + VkSwapchainKHR* pSwapchains{}; + const uint32_t* pImageIndices{}; + VkResult* pResults{}; + + safe_VkPresentInfoKHR(const VkPresentInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPresentInfoKHR(const safe_VkPresentInfoKHR& copy_src); + safe_VkPresentInfoKHR& operator=(const safe_VkPresentInfoKHR& copy_src); + safe_VkPresentInfoKHR(); + ~safe_VkPresentInfoKHR(); + void initialize(const VkPresentInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPresentInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPresentInfoKHR* ptr() { return reinterpret_cast(this); } + VkPresentInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImageSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkSwapchainKHR swapchain; + + safe_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImageSwapchainCreateInfoKHR(const safe_VkImageSwapchainCreateInfoKHR& copy_src); + safe_VkImageSwapchainCreateInfoKHR& operator=(const safe_VkImageSwapchainCreateInfoKHR& copy_src); + safe_VkImageSwapchainCreateInfoKHR(); + ~safe_VkImageSwapchainCreateInfoKHR(); + void initialize(const VkImageSwapchainCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageSwapchainCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkImageSwapchainCreateInfoKHR* ptr() { return reinterpret_cast(this); } + VkImageSwapchainCreateInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkBindImageMemorySwapchainInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkSwapchainKHR swapchain; + uint32_t imageIndex; + + safe_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkBindImageMemorySwapchainInfoKHR(const safe_VkBindImageMemorySwapchainInfoKHR& copy_src); + safe_VkBindImageMemorySwapchainInfoKHR& operator=(const safe_VkBindImageMemorySwapchainInfoKHR& copy_src); + safe_VkBindImageMemorySwapchainInfoKHR(); + ~safe_VkBindImageMemorySwapchainInfoKHR(); + void initialize(const VkBindImageMemorySwapchainInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBindImageMemorySwapchainInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkBindImageMemorySwapchainInfoKHR* ptr() { return reinterpret_cast(this); } + VkBindImageMemorySwapchainInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAcquireNextImageInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkSwapchainKHR swapchain; + uint64_t timeout; + VkSemaphore semaphore; + VkFence fence; + uint32_t deviceMask; + + safe_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkAcquireNextImageInfoKHR(const safe_VkAcquireNextImageInfoKHR& copy_src); + safe_VkAcquireNextImageInfoKHR& operator=(const safe_VkAcquireNextImageInfoKHR& copy_src); + safe_VkAcquireNextImageInfoKHR(); + ~safe_VkAcquireNextImageInfoKHR(); + void initialize(const VkAcquireNextImageInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAcquireNextImageInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkAcquireNextImageInfoKHR* ptr() { return reinterpret_cast(this); } + VkAcquireNextImageInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDeviceGroupPresentCapabilitiesKHR { + VkStructureType sType; + void* pNext{}; + uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; + VkDeviceGroupPresentModeFlagsKHR modes; + + safe_VkDeviceGroupPresentCapabilitiesKHR(const VkDeviceGroupPresentCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDeviceGroupPresentCapabilitiesKHR(const safe_VkDeviceGroupPresentCapabilitiesKHR& copy_src); + safe_VkDeviceGroupPresentCapabilitiesKHR& operator=(const safe_VkDeviceGroupPresentCapabilitiesKHR& copy_src); + safe_VkDeviceGroupPresentCapabilitiesKHR(); + ~safe_VkDeviceGroupPresentCapabilitiesKHR(); + void initialize(const VkDeviceGroupPresentCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceGroupPresentCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkDeviceGroupPresentCapabilitiesKHR* ptr() { return reinterpret_cast(this); } + VkDeviceGroupPresentCapabilitiesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDeviceGroupPresentInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t swapchainCount; + const uint32_t* pDeviceMasks{}; + VkDeviceGroupPresentModeFlagBitsKHR mode; + + safe_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDeviceGroupPresentInfoKHR(const safe_VkDeviceGroupPresentInfoKHR& copy_src); + safe_VkDeviceGroupPresentInfoKHR& operator=(const safe_VkDeviceGroupPresentInfoKHR& copy_src); + safe_VkDeviceGroupPresentInfoKHR(); + ~safe_VkDeviceGroupPresentInfoKHR(); + void initialize(const VkDeviceGroupPresentInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceGroupPresentInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkDeviceGroupPresentInfoKHR* ptr() { return reinterpret_cast(this); } + VkDeviceGroupPresentInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDeviceGroupSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkDeviceGroupPresentModeFlagsKHR modes; + + safe_VkDeviceGroupSwapchainCreateInfoKHR(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDeviceGroupSwapchainCreateInfoKHR(const safe_VkDeviceGroupSwapchainCreateInfoKHR& copy_src); + safe_VkDeviceGroupSwapchainCreateInfoKHR& operator=(const safe_VkDeviceGroupSwapchainCreateInfoKHR& copy_src); + safe_VkDeviceGroupSwapchainCreateInfoKHR(); + ~safe_VkDeviceGroupSwapchainCreateInfoKHR(); + void initialize(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceGroupSwapchainCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkDeviceGroupSwapchainCreateInfoKHR* ptr() { return reinterpret_cast(this); } + VkDeviceGroupSwapchainCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDisplayModeCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkDisplayModeCreateFlagsKHR flags; + VkDisplayModeParametersKHR parameters; + + safe_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDisplayModeCreateInfoKHR(const safe_VkDisplayModeCreateInfoKHR& copy_src); + safe_VkDisplayModeCreateInfoKHR& operator=(const safe_VkDisplayModeCreateInfoKHR& copy_src); + safe_VkDisplayModeCreateInfoKHR(); + ~safe_VkDisplayModeCreateInfoKHR(); + void initialize(const VkDisplayModeCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDisplayModeCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkDisplayModeCreateInfoKHR* ptr() { return reinterpret_cast(this); } + VkDisplayModeCreateInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDisplayPropertiesKHR { + VkDisplayKHR display; + const char* displayName{}; + VkExtent2D physicalDimensions; + VkExtent2D physicalResolution; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkBool32 planeReorderPossible; + VkBool32 persistentContent; + + safe_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + safe_VkDisplayPropertiesKHR(const safe_VkDisplayPropertiesKHR& copy_src); + safe_VkDisplayPropertiesKHR& operator=(const safe_VkDisplayPropertiesKHR& copy_src); + safe_VkDisplayPropertiesKHR(); + ~safe_VkDisplayPropertiesKHR(); + void initialize(const VkDisplayPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDisplayPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkDisplayPropertiesKHR* ptr() { return reinterpret_cast(this); } + VkDisplayPropertiesKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDisplaySurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkDisplaySurfaceCreateFlagsKHR flags; + VkDisplayModeKHR displayMode; + uint32_t planeIndex; + uint32_t planeStackIndex; + VkSurfaceTransformFlagBitsKHR transform; + float globalAlpha; + VkDisplayPlaneAlphaFlagBitsKHR alphaMode; + VkExtent2D imageExtent; + + safe_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDisplaySurfaceCreateInfoKHR(const safe_VkDisplaySurfaceCreateInfoKHR& copy_src); + safe_VkDisplaySurfaceCreateInfoKHR& operator=(const safe_VkDisplaySurfaceCreateInfoKHR& copy_src); + safe_VkDisplaySurfaceCreateInfoKHR(); + ~safe_VkDisplaySurfaceCreateInfoKHR(); + void initialize(const VkDisplaySurfaceCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDisplaySurfaceCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkDisplaySurfaceCreateInfoKHR* ptr() { return reinterpret_cast(this); } + VkDisplaySurfaceCreateInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDisplayPresentInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkRect2D srcRect; + VkRect2D dstRect; + VkBool32 persistent; + + safe_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDisplayPresentInfoKHR(const safe_VkDisplayPresentInfoKHR& copy_src); + safe_VkDisplayPresentInfoKHR& operator=(const safe_VkDisplayPresentInfoKHR& copy_src); + safe_VkDisplayPresentInfoKHR(); + ~safe_VkDisplayPresentInfoKHR(); + void initialize(const VkDisplayPresentInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDisplayPresentInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkDisplayPresentInfoKHR* ptr() { return reinterpret_cast(this); } + VkDisplayPresentInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkQueueFamilyQueryResultStatusPropertiesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 queryResultStatusSupport; + + safe_VkQueueFamilyQueryResultStatusPropertiesKHR(const VkQueueFamilyQueryResultStatusPropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkQueueFamilyQueryResultStatusPropertiesKHR(const safe_VkQueueFamilyQueryResultStatusPropertiesKHR& copy_src); + safe_VkQueueFamilyQueryResultStatusPropertiesKHR& operator=(const safe_VkQueueFamilyQueryResultStatusPropertiesKHR& copy_src); + safe_VkQueueFamilyQueryResultStatusPropertiesKHR(); + ~safe_VkQueueFamilyQueryResultStatusPropertiesKHR(); + void initialize(const VkQueueFamilyQueryResultStatusPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkQueueFamilyQueryResultStatusPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkQueueFamilyQueryResultStatusPropertiesKHR* ptr() { + return reinterpret_cast(this); + } + VkQueueFamilyQueryResultStatusPropertiesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkQueueFamilyVideoPropertiesKHR { + VkStructureType sType; + void* pNext{}; + VkVideoCodecOperationFlagsKHR videoCodecOperations; + + safe_VkQueueFamilyVideoPropertiesKHR(const VkQueueFamilyVideoPropertiesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkQueueFamilyVideoPropertiesKHR(const safe_VkQueueFamilyVideoPropertiesKHR& copy_src); + safe_VkQueueFamilyVideoPropertiesKHR& operator=(const safe_VkQueueFamilyVideoPropertiesKHR& copy_src); + safe_VkQueueFamilyVideoPropertiesKHR(); + ~safe_VkQueueFamilyVideoPropertiesKHR(); + void initialize(const VkQueueFamilyVideoPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkQueueFamilyVideoPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkQueueFamilyVideoPropertiesKHR* ptr() { return reinterpret_cast(this); } + VkQueueFamilyVideoPropertiesKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoProfileInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkVideoCodecOperationFlagBitsKHR videoCodecOperation; + VkVideoChromaSubsamplingFlagsKHR chromaSubsampling; + VkVideoComponentBitDepthFlagsKHR lumaBitDepth; + VkVideoComponentBitDepthFlagsKHR chromaBitDepth; + + safe_VkVideoProfileInfoKHR(const VkVideoProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoProfileInfoKHR(const safe_VkVideoProfileInfoKHR& copy_src); + safe_VkVideoProfileInfoKHR& operator=(const safe_VkVideoProfileInfoKHR& copy_src); + safe_VkVideoProfileInfoKHR(); + ~safe_VkVideoProfileInfoKHR(); + void initialize(const VkVideoProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoProfileInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoProfileInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoProfileInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoProfileListInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t profileCount; + safe_VkVideoProfileInfoKHR* pProfiles{}; + + safe_VkVideoProfileListInfoKHR(const VkVideoProfileListInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoProfileListInfoKHR(const safe_VkVideoProfileListInfoKHR& copy_src); + safe_VkVideoProfileListInfoKHR& operator=(const safe_VkVideoProfileListInfoKHR& copy_src); + safe_VkVideoProfileListInfoKHR(); + ~safe_VkVideoProfileListInfoKHR(); + void initialize(const VkVideoProfileListInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoProfileListInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoProfileListInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoProfileListInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoCapabilitiesKHR { + VkStructureType sType; + void* pNext{}; + VkVideoCapabilityFlagsKHR flags; + VkDeviceSize minBitstreamBufferOffsetAlignment; + VkDeviceSize minBitstreamBufferSizeAlignment; + VkExtent2D pictureAccessGranularity; + VkExtent2D minCodedExtent; + VkExtent2D maxCodedExtent; + uint32_t maxDpbSlots; + uint32_t maxActiveReferencePictures; + VkExtensionProperties stdHeaderVersion; + + safe_VkVideoCapabilitiesKHR(const VkVideoCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoCapabilitiesKHR(const safe_VkVideoCapabilitiesKHR& copy_src); + safe_VkVideoCapabilitiesKHR& operator=(const safe_VkVideoCapabilitiesKHR& copy_src); + safe_VkVideoCapabilitiesKHR(); + ~safe_VkVideoCapabilitiesKHR(); + void initialize(const VkVideoCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoCapabilitiesKHR* ptr() { return reinterpret_cast(this); } + VkVideoCapabilitiesKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceVideoFormatInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkImageUsageFlags imageUsage; + + safe_VkPhysicalDeviceVideoFormatInfoKHR(const VkPhysicalDeviceVideoFormatInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceVideoFormatInfoKHR(const safe_VkPhysicalDeviceVideoFormatInfoKHR& copy_src); + safe_VkPhysicalDeviceVideoFormatInfoKHR& operator=(const safe_VkPhysicalDeviceVideoFormatInfoKHR& copy_src); + safe_VkPhysicalDeviceVideoFormatInfoKHR(); + ~safe_VkPhysicalDeviceVideoFormatInfoKHR(); + void initialize(const VkPhysicalDeviceVideoFormatInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVideoFormatInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVideoFormatInfoKHR* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceVideoFormatInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkVideoFormatPropertiesKHR { + VkStructureType sType; + void* pNext{}; + VkFormat format; + VkComponentMapping componentMapping; + VkImageCreateFlags imageCreateFlags; + VkImageType imageType; + VkImageTiling imageTiling; + VkImageUsageFlags imageUsageFlags; + + safe_VkVideoFormatPropertiesKHR(const VkVideoFormatPropertiesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoFormatPropertiesKHR(const safe_VkVideoFormatPropertiesKHR& copy_src); + safe_VkVideoFormatPropertiesKHR& operator=(const safe_VkVideoFormatPropertiesKHR& copy_src); + safe_VkVideoFormatPropertiesKHR(); + ~safe_VkVideoFormatPropertiesKHR(); + void initialize(const VkVideoFormatPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoFormatPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoFormatPropertiesKHR* ptr() { return reinterpret_cast(this); } + VkVideoFormatPropertiesKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoPictureResourceInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkOffset2D codedOffset; + VkExtent2D codedExtent; + uint32_t baseArrayLayer; + VkImageView imageViewBinding; + + safe_VkVideoPictureResourceInfoKHR(const VkVideoPictureResourceInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoPictureResourceInfoKHR(const safe_VkVideoPictureResourceInfoKHR& copy_src); + safe_VkVideoPictureResourceInfoKHR& operator=(const safe_VkVideoPictureResourceInfoKHR& copy_src); + safe_VkVideoPictureResourceInfoKHR(); + ~safe_VkVideoPictureResourceInfoKHR(); + void initialize(const VkVideoPictureResourceInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoPictureResourceInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoPictureResourceInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoPictureResourceInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoReferenceSlotInfoKHR { + VkStructureType sType; + const void* pNext{}; + int32_t slotIndex; + safe_VkVideoPictureResourceInfoKHR* pPictureResource{}; + + safe_VkVideoReferenceSlotInfoKHR(const VkVideoReferenceSlotInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoReferenceSlotInfoKHR(const safe_VkVideoReferenceSlotInfoKHR& copy_src); + safe_VkVideoReferenceSlotInfoKHR& operator=(const safe_VkVideoReferenceSlotInfoKHR& copy_src); + safe_VkVideoReferenceSlotInfoKHR(); + ~safe_VkVideoReferenceSlotInfoKHR(); + void initialize(const VkVideoReferenceSlotInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoReferenceSlotInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoReferenceSlotInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoReferenceSlotInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoSessionMemoryRequirementsKHR { + VkStructureType sType; + void* pNext{}; + uint32_t memoryBindIndex; + VkMemoryRequirements memoryRequirements; + + safe_VkVideoSessionMemoryRequirementsKHR(const VkVideoSessionMemoryRequirementsKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoSessionMemoryRequirementsKHR(const safe_VkVideoSessionMemoryRequirementsKHR& copy_src); + safe_VkVideoSessionMemoryRequirementsKHR& operator=(const safe_VkVideoSessionMemoryRequirementsKHR& copy_src); + safe_VkVideoSessionMemoryRequirementsKHR(); + ~safe_VkVideoSessionMemoryRequirementsKHR(); + void initialize(const VkVideoSessionMemoryRequirementsKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoSessionMemoryRequirementsKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoSessionMemoryRequirementsKHR* ptr() { return reinterpret_cast(this); } + VkVideoSessionMemoryRequirementsKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkBindVideoSessionMemoryInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t memoryBindIndex; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkDeviceSize memorySize; + + safe_VkBindVideoSessionMemoryInfoKHR(const VkBindVideoSessionMemoryInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkBindVideoSessionMemoryInfoKHR(const safe_VkBindVideoSessionMemoryInfoKHR& copy_src); + safe_VkBindVideoSessionMemoryInfoKHR& operator=(const safe_VkBindVideoSessionMemoryInfoKHR& copy_src); + safe_VkBindVideoSessionMemoryInfoKHR(); + ~safe_VkBindVideoSessionMemoryInfoKHR(); + void initialize(const VkBindVideoSessionMemoryInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBindVideoSessionMemoryInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkBindVideoSessionMemoryInfoKHR* ptr() { return reinterpret_cast(this); } + VkBindVideoSessionMemoryInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoSessionCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t queueFamilyIndex; + VkVideoSessionCreateFlagsKHR flags; + safe_VkVideoProfileInfoKHR* pVideoProfile{}; + VkFormat pictureFormat; + VkExtent2D maxCodedExtent; + VkFormat referencePictureFormat; + uint32_t maxDpbSlots; + uint32_t maxActiveReferencePictures; + const VkExtensionProperties* pStdHeaderVersion{}; + + safe_VkVideoSessionCreateInfoKHR(const VkVideoSessionCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoSessionCreateInfoKHR(const safe_VkVideoSessionCreateInfoKHR& copy_src); + safe_VkVideoSessionCreateInfoKHR& operator=(const safe_VkVideoSessionCreateInfoKHR& copy_src); + safe_VkVideoSessionCreateInfoKHR(); + ~safe_VkVideoSessionCreateInfoKHR(); + void initialize(const VkVideoSessionCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoSessionCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoSessionCreateInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoSessionCreateInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoSessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkVideoSessionParametersCreateFlagsKHR flags; + VkVideoSessionParametersKHR videoSessionParametersTemplate; + VkVideoSessionKHR videoSession; + + safe_VkVideoSessionParametersCreateInfoKHR(const VkVideoSessionParametersCreateInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoSessionParametersCreateInfoKHR(const safe_VkVideoSessionParametersCreateInfoKHR& copy_src); + safe_VkVideoSessionParametersCreateInfoKHR& operator=(const safe_VkVideoSessionParametersCreateInfoKHR& copy_src); + safe_VkVideoSessionParametersCreateInfoKHR(); + ~safe_VkVideoSessionParametersCreateInfoKHR(); + void initialize(const VkVideoSessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoSessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoSessionParametersCreateInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoSessionParametersCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkVideoSessionParametersUpdateInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t updateSequenceCount; + + safe_VkVideoSessionParametersUpdateInfoKHR(const VkVideoSessionParametersUpdateInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoSessionParametersUpdateInfoKHR(const safe_VkVideoSessionParametersUpdateInfoKHR& copy_src); + safe_VkVideoSessionParametersUpdateInfoKHR& operator=(const safe_VkVideoSessionParametersUpdateInfoKHR& copy_src); + safe_VkVideoSessionParametersUpdateInfoKHR(); + ~safe_VkVideoSessionParametersUpdateInfoKHR(); + void initialize(const VkVideoSessionParametersUpdateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoSessionParametersUpdateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoSessionParametersUpdateInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoSessionParametersUpdateInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkVideoBeginCodingInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkVideoBeginCodingFlagsKHR flags; + VkVideoSessionKHR videoSession; + VkVideoSessionParametersKHR videoSessionParameters; + uint32_t referenceSlotCount; + safe_VkVideoReferenceSlotInfoKHR* pReferenceSlots{}; + + safe_VkVideoBeginCodingInfoKHR(const VkVideoBeginCodingInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoBeginCodingInfoKHR(const safe_VkVideoBeginCodingInfoKHR& copy_src); + safe_VkVideoBeginCodingInfoKHR& operator=(const safe_VkVideoBeginCodingInfoKHR& copy_src); + safe_VkVideoBeginCodingInfoKHR(); + ~safe_VkVideoBeginCodingInfoKHR(); + void initialize(const VkVideoBeginCodingInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoBeginCodingInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoBeginCodingInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoBeginCodingInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoEndCodingInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkVideoEndCodingFlagsKHR flags; + + safe_VkVideoEndCodingInfoKHR(const VkVideoEndCodingInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEndCodingInfoKHR(const safe_VkVideoEndCodingInfoKHR& copy_src); + safe_VkVideoEndCodingInfoKHR& operator=(const safe_VkVideoEndCodingInfoKHR& copy_src); + safe_VkVideoEndCodingInfoKHR(); + ~safe_VkVideoEndCodingInfoKHR(); + void initialize(const VkVideoEndCodingInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEndCodingInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoEndCodingInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoEndCodingInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoCodingControlInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkVideoCodingControlFlagsKHR flags; + + safe_VkVideoCodingControlInfoKHR(const VkVideoCodingControlInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoCodingControlInfoKHR(const safe_VkVideoCodingControlInfoKHR& copy_src); + safe_VkVideoCodingControlInfoKHR& operator=(const safe_VkVideoCodingControlInfoKHR& copy_src); + safe_VkVideoCodingControlInfoKHR(); + ~safe_VkVideoCodingControlInfoKHR(); + void initialize(const VkVideoCodingControlInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoCodingControlInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoCodingControlInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoCodingControlInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoDecodeCapabilitiesKHR { + VkStructureType sType; + void* pNext{}; + VkVideoDecodeCapabilityFlagsKHR flags; + + safe_VkVideoDecodeCapabilitiesKHR(const VkVideoDecodeCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoDecodeCapabilitiesKHR(const safe_VkVideoDecodeCapabilitiesKHR& copy_src); + safe_VkVideoDecodeCapabilitiesKHR& operator=(const safe_VkVideoDecodeCapabilitiesKHR& copy_src); + safe_VkVideoDecodeCapabilitiesKHR(); + ~safe_VkVideoDecodeCapabilitiesKHR(); + void initialize(const VkVideoDecodeCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeCapabilitiesKHR* ptr() { return reinterpret_cast(this); } + VkVideoDecodeCapabilitiesKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoDecodeUsageInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkVideoDecodeUsageFlagsKHR videoUsageHints; + + safe_VkVideoDecodeUsageInfoKHR(const VkVideoDecodeUsageInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoDecodeUsageInfoKHR(const safe_VkVideoDecodeUsageInfoKHR& copy_src); + safe_VkVideoDecodeUsageInfoKHR& operator=(const safe_VkVideoDecodeUsageInfoKHR& copy_src); + safe_VkVideoDecodeUsageInfoKHR(); + ~safe_VkVideoDecodeUsageInfoKHR(); + void initialize(const VkVideoDecodeUsageInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeUsageInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeUsageInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoDecodeUsageInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoDecodeInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkVideoDecodeFlagsKHR flags; + VkBuffer srcBuffer; + VkDeviceSize srcBufferOffset; + VkDeviceSize srcBufferRange; + safe_VkVideoPictureResourceInfoKHR dstPictureResource; + safe_VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot{}; + uint32_t referenceSlotCount; + safe_VkVideoReferenceSlotInfoKHR* pReferenceSlots{}; + + safe_VkVideoDecodeInfoKHR(const VkVideoDecodeInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoDecodeInfoKHR(const safe_VkVideoDecodeInfoKHR& copy_src); + safe_VkVideoDecodeInfoKHR& operator=(const safe_VkVideoDecodeInfoKHR& copy_src); + safe_VkVideoDecodeInfoKHR(); + ~safe_VkVideoDecodeInfoKHR(); + void initialize(const VkVideoDecodeInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoDecodeInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoEncodeH264CapabilitiesKHR { + VkStructureType sType; + 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_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_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; + + 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_VkVideoEncodeH264SessionParametersAddInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t stdSPSCount; + const StdVideoH264SequenceParameterSet* pStdSPSs{}; + uint32_t stdPPSCount; + const StdVideoH264PictureParameterSet* pStdPPSs{}; + + safe_VkVideoEncodeH264SessionParametersAddInfoKHR(const VkVideoEncodeH264SessionParametersAddInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + 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); + } + VkVideoEncodeH264SessionParametersAddInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkVideoEncodeH264SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + safe_VkVideoEncodeH264SessionParametersAddInfoKHR* pParametersAddInfo{}; + + safe_VkVideoEncodeH264SessionParametersCreateInfoKHR(const VkVideoEncodeH264SessionParametersCreateInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + 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); + } + VkVideoEncodeH264SessionParametersCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkVideoEncodeH264SessionParametersGetInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkBool32 writeStdSPS; + VkBool32 writeStdPPS; + uint32_t stdSPSId; + uint32_t stdPPSId; + + 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_VkVideoEncodeH264SessionParametersFeedbackInfoKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 hasStdSPSOverrides; + VkBool32 hasStdPPSOverrides; + + 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_VkVideoEncodeH264NaluSliceInfoKHR { + VkStructureType sType; + const void* pNext{}; + int32_t constantQp; + const StdVideoEncodeH264SliceHeader* pStdSliceHeader{}; + + 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_VkVideoEncodeH264PictureInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t naluSliceEntryCount; + safe_VkVideoEncodeH264NaluSliceInfoKHR* pNaluSliceEntries{}; + const StdVideoEncodeH264PictureInfo* pStdPictureInfo{}; + VkBool32 generatePrefixNalu; + + 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_VkVideoEncodeH264DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext{}; + const StdVideoEncodeH264ReferenceInfo* pStdReferenceInfo{}; + + 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_VkVideoEncodeH264ProfileInfoKHR { + VkStructureType sType; + const void* pNext{}; + StdVideoH264ProfileIdc stdProfileIdc; + + 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_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); + } +}; +struct safe_VkVideoEncodeH264RateControlLayerInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkBool32 useMinQp; + VkVideoEncodeH264QpKHR minQp; + VkBool32 useMaxQp; + VkVideoEncodeH264QpKHR maxQp; + VkBool32 useMaxFrameSize; + VkVideoEncodeH264FrameSizeKHR maxFrameSize; + + 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_VkVideoEncodeH264GopRemainingFrameInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkBool32 useGopRemainingFrames; + uint32_t gopRemainingI; + uint32_t gopRemainingP; + uint32_t gopRemainingB; + + 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_VkVideoEncodeH265CapabilitiesKHR { + VkStructureType sType; + void* pNext{}; + 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_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); } +}; +struct safe_VkVideoEncodeH265SessionCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkBool32 useMaxLevelIdc; + StdVideoH265LevelIdc maxLevelIdc; + + 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_VkVideoEncodeH265QualityLevelPropertiesKHR { + VkStructureType sType; + void* pNext{}; + VkVideoEncodeH265RateControlFlagsKHR preferredRateControlFlags; + uint32_t preferredGopFrameCount; + uint32_t preferredIdrPeriod; + uint32_t preferredConsecutiveBFrameCount; + uint32_t preferredSubLayerCount; + VkVideoEncodeH265QpKHR preferredConstantQp; + uint32_t preferredMaxL0ReferenceCount; + uint32_t preferredMaxL1ReferenceCount; + + 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_VkVideoEncodeH265SessionParametersAddInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t stdVPSCount; + const StdVideoH265VideoParameterSet* pStdVPSs{}; + uint32_t stdSPSCount; + const StdVideoH265SequenceParameterSet* pStdSPSs{}; + uint32_t stdPPSCount; + const StdVideoH265PictureParameterSet* pStdPPSs{}; + + 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); + } +}; +struct safe_VkVideoEncodeH265SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t maxStdVPSCount; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + safe_VkVideoEncodeH265SessionParametersAddInfoKHR* pParametersAddInfo{}; + + 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_VkVideoEncodeH265SessionParametersGetInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkBool32 writeStdVPS; + VkBool32 writeStdSPS; + VkBool32 writeStdPPS; + uint32_t stdVPSId; + uint32_t stdSPSId; + uint32_t stdPPSId; + + 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_VkVideoEncodeH265SessionParametersFeedbackInfoKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 hasStdVPSOverrides; + VkBool32 hasStdSPSOverrides; + VkBool32 hasStdPPSOverrides; + + 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_VkVideoEncodeH265NaluSliceSegmentInfoKHR { + VkStructureType sType; + const void* pNext{}; + int32_t constantQp; + const StdVideoEncodeH265SliceSegmentHeader* pStdSliceSegmentHeader{}; + + 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_VkVideoEncodeH265PictureInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t naluSliceSegmentEntryCount; + safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR* pNaluSliceSegmentEntries{}; + const StdVideoEncodeH265PictureInfo* pStdPictureInfo{}; + + 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); } +}; +struct safe_VkVideoEncodeH265DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext{}; + const StdVideoEncodeH265ReferenceInfo* pStdReferenceInfo{}; + + 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_VkVideoEncodeH265ProfileInfoKHR { + VkStructureType sType; + const void* pNext{}; + StdVideoH265ProfileIdc stdProfileIdc; + + 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_VkVideoEncodeH265RateControlInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkVideoEncodeH265RateControlFlagsKHR flags; + uint32_t gopFrameCount; + uint32_t idrPeriod; + uint32_t consecutiveBFrameCount; + uint32_t subLayerCount; + + 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); + } +}; +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_VkVideoEncodeH265GopRemainingFrameInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkBool32 useGopRemainingFrames; + uint32_t gopRemainingI; + uint32_t gopRemainingP; + uint32_t gopRemainingB; + + 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_VkVideoDecodeH264ProfileInfoKHR { + VkStructureType sType; + const void* pNext{}; + StdVideoH264ProfileIdc stdProfileIdc; + VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout; + + 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_VkVideoDecodeH264CapabilitiesKHR { + VkStructureType sType; + void* pNext{}; + 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); } +}; +struct safe_VkVideoDecodeH264SessionParametersAddInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t stdSPSCount; + const StdVideoH264SequenceParameterSet* pStdSPSs{}; + uint32_t stdPPSCount; + const StdVideoH264PictureParameterSet* pStdPPSs{}; + + 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_VkVideoDecodeH264SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + safe_VkVideoDecodeH264SessionParametersAddInfoKHR* pParametersAddInfo{}; + + 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_VkVideoDecodeH264PictureInfoKHR { + VkStructureType sType; + const void* pNext{}; + const StdVideoDecodeH264PictureInfo* pStdPictureInfo{}; + uint32_t sliceCount; + const uint32_t* pSliceOffsets{}; + + 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); } +}; +struct safe_VkVideoDecodeH264DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext{}; + const StdVideoDecodeH264ReferenceInfo* pStdReferenceInfo{}; + + 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_VkRenderingFragmentShadingRateAttachmentInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkImageView imageView; + VkImageLayout imageLayout; + VkExtent2D shadingRateAttachmentTexelSize; + + 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); + } +}; +struct safe_VkRenderingFragmentDensityMapAttachmentInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkImageView imageView; + VkImageLayout imageLayout; + + 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); + } +}; +struct safe_VkAttachmentSampleCountInfoAMD { + VkStructureType sType; + const void* pNext{}; + uint32_t colorAttachmentCount; + const VkSampleCountFlagBits* pColorAttachmentSamples{}; + VkSampleCountFlagBits depthStencilAttachmentSamples; + + 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_VkMultiviewPerViewAttributesInfoNVX { + VkStructureType sType; + const void* pNext{}; + VkBool32 perViewAttributes; + VkBool32 perViewAttributesPositionXOnly; + + safe_VkMultiviewPerViewAttributesInfoNVX(const VkMultiviewPerViewAttributesInfoNVX* 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); + } +}; +#ifdef VK_USE_PLATFORM_WIN32_KHR +struct safe_VkImportMemoryWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkExternalMemoryHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; + + 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_VkExportMemoryWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext{}; + const SECURITY_ATTRIBUTES* pAttributes{}; + DWORD dwAccess; + LPCWSTR name; + + 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_VkMemoryWin32HandlePropertiesKHR { + 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; + + 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); } +}; +#endif // VK_USE_PLATFORM_WIN32_KHR +struct safe_VkImportMemoryFdInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkExternalMemoryHandleTypeFlagBits handleType; + int fd; + + 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_VkMemoryFdPropertiesKHR { + VkStructureType sType; + void* pNext{}; + uint32_t memoryTypeBits; + + 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_VkMemoryGetFdInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; + + 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); } +}; +#ifdef VK_USE_PLATFORM_WIN32_KHR +struct safe_VkWin32KeyedMutexAcquireReleaseInfoKHR { + 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{}; + + 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_VkImportSemaphoreWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkSemaphore semaphore; + VkSemaphoreImportFlags flags; + VkExternalSemaphoreHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; + + 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_VkExportSemaphoreWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext{}; + const SECURITY_ATTRIBUTES* pAttributes{}; + DWORD dwAccess; + LPCWSTR name; + + 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); + } +}; +struct safe_VkD3D12FenceSubmitInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t waitSemaphoreValuesCount; + const uint64_t* pWaitSemaphoreValues{}; + uint32_t signalSemaphoreValuesCount; + const uint64_t* pSignalSemaphoreValues{}; + + 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_VkSemaphoreGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBits handleType; + + 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_USE_PLATFORM_WIN32_KHR +struct safe_VkImportSemaphoreFdInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkSemaphore semaphore; + VkSemaphoreImportFlags flags; + VkExternalSemaphoreHandleTypeFlagBits handleType; + int fd; + + 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_VkSemaphoreGetFdInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBits handleType; + + 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_VkPhysicalDevicePushDescriptorPropertiesKHR { + VkStructureType sType; + void* pNext{}; + uint32_t maxPushDescriptors; + + safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src); + safe_VkPhysicalDevicePushDescriptorPropertiesKHR& operator=(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src); + safe_VkPhysicalDevicePushDescriptorPropertiesKHR(); + ~safe_VkPhysicalDevicePushDescriptorPropertiesKHR(); + void initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePushDescriptorPropertiesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDevicePushDescriptorPropertiesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPresentRegionKHR { + uint32_t rectangleCount; + const VkRectLayerKHR* pRectangles{}; + + 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 swapchainCount; + safe_VkPresentRegionKHR* pRegions{}; + + 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_VkSharedPresentSurfaceCapabilitiesKHR { + VkStructureType sType; + void* pNext{}; + VkImageUsageFlags sharedPresentSupportedUsageFlags; + + 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); + } +}; +#ifdef VK_USE_PLATFORM_WIN32_KHR +struct safe_VkImportFenceWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkFence fence; + VkFenceImportFlags flags; + VkExternalFenceHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; + + 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); } +}; +struct safe_VkExportFenceWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext{}; + const SECURITY_ATTRIBUTES* pAttributes{}; + DWORD dwAccess; + LPCWSTR name; + + 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); } +}; +struct safe_VkFenceGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkFence fence; + VkExternalFenceHandleTypeFlagBits handleType; + + 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); } +}; +#endif // VK_USE_PLATFORM_WIN32_KHR +struct safe_VkImportFenceFdInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkFence fence; + VkFenceImportFlags flags; + VkExternalFenceHandleTypeFlagBits handleType; + int fd; + + 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_VkFenceGetFdInfoKHR { + 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; + + 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); + } + VkPhysicalDevicePerformanceQueryFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDevicePerformanceQueryPropertiesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 allowCommandBufferQueryCopies; + + 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); + } + VkPhysicalDevicePerformanceQueryPropertiesKHR 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 { + VkStructureType sType; + void* pNext{}; + VkPerformanceCounterDescriptionFlagsKHR flags; + char name[VK_MAX_DESCRIPTION_SIZE]; + char category[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + + 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_VkQueryPoolPerformanceCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t queueFamilyIndex; + uint32_t counterIndexCount; + const uint32_t* pCounterIndices{}; + + 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_VkAcquireProfilingLockInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkAcquireProfilingLockFlagsKHR flags; + uint64_t timeout; + + 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_VkPerformanceQuerySubmitInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t counterPassIndex; + + 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_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{}; + VkSurfaceCapabilitiesKHR surfaceCapabilities; + + 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_VkSurfaceFormat2KHR { + VkStructureType sType; + void* pNext{}; + VkSurfaceFormatKHR surfaceFormat; + + 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_VkDisplayProperties2KHR { + VkStructureType sType; + void* pNext{}; + safe_VkDisplayPropertiesKHR displayProperties; + + 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_VkDisplayPlaneProperties2KHR { + VkStructureType sType; + void* pNext{}; + VkDisplayPlanePropertiesKHR displayPlaneProperties; + + 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_VkDisplayModeProperties2KHR { + VkStructureType sType; + void* pNext{}; + VkDisplayModePropertiesKHR displayModeProperties; + + 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_VkDisplayPlaneInfo2KHR { + VkStructureType sType; + const void* pNext{}; + VkDisplayModeKHR mode; + uint32_t planeIndex; + + 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_VkDisplayPlaneCapabilities2KHR { + VkStructureType sType; + void* pNext{}; + VkDisplayPlaneCapabilitiesKHR capabilities; + + 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); } +}; +#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_VkPhysicalDevicePortabilitySubsetPropertiesKHR { + VkStructureType sType; + void* pNext{}; + uint32_t minVertexInputBindingStrideAlignment; + + 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); + } +}; +#endif // VK_ENABLE_BETA_EXTENSIONS +struct safe_VkPhysicalDeviceShaderClockFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderSubgroupClock; + VkBool32 shaderDeviceClock; + + 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); + } +}; +struct safe_VkVideoDecodeH265ProfileInfoKHR { + VkStructureType sType; + const void* pNext{}; + StdVideoH265ProfileIdc stdProfileIdc; + + 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_VkVideoDecodeH265CapabilitiesKHR { + VkStructureType sType; + void* pNext{}; + StdVideoH265LevelIdc maxLevelIdc; + + 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_VkVideoDecodeH265SessionParametersAddInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t stdVPSCount; + const StdVideoH265VideoParameterSet* pStdVPSs{}; + uint32_t stdSPSCount; + const StdVideoH265SequenceParameterSet* pStdSPSs{}; + uint32_t stdPPSCount; + const StdVideoH265PictureParameterSet* pStdPPSs{}; + + 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); + } +}; +struct safe_VkVideoDecodeH265SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t maxStdVPSCount; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + safe_VkVideoDecodeH265SessionParametersAddInfoKHR* pParametersAddInfo{}; + + 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_VkVideoDecodeH265PictureInfoKHR { + VkStructureType sType; + const void* pNext{}; + const StdVideoDecodeH265PictureInfo* pStdPictureInfo{}; + uint32_t sliceSegmentCount; + const uint32_t* pSliceSegmentOffsets{}; + + 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_VkVideoDecodeH265DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext{}; + const StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo{}; + + safe_VkVideoDecodeH265DpbSlotInfoKHR(const VkVideoDecodeH265DpbSlotInfoKHR* 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); } +}; +struct safe_VkDeviceQueueGlobalPriorityCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkQueueGlobalPriorityKHR globalPriority; + + safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& copy_src); + safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& operator=(const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& copy_src); + safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(); + ~safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(); + void initialize(const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkDeviceQueueGlobalPriorityCreateInfoKHR* ptr() { return reinterpret_cast(this); } + VkDeviceQueueGlobalPriorityCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 globalPriorityQuery; + + safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src); + safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& operator=( + const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src); + safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(); + ~safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(); + void initialize(const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkQueueFamilyGlobalPriorityPropertiesKHR { + VkStructureType sType; + void* pNext{}; + uint32_t priorityCount; + VkQueueGlobalPriorityKHR priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_KHR]; + + safe_VkQueueFamilyGlobalPriorityPropertiesKHR(const VkQueueFamilyGlobalPriorityPropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkQueueFamilyGlobalPriorityPropertiesKHR(const safe_VkQueueFamilyGlobalPriorityPropertiesKHR& copy_src); + safe_VkQueueFamilyGlobalPriorityPropertiesKHR& operator=(const safe_VkQueueFamilyGlobalPriorityPropertiesKHR& copy_src); + safe_VkQueueFamilyGlobalPriorityPropertiesKHR(); + ~safe_VkQueueFamilyGlobalPriorityPropertiesKHR(); + void initialize(const VkQueueFamilyGlobalPriorityPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkQueueFamilyGlobalPriorityPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkQueueFamilyGlobalPriorityPropertiesKHR* ptr() { return reinterpret_cast(this); } + VkQueueFamilyGlobalPriorityPropertiesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkFragmentShadingRateAttachmentInfoKHR { + VkStructureType sType; + const void* pNext{}; + safe_VkAttachmentReference2* pFragmentShadingRateAttachment{}; + VkExtent2D shadingRateAttachmentTexelSize; + + 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_VkPipelineFragmentShadingRateStateCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkExtent2D fragmentSize; + VkFragmentShadingRateCombinerOpKHR combinerOps[2]; + + 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_VkPhysicalDeviceFragmentShadingRateFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 pipelineFragmentShadingRate; + VkBool32 primitiveFragmentShadingRate; + VkBool32 attachmentFragmentShadingRate; + + 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); + } + VkPhysicalDeviceFragmentShadingRateFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR { + 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; + + 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_VkPhysicalDeviceFragmentShadingRateKHR { + VkStructureType sType; + void* pNext{}; + VkSampleCountFlags sampleCounts; + VkExtent2D fragmentSize; + + 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_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 dynamicRenderingLocalRead; + + safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR( + const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src); + safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& operator=( + const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src); + safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(); + ~safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(); + void initialize(const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRenderingAttachmentLocationInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t colorAttachmentCount; + const uint32_t* pColorAttachmentLocations{}; + + safe_VkRenderingAttachmentLocationInfoKHR(const VkRenderingAttachmentLocationInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkRenderingAttachmentLocationInfoKHR(const safe_VkRenderingAttachmentLocationInfoKHR& copy_src); + safe_VkRenderingAttachmentLocationInfoKHR& operator=(const safe_VkRenderingAttachmentLocationInfoKHR& copy_src); + safe_VkRenderingAttachmentLocationInfoKHR(); + ~safe_VkRenderingAttachmentLocationInfoKHR(); + void initialize(const VkRenderingAttachmentLocationInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderingAttachmentLocationInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkRenderingAttachmentLocationInfoKHR* ptr() { return reinterpret_cast(this); } + VkRenderingAttachmentLocationInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRenderingInputAttachmentIndexInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t colorAttachmentCount; + const uint32_t* pColorAttachmentInputIndices{}; + const uint32_t* pDepthInputAttachmentIndex{}; + const uint32_t* pStencilInputAttachmentIndex{}; + + safe_VkRenderingInputAttachmentIndexInfoKHR(const VkRenderingInputAttachmentIndexInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkRenderingInputAttachmentIndexInfoKHR(const safe_VkRenderingInputAttachmentIndexInfoKHR& copy_src); + safe_VkRenderingInputAttachmentIndexInfoKHR& operator=(const safe_VkRenderingInputAttachmentIndexInfoKHR& copy_src); + safe_VkRenderingInputAttachmentIndexInfoKHR(); + ~safe_VkRenderingInputAttachmentIndexInfoKHR(); + void initialize(const VkRenderingInputAttachmentIndexInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderingInputAttachmentIndexInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkRenderingInputAttachmentIndexInfoKHR* ptr() { return reinterpret_cast(this); } + VkRenderingInputAttachmentIndexInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderQuadControl; + + safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR(const VkPhysicalDeviceShaderQuadControlFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR(const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& copy_src); + safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& operator=(const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& copy_src); + safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR(); + ~safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR(); + void initialize(const VkPhysicalDeviceShaderQuadControlFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderQuadControlFeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderQuadControlFeaturesKHR 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_VkPhysicalDevicePresentWaitFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 presentWait; + + 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_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 pipelineExecutableInfo; + + 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); + } +}; +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{}; + VkShaderStageFlags stages; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + uint32_t subgroupSize; + + 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_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{}; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + VkPipelineExecutableStatisticFormatKHR format; + VkPipelineExecutableStatisticValueKHR value; + + 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_VkPipelineExecutableInternalRepresentationKHR { + VkStructureType sType; + void* pNext{}; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + VkBool32 isText; + size_t dataSize; + void* pData{}; + + 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); + } +}; +struct safe_VkMemoryMapInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkMemoryMapFlags flags; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; + + safe_VkMemoryMapInfoKHR(const VkMemoryMapInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMemoryMapInfoKHR(const safe_VkMemoryMapInfoKHR& copy_src); + safe_VkMemoryMapInfoKHR& operator=(const safe_VkMemoryMapInfoKHR& copy_src); + safe_VkMemoryMapInfoKHR(); + ~safe_VkMemoryMapInfoKHR(); + void initialize(const VkMemoryMapInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryMapInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkMemoryMapInfoKHR* ptr() { return reinterpret_cast(this); } + VkMemoryMapInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkMemoryUnmapInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkMemoryUnmapFlagsKHR flags; + VkDeviceMemory memory; + + safe_VkMemoryUnmapInfoKHR(const VkMemoryUnmapInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMemoryUnmapInfoKHR(const safe_VkMemoryUnmapInfoKHR& copy_src); + safe_VkMemoryUnmapInfoKHR& operator=(const safe_VkMemoryUnmapInfoKHR& copy_src); + safe_VkMemoryUnmapInfoKHR(); + ~safe_VkMemoryUnmapInfoKHR(); + void initialize(const VkMemoryUnmapInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryUnmapInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkMemoryUnmapInfoKHR* ptr() { return reinterpret_cast(this); } + VkMemoryUnmapInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPipelineLibraryCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t libraryCount; + VkPipeline* pLibraries{}; + + 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_VkPresentIdKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t swapchainCount; + const uint64_t* pPresentIds{}; + + 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_VkPhysicalDevicePresentIdFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 presentId; + + 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_VkVideoEncodeInfoKHR { + 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; + + 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_VkVideoEncodeCapabilitiesKHR { + VkStructureType sType; + void* pNext{}; + VkVideoEncodeCapabilityFlagsKHR flags; + VkVideoEncodeRateControlModeFlagsKHR rateControlModes; + uint32_t maxRateControlLayers; + uint64_t maxBitrate; + uint32_t maxQualityLevels; + VkExtent2D encodeInputPictureGranularity; + VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags; + + 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_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags; + + 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_VkVideoEncodeUsageInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkVideoEncodeUsageFlagsKHR videoUsageHints; + VkVideoEncodeContentFlagsKHR videoContentHints; + VkVideoEncodeTuningModeKHR tuningMode; + + 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_VkVideoEncodeRateControlLayerInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint64_t averageBitrate; + uint64_t maxBitrate; + uint32_t frameRateNumerator; + uint32_t frameRateDenominator; + + 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_VkVideoEncodeRateControlInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkVideoEncodeRateControlFlagsKHR flags; + VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode; + uint32_t layerCount; + safe_VkVideoEncodeRateControlLayerInfoKHR* pLayers{}; + uint32_t virtualBufferSizeInMs; + uint32_t initialVirtualBufferSizeInMs; + + 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_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR { + VkStructureType sType; + const void* pNext{}; + safe_VkVideoProfileInfoKHR* pVideoProfile{}; + uint32_t qualityLevel; + + safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* 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); + } + VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkVideoEncodeQualityLevelPropertiesKHR { + VkStructureType sType; + void* pNext{}; + VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode; + uint32_t preferredRateControlLayerCount; + + 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_VkVideoEncodeQualityLevelInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t qualityLevel; + + 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_VkVideoEncodeSessionParametersFeedbackInfoKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 hasOverrides; + + 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); + } + VkVideoEncodeSessionParametersFeedbackInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkQueueFamilyCheckpointProperties2NV { + VkStructureType sType; + void* pNext{}; + VkPipelineStageFlags2 checkpointExecutionStageMask; + + 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_VkCheckpointData2NV { + VkStructureType sType; + void* pNext{}; + VkPipelineStageFlags2 stage; + void* pCheckpointMarker{}; + + 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_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 fragmentShaderBarycentric; + + 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); + } +}; +struct safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 triStripVertexOrderIndependentOfProvokingVertex; + + 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_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderSubgroupUniformControlFlow; + + 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_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 workgroupMemoryExplicitLayout; + VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout; + VkBool32 workgroupMemoryExplicitLayout8BitAccess; + VkBool32 workgroupMemoryExplicitLayout16BitAccess; + + 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_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 rayTracingMaintenance1; + VkBool32 rayTracingPipelineTraceRaysIndirect2; + + 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_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderSubgroupRotate; + VkBool32 shaderSubgroupRotateClustered; + + safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src); + safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& operator=( + const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src); + safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(); + ~safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(); + void initialize(const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderMaximalReconvergence; + + safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( + const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( + const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& copy_src); + safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& operator=( + const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& copy_src); + safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(); + ~safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(); + void initialize(const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMaintenance5FeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 maintenance5; + + safe_VkPhysicalDeviceMaintenance5FeaturesKHR(const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMaintenance5FeaturesKHR(const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src); + safe_VkPhysicalDeviceMaintenance5FeaturesKHR& operator=(const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src); + safe_VkPhysicalDeviceMaintenance5FeaturesKHR(); + ~safe_VkPhysicalDeviceMaintenance5FeaturesKHR(); + void initialize(const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMaintenance5FeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMaintenance5FeaturesKHR* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMaintenance5FeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMaintenance5PropertiesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting; + VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting; + VkBool32 depthStencilSwizzleOneSupport; + VkBool32 polygonModePointSize; + VkBool32 nonStrictSinglePixelWideLinesUseParallelogram; + VkBool32 nonStrictWideLinesUseParallelogram; + + safe_VkPhysicalDeviceMaintenance5PropertiesKHR(const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMaintenance5PropertiesKHR(const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src); + safe_VkPhysicalDeviceMaintenance5PropertiesKHR& operator=(const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src); + safe_VkPhysicalDeviceMaintenance5PropertiesKHR(); + ~safe_VkPhysicalDeviceMaintenance5PropertiesKHR(); + void initialize(const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMaintenance5PropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMaintenance5PropertiesKHR* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMaintenance5PropertiesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRenderingAreaInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t viewMask; + uint32_t colorAttachmentCount; + const VkFormat* pColorAttachmentFormats{}; + VkFormat depthAttachmentFormat; + VkFormat stencilAttachmentFormat; + + safe_VkRenderingAreaInfoKHR(const VkRenderingAreaInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkRenderingAreaInfoKHR(const safe_VkRenderingAreaInfoKHR& copy_src); + safe_VkRenderingAreaInfoKHR& operator=(const safe_VkRenderingAreaInfoKHR& copy_src); + safe_VkRenderingAreaInfoKHR(); + ~safe_VkRenderingAreaInfoKHR(); + void initialize(const VkRenderingAreaInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderingAreaInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkRenderingAreaInfoKHR* ptr() { return reinterpret_cast(this); } + VkRenderingAreaInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImageSubresource2KHR { + VkStructureType sType; + void* pNext{}; + VkImageSubresource imageSubresource; + + safe_VkImageSubresource2KHR(const VkImageSubresource2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImageSubresource2KHR(const safe_VkImageSubresource2KHR& copy_src); + safe_VkImageSubresource2KHR& operator=(const safe_VkImageSubresource2KHR& copy_src); + safe_VkImageSubresource2KHR(); + ~safe_VkImageSubresource2KHR(); + void initialize(const VkImageSubresource2KHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageSubresource2KHR* copy_src, PNextCopyState* copy_state = {}); + VkImageSubresource2KHR* ptr() { return reinterpret_cast(this); } + VkImageSubresource2KHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDeviceImageSubresourceInfoKHR { + VkStructureType sType; + const void* pNext{}; + safe_VkImageCreateInfo* pCreateInfo{}; + safe_VkImageSubresource2KHR* pSubresource{}; + + safe_VkDeviceImageSubresourceInfoKHR(const VkDeviceImageSubresourceInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDeviceImageSubresourceInfoKHR(const safe_VkDeviceImageSubresourceInfoKHR& copy_src); + safe_VkDeviceImageSubresourceInfoKHR& operator=(const safe_VkDeviceImageSubresourceInfoKHR& copy_src); + safe_VkDeviceImageSubresourceInfoKHR(); + ~safe_VkDeviceImageSubresourceInfoKHR(); + void initialize(const VkDeviceImageSubresourceInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceImageSubresourceInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkDeviceImageSubresourceInfoKHR* ptr() { return reinterpret_cast(this); } + VkDeviceImageSubresourceInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSubresourceLayout2KHR { + VkStructureType sType; + void* pNext{}; + VkSubresourceLayout subresourceLayout; + + safe_VkSubresourceLayout2KHR(const VkSubresourceLayout2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSubresourceLayout2KHR(const safe_VkSubresourceLayout2KHR& copy_src); + safe_VkSubresourceLayout2KHR& operator=(const safe_VkSubresourceLayout2KHR& copy_src); + safe_VkSubresourceLayout2KHR(); + ~safe_VkSubresourceLayout2KHR(); + void initialize(const VkSubresourceLayout2KHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSubresourceLayout2KHR* copy_src, PNextCopyState* copy_state = {}); + VkSubresourceLayout2KHR* ptr() { return reinterpret_cast(this); } + VkSubresourceLayout2KHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPipelineCreateFlags2CreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkPipelineCreateFlags2KHR flags; + + safe_VkPipelineCreateFlags2CreateInfoKHR(const VkPipelineCreateFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineCreateFlags2CreateInfoKHR(const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src); + safe_VkPipelineCreateFlags2CreateInfoKHR& operator=(const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src); + safe_VkPipelineCreateFlags2CreateInfoKHR(); + ~safe_VkPipelineCreateFlags2CreateInfoKHR(); + void initialize(const VkPipelineCreateFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineCreateFlags2CreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPipelineCreateFlags2CreateInfoKHR* ptr() { return reinterpret_cast(this); } + VkPipelineCreateFlags2CreateInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkBufferUsageFlags2CreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkBufferUsageFlags2KHR usage; + + safe_VkBufferUsageFlags2CreateInfoKHR(const VkBufferUsageFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkBufferUsageFlags2CreateInfoKHR(const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src); + safe_VkBufferUsageFlags2CreateInfoKHR& operator=(const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src); + safe_VkBufferUsageFlags2CreateInfoKHR(); + ~safe_VkBufferUsageFlags2CreateInfoKHR(); + void initialize(const VkBufferUsageFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBufferUsageFlags2CreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkBufferUsageFlags2CreateInfoKHR* ptr() { return reinterpret_cast(this); } + VkBufferUsageFlags2CreateInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 rayTracingPositionFetch; + + 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_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 { + VkStructureType sType; + void* pNext{}; + VkBool32 cooperativeMatrix; + VkBool32 cooperativeMatrixRobustBufferAccess; + + 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); + } +}; +struct safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR { + VkStructureType sType; + void* pNext{}; + VkShaderStageFlags cooperativeMatrixSupportedStages; + + 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_VkVideoDecodeAV1ProfileInfoKHR { + VkStructureType sType; + const void* pNext{}; + StdVideoAV1Profile stdProfile; + VkBool32 filmGrainSupport; + + safe_VkVideoDecodeAV1ProfileInfoKHR(const VkVideoDecodeAV1ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoDecodeAV1ProfileInfoKHR(const safe_VkVideoDecodeAV1ProfileInfoKHR& copy_src); + safe_VkVideoDecodeAV1ProfileInfoKHR& operator=(const safe_VkVideoDecodeAV1ProfileInfoKHR& copy_src); + safe_VkVideoDecodeAV1ProfileInfoKHR(); + ~safe_VkVideoDecodeAV1ProfileInfoKHR(); + void initialize(const VkVideoDecodeAV1ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeAV1ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeAV1ProfileInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoDecodeAV1ProfileInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoDecodeAV1CapabilitiesKHR { + VkStructureType sType; + void* pNext{}; + StdVideoAV1Level maxLevel; + + safe_VkVideoDecodeAV1CapabilitiesKHR(const VkVideoDecodeAV1CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoDecodeAV1CapabilitiesKHR(const safe_VkVideoDecodeAV1CapabilitiesKHR& copy_src); + safe_VkVideoDecodeAV1CapabilitiesKHR& operator=(const safe_VkVideoDecodeAV1CapabilitiesKHR& copy_src); + safe_VkVideoDecodeAV1CapabilitiesKHR(); + ~safe_VkVideoDecodeAV1CapabilitiesKHR(); + void initialize(const VkVideoDecodeAV1CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeAV1CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeAV1CapabilitiesKHR* ptr() { return reinterpret_cast(this); } + VkVideoDecodeAV1CapabilitiesKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + const StdVideoAV1SequenceHeader* pStdSequenceHeader{}; + + safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR(const VkVideoDecodeAV1SessionParametersCreateInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR(const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& copy_src); + safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& operator=( + const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& copy_src); + safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR(); + ~safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR(); + void initialize(const VkVideoDecodeAV1SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeAV1SessionParametersCreateInfoKHR* ptr() { + return reinterpret_cast(this); + } + VkVideoDecodeAV1SessionParametersCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkVideoDecodeAV1PictureInfoKHR { + VkStructureType sType; + const void* pNext{}; + const StdVideoDecodeAV1PictureInfo* pStdPictureInfo{}; + int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]; + uint32_t frameHeaderOffset; + uint32_t tileCount; + const uint32_t* pTileOffsets{}; + const uint32_t* pTileSizes{}; + + safe_VkVideoDecodeAV1PictureInfoKHR(const VkVideoDecodeAV1PictureInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoDecodeAV1PictureInfoKHR(const safe_VkVideoDecodeAV1PictureInfoKHR& copy_src); + safe_VkVideoDecodeAV1PictureInfoKHR& operator=(const safe_VkVideoDecodeAV1PictureInfoKHR& copy_src); + safe_VkVideoDecodeAV1PictureInfoKHR(); + ~safe_VkVideoDecodeAV1PictureInfoKHR(); + void initialize(const VkVideoDecodeAV1PictureInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeAV1PictureInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeAV1PictureInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoDecodeAV1PictureInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkVideoDecodeAV1DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext{}; + const StdVideoDecodeAV1ReferenceInfo* pStdReferenceInfo{}; + + safe_VkVideoDecodeAV1DpbSlotInfoKHR(const VkVideoDecodeAV1DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoDecodeAV1DpbSlotInfoKHR(const safe_VkVideoDecodeAV1DpbSlotInfoKHR& copy_src); + safe_VkVideoDecodeAV1DpbSlotInfoKHR& operator=(const safe_VkVideoDecodeAV1DpbSlotInfoKHR& copy_src); + safe_VkVideoDecodeAV1DpbSlotInfoKHR(); + ~safe_VkVideoDecodeAV1DpbSlotInfoKHR(); + void initialize(const VkVideoDecodeAV1DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoDecodeAV1DpbSlotInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoDecodeAV1DpbSlotInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoDecodeAV1DpbSlotInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 videoMaintenance1; + + safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src); + safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& operator=(const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src); + safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(); + ~safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(); + void initialize(const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVideoMaintenance1FeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceVideoMaintenance1FeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkVideoInlineQueryInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkQueryPool queryPool; + uint32_t firstQuery; + uint32_t queryCount; + + safe_VkVideoInlineQueryInfoKHR(const VkVideoInlineQueryInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVideoInlineQueryInfoKHR(const safe_VkVideoInlineQueryInfoKHR& copy_src); + safe_VkVideoInlineQueryInfoKHR& operator=(const safe_VkVideoInlineQueryInfoKHR& copy_src); + safe_VkVideoInlineQueryInfoKHR(); + ~safe_VkVideoInlineQueryInfoKHR(); + void initialize(const VkVideoInlineQueryInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoInlineQueryInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkVideoInlineQueryInfoKHR* ptr() { return reinterpret_cast(this); } + VkVideoInlineQueryInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR { + VkStructureType sType; + void* pNext{}; + uint32_t maxVertexAttribDivisor; + VkBool32 supportsNonZeroFirstInstance; + + safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR( + const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src); + safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& operator=( + const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src); + safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(); + ~safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(); + void initialize(const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineVertexInputDivisorStateCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t vertexBindingDivisorCount; + const VkVertexInputBindingDivisorDescriptionKHR* pVertexBindingDivisors{}; + + safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src); + safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& operator=( + const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src); + safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(); + ~safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(); + void initialize(const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPipelineVertexInputDivisorStateCreateInfoKHR* ptr() { + return reinterpret_cast(this); + } + VkPipelineVertexInputDivisorStateCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 vertexAttributeInstanceRateDivisor; + VkBool32 vertexAttributeInstanceRateZeroDivisor; + + safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src); + safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& operator=( + const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src); + safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(); + ~safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(); + void initialize(const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderFloatControls2; + + safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src); + safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& operator=( + const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src); + safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(); + ~safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(); + void initialize(const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderFloatControls2FeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderFloatControls2FeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 indexTypeUint8; + + safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src); + safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& operator=(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src); + safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(); + ~safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(); + void initialize(const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceIndexTypeUint8FeaturesKHR* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceIndexTypeUint8FeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceLineRasterizationFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 rectangularLines; + VkBool32 bresenhamLines; + VkBool32 smoothLines; + VkBool32 stippledRectangularLines; + VkBool32 stippledBresenhamLines; + VkBool32 stippledSmoothLines; + + safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& copy_src); + safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& operator=(const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& copy_src); + safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(); + ~safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(); + void initialize(const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceLineRasterizationFeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceLineRasterizationFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceLineRasterizationPropertiesKHR { + VkStructureType sType; + void* pNext{}; + uint32_t lineSubPixelPrecisionBits; + + safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& copy_src); + safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& operator=( + const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& copy_src); + safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(); + ~safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(); + void initialize(const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceLineRasterizationPropertiesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceLineRasterizationPropertiesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineRasterizationLineStateCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkLineRasterizationModeKHR lineRasterizationMode; + VkBool32 stippledLineEnable; + uint32_t lineStippleFactor; + uint16_t lineStipplePattern; + + safe_VkPipelineRasterizationLineStateCreateInfoKHR(const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineRasterizationLineStateCreateInfoKHR(const safe_VkPipelineRasterizationLineStateCreateInfoKHR& copy_src); + safe_VkPipelineRasterizationLineStateCreateInfoKHR& operator=( + const safe_VkPipelineRasterizationLineStateCreateInfoKHR& copy_src); + safe_VkPipelineRasterizationLineStateCreateInfoKHR(); + ~safe_VkPipelineRasterizationLineStateCreateInfoKHR(); + void initialize(const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineRasterizationLineStateCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPipelineRasterizationLineStateCreateInfoKHR* ptr() { + return reinterpret_cast(this); + } + VkPipelineRasterizationLineStateCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +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_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderExpectAssume; + + safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src); + safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& operator=( + const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src); + safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(); + ~safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(); + void initialize(const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderExpectAssumeFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMaintenance6FeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 maintenance6; + + safe_VkPhysicalDeviceMaintenance6FeaturesKHR(const VkPhysicalDeviceMaintenance6FeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMaintenance6FeaturesKHR(const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& copy_src); + safe_VkPhysicalDeviceMaintenance6FeaturesKHR& operator=(const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& copy_src); + safe_VkPhysicalDeviceMaintenance6FeaturesKHR(); + ~safe_VkPhysicalDeviceMaintenance6FeaturesKHR(); + void initialize(const VkPhysicalDeviceMaintenance6FeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMaintenance6FeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMaintenance6FeaturesKHR* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMaintenance6FeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMaintenance6PropertiesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 blockTexelViewCompatibleMultipleLayers; + uint32_t maxCombinedImageSamplerDescriptorCount; + VkBool32 fragmentShadingRateClampCombinerInputs; + + safe_VkPhysicalDeviceMaintenance6PropertiesKHR(const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMaintenance6PropertiesKHR(const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src); + safe_VkPhysicalDeviceMaintenance6PropertiesKHR& operator=(const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src); + safe_VkPhysicalDeviceMaintenance6PropertiesKHR(); + ~safe_VkPhysicalDeviceMaintenance6PropertiesKHR(); + void initialize(const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMaintenance6PropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMaintenance6PropertiesKHR* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMaintenance6PropertiesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkBindMemoryStatusKHR { + VkStructureType sType; + const void* pNext{}; + VkResult* pResult{}; + + safe_VkBindMemoryStatusKHR(const VkBindMemoryStatusKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkBindMemoryStatusKHR(const safe_VkBindMemoryStatusKHR& copy_src); + safe_VkBindMemoryStatusKHR& operator=(const safe_VkBindMemoryStatusKHR& copy_src); + safe_VkBindMemoryStatusKHR(); + ~safe_VkBindMemoryStatusKHR(); + void initialize(const VkBindMemoryStatusKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBindMemoryStatusKHR* copy_src, PNextCopyState* copy_state = {}); + VkBindMemoryStatusKHR* ptr() { return reinterpret_cast(this); } + VkBindMemoryStatusKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkBindDescriptorSetsInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkShaderStageFlags stageFlags; + VkPipelineLayout layout; + uint32_t firstSet; + uint32_t descriptorSetCount; + VkDescriptorSet* pDescriptorSets{}; + uint32_t dynamicOffsetCount; + const uint32_t* pDynamicOffsets{}; + + safe_VkBindDescriptorSetsInfoKHR(const VkBindDescriptorSetsInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkBindDescriptorSetsInfoKHR(const safe_VkBindDescriptorSetsInfoKHR& copy_src); + safe_VkBindDescriptorSetsInfoKHR& operator=(const safe_VkBindDescriptorSetsInfoKHR& copy_src); + safe_VkBindDescriptorSetsInfoKHR(); + ~safe_VkBindDescriptorSetsInfoKHR(); + void initialize(const VkBindDescriptorSetsInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBindDescriptorSetsInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkBindDescriptorSetsInfoKHR* ptr() { return reinterpret_cast(this); } + VkBindDescriptorSetsInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPushConstantsInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkPipelineLayout layout; + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; + const void* pValues{}; + + safe_VkPushConstantsInfoKHR(const VkPushConstantsInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPushConstantsInfoKHR(const safe_VkPushConstantsInfoKHR& copy_src); + safe_VkPushConstantsInfoKHR& operator=(const safe_VkPushConstantsInfoKHR& copy_src); + safe_VkPushConstantsInfoKHR(); + ~safe_VkPushConstantsInfoKHR(); + void initialize(const VkPushConstantsInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPushConstantsInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPushConstantsInfoKHR* ptr() { return reinterpret_cast(this); } + VkPushConstantsInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPushDescriptorSetInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkShaderStageFlags stageFlags; + VkPipelineLayout layout; + uint32_t set; + uint32_t descriptorWriteCount; + safe_VkWriteDescriptorSet* pDescriptorWrites{}; + + safe_VkPushDescriptorSetInfoKHR(const VkPushDescriptorSetInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPushDescriptorSetInfoKHR(const safe_VkPushDescriptorSetInfoKHR& copy_src); + safe_VkPushDescriptorSetInfoKHR& operator=(const safe_VkPushDescriptorSetInfoKHR& copy_src); + safe_VkPushDescriptorSetInfoKHR(); + ~safe_VkPushDescriptorSetInfoKHR(); + void initialize(const VkPushDescriptorSetInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPushDescriptorSetInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPushDescriptorSetInfoKHR* ptr() { return reinterpret_cast(this); } + VkPushDescriptorSetInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPushDescriptorSetWithTemplateInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkDescriptorUpdateTemplate descriptorUpdateTemplate; + VkPipelineLayout layout; + uint32_t set; + const void* pData{}; + + safe_VkPushDescriptorSetWithTemplateInfoKHR(const VkPushDescriptorSetWithTemplateInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPushDescriptorSetWithTemplateInfoKHR(const safe_VkPushDescriptorSetWithTemplateInfoKHR& copy_src); + safe_VkPushDescriptorSetWithTemplateInfoKHR& operator=(const safe_VkPushDescriptorSetWithTemplateInfoKHR& copy_src); + safe_VkPushDescriptorSetWithTemplateInfoKHR(); + ~safe_VkPushDescriptorSetWithTemplateInfoKHR(); + void initialize(const VkPushDescriptorSetWithTemplateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPushDescriptorSetWithTemplateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkPushDescriptorSetWithTemplateInfoKHR* ptr() { return reinterpret_cast(this); } + VkPushDescriptorSetWithTemplateInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSetDescriptorBufferOffsetsInfoEXT { + VkStructureType sType; + const void* pNext{}; + 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_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_VkBindDescriptorBufferEmbeddedSamplersInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkShaderStageFlags stageFlags; + VkPipelineLayout layout; + uint32_t set; + + 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_VkDebugReportCallbackCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkDebugReportFlagsEXT flags; + PFN_vkDebugReportCallbackEXT pfnCallback; + void* pUserData{}; + + 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_VkPipelineRasterizationStateRasterizationOrderAMD { + VkStructureType sType; + const void* pNext{}; + VkRasterizationOrderAMD rasterizationOrder; + + 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_VkDebugMarkerObjectNameInfoEXT { + VkStructureType sType; + const void* pNext{}; + 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_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_VkDedicatedAllocationImageCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkBool32 dedicatedAllocation; + + 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_VkDedicatedAllocationBufferCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkBool32 dedicatedAllocation; + + 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_VkDedicatedAllocationMemoryAllocateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkImage image; + VkBuffer buffer; + + 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_VkPhysicalDeviceTransformFeedbackFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 transformFeedback; + VkBool32 geometryStreams; + + 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); + } +}; +struct safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT { + 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; + + 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); + } +}; +struct safe_VkPipelineRasterizationStateStreamCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkPipelineRasterizationStateStreamCreateFlagsEXT flags; + uint32_t rasterizationStream; + + 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_VkCuModuleCreateInfoNVX { + VkStructureType sType; + const void* pNext{}; + size_t dataSize; + const void* pData{}; + + 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_VkCuFunctionCreateInfoNVX { + VkStructureType sType; + const void* pNext{}; + VkCuModuleNVX module; + const char* pName{}; + + 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_VkCuLaunchInfoNVX { + 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{}; + + 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_VkImageViewHandleInfoNVX { + VkStructureType sType; + const void* pNext{}; + VkImageView imageView; + VkDescriptorType descriptorType; + VkSampler sampler; + + 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_VkImageViewAddressPropertiesNVX { + VkStructureType sType; + void* pNext{}; + VkDeviceAddress deviceAddress; + VkDeviceSize size; + + 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); } +}; +struct safe_VkTextureLODGatherFormatPropertiesAMD { + VkStructureType sType; + void* pNext{}; + VkBool32 supportsTextureGatherLODBiasAMD; + + safe_VkTextureLODGatherFormatPropertiesAMD(const VkTextureLODGatherFormatPropertiesAMD* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkTextureLODGatherFormatPropertiesAMD(const safe_VkTextureLODGatherFormatPropertiesAMD& copy_src); + safe_VkTextureLODGatherFormatPropertiesAMD& operator=(const safe_VkTextureLODGatherFormatPropertiesAMD& copy_src); + safe_VkTextureLODGatherFormatPropertiesAMD(); + ~safe_VkTextureLODGatherFormatPropertiesAMD(); + void initialize(const VkTextureLODGatherFormatPropertiesAMD* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkTextureLODGatherFormatPropertiesAMD* copy_src, PNextCopyState* copy_state = {}); + VkTextureLODGatherFormatPropertiesAMD* ptr() { return reinterpret_cast(this); } + VkTextureLODGatherFormatPropertiesAMD const* ptr() const { + return reinterpret_cast(this); + } +}; +#ifdef VK_USE_PLATFORM_GGP +struct safe_VkStreamDescriptorSurfaceCreateInfoGGP { + VkStructureType sType; + const void* pNext{}; + VkStreamDescriptorSurfaceCreateFlagsGGP flags; + GgpStreamDescriptor streamDescriptor; + + safe_VkStreamDescriptorSurfaceCreateInfoGGP(const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkStreamDescriptorSurfaceCreateInfoGGP(const safe_VkStreamDescriptorSurfaceCreateInfoGGP& copy_src); + safe_VkStreamDescriptorSurfaceCreateInfoGGP& operator=(const safe_VkStreamDescriptorSurfaceCreateInfoGGP& copy_src); + safe_VkStreamDescriptorSurfaceCreateInfoGGP(); + ~safe_VkStreamDescriptorSurfaceCreateInfoGGP(); + void initialize(const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkStreamDescriptorSurfaceCreateInfoGGP* copy_src, PNextCopyState* copy_state = {}); + VkStreamDescriptorSurfaceCreateInfoGGP* ptr() { return reinterpret_cast(this); } + VkStreamDescriptorSurfaceCreateInfoGGP const* ptr() const { + return reinterpret_cast(this); + } +}; +#endif // VK_USE_PLATFORM_GGP +struct safe_VkPhysicalDeviceCornerSampledImageFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 cornerSampledImage; + + safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& copy_src); + safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& operator=(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& copy_src); + safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(); + ~safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(); + void initialize(const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceCornerSampledImageFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceCornerSampledImageFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkExternalMemoryImageCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkExternalMemoryHandleTypeFlagsNV handleTypes; + + safe_VkExternalMemoryImageCreateInfoNV(const VkExternalMemoryImageCreateInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExternalMemoryImageCreateInfoNV(const safe_VkExternalMemoryImageCreateInfoNV& copy_src); + safe_VkExternalMemoryImageCreateInfoNV& operator=(const safe_VkExternalMemoryImageCreateInfoNV& copy_src); + safe_VkExternalMemoryImageCreateInfoNV(); + ~safe_VkExternalMemoryImageCreateInfoNV(); + void initialize(const VkExternalMemoryImageCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExternalMemoryImageCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkExternalMemoryImageCreateInfoNV* ptr() { return reinterpret_cast(this); } + VkExternalMemoryImageCreateInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkExportMemoryAllocateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkExternalMemoryHandleTypeFlagsNV handleTypes; + + safe_VkExportMemoryAllocateInfoNV(const VkExportMemoryAllocateInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExportMemoryAllocateInfoNV(const safe_VkExportMemoryAllocateInfoNV& copy_src); + safe_VkExportMemoryAllocateInfoNV& operator=(const safe_VkExportMemoryAllocateInfoNV& copy_src); + safe_VkExportMemoryAllocateInfoNV(); + ~safe_VkExportMemoryAllocateInfoNV(); + void initialize(const VkExportMemoryAllocateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExportMemoryAllocateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkExportMemoryAllocateInfoNV* ptr() { return reinterpret_cast(this); } + VkExportMemoryAllocateInfoNV const* ptr() const { return reinterpret_cast(this); } +}; +#ifdef VK_USE_PLATFORM_WIN32_KHR +struct safe_VkImportMemoryWin32HandleInfoNV { + VkStructureType sType; + const void* pNext{}; + VkExternalMemoryHandleTypeFlagsNV handleType; + HANDLE handle; + + safe_VkImportMemoryWin32HandleInfoNV(const VkImportMemoryWin32HandleInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImportMemoryWin32HandleInfoNV(const safe_VkImportMemoryWin32HandleInfoNV& copy_src); + safe_VkImportMemoryWin32HandleInfoNV& operator=(const safe_VkImportMemoryWin32HandleInfoNV& copy_src); + safe_VkImportMemoryWin32HandleInfoNV(); + ~safe_VkImportMemoryWin32HandleInfoNV(); + void initialize(const VkImportMemoryWin32HandleInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImportMemoryWin32HandleInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkImportMemoryWin32HandleInfoNV* ptr() { return reinterpret_cast(this); } + VkImportMemoryWin32HandleInfoNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkExportMemoryWin32HandleInfoNV { + VkStructureType sType; + const void* pNext{}; + const SECURITY_ATTRIBUTES* pAttributes{}; + DWORD dwAccess; + + safe_VkExportMemoryWin32HandleInfoNV(const VkExportMemoryWin32HandleInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExportMemoryWin32HandleInfoNV(const safe_VkExportMemoryWin32HandleInfoNV& copy_src); + safe_VkExportMemoryWin32HandleInfoNV& operator=(const safe_VkExportMemoryWin32HandleInfoNV& copy_src); + safe_VkExportMemoryWin32HandleInfoNV(); + ~safe_VkExportMemoryWin32HandleInfoNV(); + void initialize(const VkExportMemoryWin32HandleInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExportMemoryWin32HandleInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkExportMemoryWin32HandleInfoNV* ptr() { return reinterpret_cast(this); } + VkExportMemoryWin32HandleInfoNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkWin32KeyedMutexAcquireReleaseInfoNV { + VkStructureType sType; + const void* pNext{}; + uint32_t acquireCount; + VkDeviceMemory* pAcquireSyncs{}; + const uint64_t* pAcquireKeys{}; + const uint32_t* pAcquireTimeoutMilliseconds{}; + uint32_t releaseCount; + VkDeviceMemory* pReleaseSyncs{}; + const uint64_t* pReleaseKeys{}; + + safe_VkWin32KeyedMutexAcquireReleaseInfoNV(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkWin32KeyedMutexAcquireReleaseInfoNV(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& copy_src); + safe_VkWin32KeyedMutexAcquireReleaseInfoNV& operator=(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& copy_src); + safe_VkWin32KeyedMutexAcquireReleaseInfoNV(); + ~safe_VkWin32KeyedMutexAcquireReleaseInfoNV(); + void initialize(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkWin32KeyedMutexAcquireReleaseInfoNV* ptr() { return reinterpret_cast(this); } + VkWin32KeyedMutexAcquireReleaseInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +#endif // VK_USE_PLATFORM_WIN32_KHR +struct safe_VkValidationFlagsEXT { + VkStructureType sType; + const void* pNext{}; + uint32_t disabledValidationCheckCount; + const VkValidationCheckEXT* pDisabledValidationChecks{}; + + safe_VkValidationFlagsEXT(const VkValidationFlagsEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkValidationFlagsEXT(const safe_VkValidationFlagsEXT& copy_src); + safe_VkValidationFlagsEXT& operator=(const safe_VkValidationFlagsEXT& copy_src); + safe_VkValidationFlagsEXT(); + ~safe_VkValidationFlagsEXT(); + void initialize(const VkValidationFlagsEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkValidationFlagsEXT* copy_src, PNextCopyState* copy_state = {}); + VkValidationFlagsEXT* ptr() { return reinterpret_cast(this); } + VkValidationFlagsEXT const* ptr() const { return reinterpret_cast(this); } +}; +#ifdef VK_USE_PLATFORM_VI_NN +struct safe_VkViSurfaceCreateInfoNN { + VkStructureType sType; + const void* pNext{}; + VkViSurfaceCreateFlagsNN flags; + void* window{}; + + safe_VkViSurfaceCreateInfoNN(const VkViSurfaceCreateInfoNN* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkViSurfaceCreateInfoNN(const safe_VkViSurfaceCreateInfoNN& copy_src); + safe_VkViSurfaceCreateInfoNN& operator=(const safe_VkViSurfaceCreateInfoNN& copy_src); + safe_VkViSurfaceCreateInfoNN(); + ~safe_VkViSurfaceCreateInfoNN(); + void initialize(const VkViSurfaceCreateInfoNN* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkViSurfaceCreateInfoNN* copy_src, PNextCopyState* copy_state = {}); + VkViSurfaceCreateInfoNN* ptr() { return reinterpret_cast(this); } + VkViSurfaceCreateInfoNN const* ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_VI_NN +struct safe_VkImageViewASTCDecodeModeEXT { + VkStructureType sType; + const void* pNext{}; + VkFormat decodeMode; + + safe_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImageViewASTCDecodeModeEXT(const safe_VkImageViewASTCDecodeModeEXT& copy_src); + safe_VkImageViewASTCDecodeModeEXT& operator=(const safe_VkImageViewASTCDecodeModeEXT& copy_src); + safe_VkImageViewASTCDecodeModeEXT(); + ~safe_VkImageViewASTCDecodeModeEXT(); + void initialize(const VkImageViewASTCDecodeModeEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageViewASTCDecodeModeEXT* copy_src, PNextCopyState* copy_state = {}); + VkImageViewASTCDecodeModeEXT* ptr() { return reinterpret_cast(this); } + VkImageViewASTCDecodeModeEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceASTCDecodeFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 decodeModeSharedExponent; + + safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& copy_src); + safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& operator=(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& copy_src); + safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(); + ~safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(); + void initialize(const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceASTCDecodeFeaturesEXT* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceASTCDecodeFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 pipelineRobustness; + + safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(const VkPhysicalDevicePipelineRobustnessFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& copy_src); + safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& operator=( + const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& copy_src); + safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(); + ~safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(); + void initialize(const VkPhysicalDevicePipelineRobustnessFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePipelineRobustnessFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDevicePipelineRobustnessFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT { + VkStructureType sType; + void* pNext{}; + VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessStorageBuffers; + VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessUniformBuffers; + VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessVertexInputs; + VkPipelineRobustnessImageBehaviorEXT defaultRobustnessImages; + + safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(const VkPhysicalDevicePipelineRobustnessPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& copy_src); + safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& operator=( + const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& copy_src); + safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(); + ~safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(); + void initialize(const VkPhysicalDevicePipelineRobustnessPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePipelineRobustnessPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDevicePipelineRobustnessPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineRobustnessCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkPipelineRobustnessBufferBehaviorEXT storageBuffers; + VkPipelineRobustnessBufferBehaviorEXT uniformBuffers; + VkPipelineRobustnessBufferBehaviorEXT vertexInputs; + VkPipelineRobustnessImageBehaviorEXT images; + + safe_VkPipelineRobustnessCreateInfoEXT(const VkPipelineRobustnessCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineRobustnessCreateInfoEXT(const safe_VkPipelineRobustnessCreateInfoEXT& copy_src); + safe_VkPipelineRobustnessCreateInfoEXT& operator=(const safe_VkPipelineRobustnessCreateInfoEXT& copy_src); + safe_VkPipelineRobustnessCreateInfoEXT(); + ~safe_VkPipelineRobustnessCreateInfoEXT(); + void initialize(const VkPipelineRobustnessCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineRobustnessCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkPipelineRobustnessCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkPipelineRobustnessCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkConditionalRenderingBeginInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkBuffer buffer; + VkDeviceSize offset; + VkConditionalRenderingFlagsEXT flags; + + safe_VkConditionalRenderingBeginInfoEXT(const VkConditionalRenderingBeginInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkConditionalRenderingBeginInfoEXT(const safe_VkConditionalRenderingBeginInfoEXT& copy_src); + safe_VkConditionalRenderingBeginInfoEXT& operator=(const safe_VkConditionalRenderingBeginInfoEXT& copy_src); + safe_VkConditionalRenderingBeginInfoEXT(); + ~safe_VkConditionalRenderingBeginInfoEXT(); + void initialize(const VkConditionalRenderingBeginInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkConditionalRenderingBeginInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkConditionalRenderingBeginInfoEXT* ptr() { return reinterpret_cast(this); } + VkConditionalRenderingBeginInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 conditionalRendering; + VkBool32 inheritedConditionalRendering; + + safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& copy_src); + safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& operator=( + const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& copy_src); + safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(); + ~safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(); + void initialize(const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceConditionalRenderingFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceConditionalRenderingFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkBool32 conditionalRenderingEnable; + + safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT( + const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT( + const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& copy_src); + safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& operator=( + const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& copy_src); + safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(); + ~safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(); + void initialize(const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkCommandBufferInheritanceConditionalRenderingInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkCommandBufferInheritanceConditionalRenderingInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineViewportWScalingStateCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkBool32 viewportWScalingEnable; + uint32_t viewportCount; + const VkViewportWScalingNV* pViewportWScalings{}; + + safe_VkPipelineViewportWScalingStateCreateInfoNV(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineViewportWScalingStateCreateInfoNV(const safe_VkPipelineViewportWScalingStateCreateInfoNV& copy_src); + safe_VkPipelineViewportWScalingStateCreateInfoNV& operator=(const safe_VkPipelineViewportWScalingStateCreateInfoNV& copy_src); + safe_VkPipelineViewportWScalingStateCreateInfoNV(); + ~safe_VkPipelineViewportWScalingStateCreateInfoNV(); + void initialize(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineViewportWScalingStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkPipelineViewportWScalingStateCreateInfoNV* ptr() { + return reinterpret_cast(this); + } + VkPipelineViewportWScalingStateCreateInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSurfaceCapabilities2EXT { + VkStructureType sType; + void* pNext{}; + uint32_t minImageCount; + uint32_t maxImageCount; + VkExtent2D currentExtent; + VkExtent2D minImageExtent; + VkExtent2D maxImageExtent; + uint32_t maxImageArrayLayers; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkSurfaceTransformFlagBitsKHR currentTransform; + VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + VkImageUsageFlags supportedUsageFlags; + VkSurfaceCounterFlagsEXT supportedSurfaceCounters; + + safe_VkSurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSurfaceCapabilities2EXT(const safe_VkSurfaceCapabilities2EXT& copy_src); + safe_VkSurfaceCapabilities2EXT& operator=(const safe_VkSurfaceCapabilities2EXT& copy_src); + safe_VkSurfaceCapabilities2EXT(); + ~safe_VkSurfaceCapabilities2EXT(); + void initialize(const VkSurfaceCapabilities2EXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSurfaceCapabilities2EXT* copy_src, PNextCopyState* copy_state = {}); + VkSurfaceCapabilities2EXT* ptr() { return reinterpret_cast(this); } + VkSurfaceCapabilities2EXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDisplayPowerInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkDisplayPowerStateEXT powerState; + + safe_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDisplayPowerInfoEXT(const safe_VkDisplayPowerInfoEXT& copy_src); + safe_VkDisplayPowerInfoEXT& operator=(const safe_VkDisplayPowerInfoEXT& copy_src); + safe_VkDisplayPowerInfoEXT(); + ~safe_VkDisplayPowerInfoEXT(); + void initialize(const VkDisplayPowerInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDisplayPowerInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkDisplayPowerInfoEXT* ptr() { return reinterpret_cast(this); } + VkDisplayPowerInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDeviceEventInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkDeviceEventTypeEXT deviceEvent; + + safe_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDeviceEventInfoEXT(const safe_VkDeviceEventInfoEXT& copy_src); + safe_VkDeviceEventInfoEXT& operator=(const safe_VkDeviceEventInfoEXT& copy_src); + safe_VkDeviceEventInfoEXT(); + ~safe_VkDeviceEventInfoEXT(); + void initialize(const VkDeviceEventInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceEventInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkDeviceEventInfoEXT* ptr() { return reinterpret_cast(this); } + VkDeviceEventInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDisplayEventInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkDisplayEventTypeEXT displayEvent; + + safe_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDisplayEventInfoEXT(const safe_VkDisplayEventInfoEXT& copy_src); + safe_VkDisplayEventInfoEXT& operator=(const safe_VkDisplayEventInfoEXT& copy_src); + safe_VkDisplayEventInfoEXT(); + ~safe_VkDisplayEventInfoEXT(); + void initialize(const VkDisplayEventInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDisplayEventInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkDisplayEventInfoEXT* ptr() { return reinterpret_cast(this); } + VkDisplayEventInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSwapchainCounterCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkSurfaceCounterFlagsEXT surfaceCounters; + + safe_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSwapchainCounterCreateInfoEXT(const safe_VkSwapchainCounterCreateInfoEXT& copy_src); + safe_VkSwapchainCounterCreateInfoEXT& operator=(const safe_VkSwapchainCounterCreateInfoEXT& copy_src); + safe_VkSwapchainCounterCreateInfoEXT(); + ~safe_VkSwapchainCounterCreateInfoEXT(); + void initialize(const VkSwapchainCounterCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSwapchainCounterCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkSwapchainCounterCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkSwapchainCounterCreateInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPresentTimesInfoGOOGLE { + VkStructureType sType; + const void* pNext{}; + uint32_t swapchainCount; + const VkPresentTimeGOOGLE* pTimes{}; + + safe_VkPresentTimesInfoGOOGLE(const VkPresentTimesInfoGOOGLE* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPresentTimesInfoGOOGLE(const safe_VkPresentTimesInfoGOOGLE& copy_src); + safe_VkPresentTimesInfoGOOGLE& operator=(const safe_VkPresentTimesInfoGOOGLE& copy_src); + safe_VkPresentTimesInfoGOOGLE(); + ~safe_VkPresentTimesInfoGOOGLE(); + void initialize(const VkPresentTimesInfoGOOGLE* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPresentTimesInfoGOOGLE* copy_src, PNextCopyState* copy_state = {}); + VkPresentTimesInfoGOOGLE* ptr() { return reinterpret_cast(this); } + VkPresentTimesInfoGOOGLE const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + VkStructureType sType; + void* pNext{}; + VkBool32 perViewPositionAllComponents; + + safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( + const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( + const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& copy_src); + safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& operator=( + const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& copy_src); + safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(); + ~safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(); + void initialize(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineViewportSwizzleStateCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkPipelineViewportSwizzleStateCreateFlagsNV flags; + uint32_t viewportCount; + const VkViewportSwizzleNV* pViewportSwizzles{}; + + safe_VkPipelineViewportSwizzleStateCreateInfoNV(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineViewportSwizzleStateCreateInfoNV(const safe_VkPipelineViewportSwizzleStateCreateInfoNV& copy_src); + safe_VkPipelineViewportSwizzleStateCreateInfoNV& operator=(const safe_VkPipelineViewportSwizzleStateCreateInfoNV& copy_src); + safe_VkPipelineViewportSwizzleStateCreateInfoNV(); + ~safe_VkPipelineViewportSwizzleStateCreateInfoNV(); + void initialize(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineViewportSwizzleStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkPipelineViewportSwizzleStateCreateInfoNV* ptr() { + return reinterpret_cast(this); + } + VkPipelineViewportSwizzleStateCreateInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT { + VkStructureType sType; + void* pNext{}; + uint32_t maxDiscardRectangles; + + safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& copy_src); + safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& operator=( + const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& copy_src); + safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(); + ~safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(); + void initialize(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDiscardRectanglePropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDiscardRectanglePropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineDiscardRectangleStateCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkPipelineDiscardRectangleStateCreateFlagsEXT flags; + VkDiscardRectangleModeEXT discardRectangleMode; + uint32_t discardRectangleCount; + const VkRect2D* pDiscardRectangles{}; + + safe_VkPipelineDiscardRectangleStateCreateInfoEXT(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineDiscardRectangleStateCreateInfoEXT(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT& copy_src); + safe_VkPipelineDiscardRectangleStateCreateInfoEXT& operator=(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT& copy_src); + safe_VkPipelineDiscardRectangleStateCreateInfoEXT(); + ~safe_VkPipelineDiscardRectangleStateCreateInfoEXT(); + void initialize(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkPipelineDiscardRectangleStateCreateInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkPipelineDiscardRectangleStateCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT { + VkStructureType sType; + void* pNext{}; + float primitiveOverestimationSize; + float maxExtraPrimitiveOverestimationSize; + float extraPrimitiveOverestimationSizeGranularity; + VkBool32 primitiveUnderestimation; + VkBool32 conservativePointAndLineRasterization; + VkBool32 degenerateTrianglesRasterized; + VkBool32 degenerateLinesRasterized; + VkBool32 fullyCoveredFragmentShaderInputVariable; + VkBool32 conservativeRasterizationPostDepthCoverage; + + safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT( + const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT( + const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& copy_src); + safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& operator=( + const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& copy_src); + safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(); + ~safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(); + void initialize(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceConservativeRasterizationPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceConservativeRasterizationPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineRasterizationConservativeStateCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; + VkConservativeRasterizationModeEXT conservativeRasterizationMode; + float extraPrimitiveOverestimationSize; + + safe_VkPipelineRasterizationConservativeStateCreateInfoEXT( + const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineRasterizationConservativeStateCreateInfoEXT( + const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& copy_src); + safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& operator=( + const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& copy_src); + safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(); + ~safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(); + void initialize(const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkPipelineRasterizationConservativeStateCreateInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkPipelineRasterizationConservativeStateCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 depthClipEnable; + + safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& copy_src); + safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& operator=(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& copy_src); + safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(); + ~safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(); + void initialize(const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDepthClipEnableFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDepthClipEnableFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags; + VkBool32 depthClipEnable; + + safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT( + const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& copy_src); + safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& operator=( + const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& copy_src); + safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(); + ~safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(); + void initialize(const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkPipelineRasterizationDepthClipStateCreateInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkPipelineRasterizationDepthClipStateCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkHdrMetadataEXT { + VkStructureType sType; + const void* pNext{}; + VkXYColorEXT displayPrimaryRed; + VkXYColorEXT displayPrimaryGreen; + VkXYColorEXT displayPrimaryBlue; + VkXYColorEXT whitePoint; + float maxLuminance; + float minLuminance; + float maxContentLightLevel; + float maxFrameAverageLightLevel; + + safe_VkHdrMetadataEXT(const VkHdrMetadataEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkHdrMetadataEXT(const safe_VkHdrMetadataEXT& copy_src); + safe_VkHdrMetadataEXT& operator=(const safe_VkHdrMetadataEXT& copy_src); + safe_VkHdrMetadataEXT(); + ~safe_VkHdrMetadataEXT(); + void initialize(const VkHdrMetadataEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkHdrMetadataEXT* copy_src, PNextCopyState* copy_state = {}); + VkHdrMetadataEXT* ptr() { return reinterpret_cast(this); } + VkHdrMetadataEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG { + VkStructureType sType; + void* pNext{}; + VkBool32 relaxedLineRasterization; + + safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG(const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG( + const safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& copy_src); + safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& operator=( + const safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& copy_src); + safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG(); + ~safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG(); + void initialize(const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDebugUtilsLabelEXT { + VkStructureType sType; + const void* pNext{}; + const char* pLabelName{}; + float color[4]; + + safe_VkDebugUtilsLabelEXT(const VkDebugUtilsLabelEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDebugUtilsLabelEXT(const safe_VkDebugUtilsLabelEXT& copy_src); + safe_VkDebugUtilsLabelEXT& operator=(const safe_VkDebugUtilsLabelEXT& copy_src); + safe_VkDebugUtilsLabelEXT(); + ~safe_VkDebugUtilsLabelEXT(); + void initialize(const VkDebugUtilsLabelEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDebugUtilsLabelEXT* copy_src, PNextCopyState* copy_state = {}); + VkDebugUtilsLabelEXT* ptr() { return reinterpret_cast(this); } + VkDebugUtilsLabelEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDebugUtilsObjectNameInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkObjectType objectType; + uint64_t objectHandle; + const char* pObjectName{}; + + safe_VkDebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDebugUtilsObjectNameInfoEXT(const safe_VkDebugUtilsObjectNameInfoEXT& copy_src); + safe_VkDebugUtilsObjectNameInfoEXT& operator=(const safe_VkDebugUtilsObjectNameInfoEXT& copy_src); + safe_VkDebugUtilsObjectNameInfoEXT(); + ~safe_VkDebugUtilsObjectNameInfoEXT(); + void initialize(const VkDebugUtilsObjectNameInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDebugUtilsObjectNameInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkDebugUtilsObjectNameInfoEXT* ptr() { return reinterpret_cast(this); } + VkDebugUtilsObjectNameInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDebugUtilsMessengerCallbackDataEXT { + VkStructureType sType; + const void* pNext{}; + VkDebugUtilsMessengerCallbackDataFlagsEXT flags; + const char* pMessageIdName{}; + int32_t messageIdNumber; + const char* pMessage{}; + uint32_t queueLabelCount; + safe_VkDebugUtilsLabelEXT* pQueueLabels{}; + uint32_t cmdBufLabelCount; + safe_VkDebugUtilsLabelEXT* pCmdBufLabels{}; + uint32_t objectCount; + safe_VkDebugUtilsObjectNameInfoEXT* pObjects{}; + + safe_VkDebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessengerCallbackDataEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDebugUtilsMessengerCallbackDataEXT(const safe_VkDebugUtilsMessengerCallbackDataEXT& copy_src); + safe_VkDebugUtilsMessengerCallbackDataEXT& operator=(const safe_VkDebugUtilsMessengerCallbackDataEXT& copy_src); + safe_VkDebugUtilsMessengerCallbackDataEXT(); + ~safe_VkDebugUtilsMessengerCallbackDataEXT(); + void initialize(const VkDebugUtilsMessengerCallbackDataEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDebugUtilsMessengerCallbackDataEXT* copy_src, PNextCopyState* copy_state = {}); + VkDebugUtilsMessengerCallbackDataEXT* ptr() { return reinterpret_cast(this); } + VkDebugUtilsMessengerCallbackDataEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDebugUtilsMessengerCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkDebugUtilsMessengerCreateFlagsEXT flags; + VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; + VkDebugUtilsMessageTypeFlagsEXT messageType; + PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; + void* pUserData{}; + + safe_VkDebugUtilsMessengerCreateInfoEXT(const VkDebugUtilsMessengerCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDebugUtilsMessengerCreateInfoEXT(const safe_VkDebugUtilsMessengerCreateInfoEXT& copy_src); + safe_VkDebugUtilsMessengerCreateInfoEXT& operator=(const safe_VkDebugUtilsMessengerCreateInfoEXT& copy_src); + safe_VkDebugUtilsMessengerCreateInfoEXT(); + ~safe_VkDebugUtilsMessengerCreateInfoEXT(); + void initialize(const VkDebugUtilsMessengerCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDebugUtilsMessengerCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkDebugUtilsMessengerCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkDebugUtilsMessengerCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDebugUtilsObjectTagInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkObjectType objectType; + uint64_t objectHandle; + uint64_t tagName; + size_t tagSize; + const void* pTag{}; + + safe_VkDebugUtilsObjectTagInfoEXT(const VkDebugUtilsObjectTagInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDebugUtilsObjectTagInfoEXT(const safe_VkDebugUtilsObjectTagInfoEXT& copy_src); + safe_VkDebugUtilsObjectTagInfoEXT& operator=(const safe_VkDebugUtilsObjectTagInfoEXT& copy_src); + safe_VkDebugUtilsObjectTagInfoEXT(); + ~safe_VkDebugUtilsObjectTagInfoEXT(); + void initialize(const VkDebugUtilsObjectTagInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDebugUtilsObjectTagInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkDebugUtilsObjectTagInfoEXT* ptr() { return reinterpret_cast(this); } + VkDebugUtilsObjectTagInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +#ifdef VK_USE_PLATFORM_ANDROID_KHR +struct safe_VkAndroidHardwareBufferUsageANDROID { + VkStructureType sType; + void* pNext{}; + uint64_t androidHardwareBufferUsage; + + safe_VkAndroidHardwareBufferUsageANDROID(const VkAndroidHardwareBufferUsageANDROID* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkAndroidHardwareBufferUsageANDROID(const safe_VkAndroidHardwareBufferUsageANDROID& copy_src); + safe_VkAndroidHardwareBufferUsageANDROID& operator=(const safe_VkAndroidHardwareBufferUsageANDROID& copy_src); + safe_VkAndroidHardwareBufferUsageANDROID(); + ~safe_VkAndroidHardwareBufferUsageANDROID(); + void initialize(const VkAndroidHardwareBufferUsageANDROID* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAndroidHardwareBufferUsageANDROID* copy_src, PNextCopyState* copy_state = {}); + VkAndroidHardwareBufferUsageANDROID* ptr() { return reinterpret_cast(this); } + VkAndroidHardwareBufferUsageANDROID const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAndroidHardwareBufferPropertiesANDROID { + VkStructureType sType; + void* pNext{}; + VkDeviceSize allocationSize; + uint32_t memoryTypeBits; + + safe_VkAndroidHardwareBufferPropertiesANDROID(const VkAndroidHardwareBufferPropertiesANDROID* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAndroidHardwareBufferPropertiesANDROID(const safe_VkAndroidHardwareBufferPropertiesANDROID& copy_src); + safe_VkAndroidHardwareBufferPropertiesANDROID& operator=(const safe_VkAndroidHardwareBufferPropertiesANDROID& copy_src); + safe_VkAndroidHardwareBufferPropertiesANDROID(); + ~safe_VkAndroidHardwareBufferPropertiesANDROID(); + void initialize(const VkAndroidHardwareBufferPropertiesANDROID* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAndroidHardwareBufferPropertiesANDROID* copy_src, PNextCopyState* copy_state = {}); + VkAndroidHardwareBufferPropertiesANDROID* ptr() { return reinterpret_cast(this); } + VkAndroidHardwareBufferPropertiesANDROID const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAndroidHardwareBufferFormatPropertiesANDROID { + VkStructureType sType; + void* pNext{}; + VkFormat format; + uint64_t externalFormat; + VkFormatFeatureFlags formatFeatures; + VkComponentMapping samplerYcbcrConversionComponents; + VkSamplerYcbcrModelConversion suggestedYcbcrModel; + VkSamplerYcbcrRange suggestedYcbcrRange; + VkChromaLocation suggestedXChromaOffset; + VkChromaLocation suggestedYChromaOffset; + + safe_VkAndroidHardwareBufferFormatPropertiesANDROID(const VkAndroidHardwareBufferFormatPropertiesANDROID* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAndroidHardwareBufferFormatPropertiesANDROID(const safe_VkAndroidHardwareBufferFormatPropertiesANDROID& copy_src); + safe_VkAndroidHardwareBufferFormatPropertiesANDROID& operator=( + const safe_VkAndroidHardwareBufferFormatPropertiesANDROID& copy_src); + safe_VkAndroidHardwareBufferFormatPropertiesANDROID(); + ~safe_VkAndroidHardwareBufferFormatPropertiesANDROID(); + void initialize(const VkAndroidHardwareBufferFormatPropertiesANDROID* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAndroidHardwareBufferFormatPropertiesANDROID* copy_src, PNextCopyState* copy_state = {}); + VkAndroidHardwareBufferFormatPropertiesANDROID* ptr() { + return reinterpret_cast(this); + } + VkAndroidHardwareBufferFormatPropertiesANDROID const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImportAndroidHardwareBufferInfoANDROID { + VkStructureType sType; + const void* pNext{}; + struct AHardwareBuffer* buffer{}; + + safe_VkImportAndroidHardwareBufferInfoANDROID(const VkImportAndroidHardwareBufferInfoANDROID* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImportAndroidHardwareBufferInfoANDROID(const safe_VkImportAndroidHardwareBufferInfoANDROID& copy_src); + safe_VkImportAndroidHardwareBufferInfoANDROID& operator=(const safe_VkImportAndroidHardwareBufferInfoANDROID& copy_src); + safe_VkImportAndroidHardwareBufferInfoANDROID(); + ~safe_VkImportAndroidHardwareBufferInfoANDROID(); + void initialize(const VkImportAndroidHardwareBufferInfoANDROID* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImportAndroidHardwareBufferInfoANDROID* copy_src, PNextCopyState* copy_state = {}); + VkImportAndroidHardwareBufferInfoANDROID* ptr() { return reinterpret_cast(this); } + VkImportAndroidHardwareBufferInfoANDROID const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkMemoryGetAndroidHardwareBufferInfoANDROID { + VkStructureType sType; + const void* pNext{}; + VkDeviceMemory memory; + + safe_VkMemoryGetAndroidHardwareBufferInfoANDROID(const VkMemoryGetAndroidHardwareBufferInfoANDROID* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMemoryGetAndroidHardwareBufferInfoANDROID(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& copy_src); + safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& operator=(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& copy_src); + safe_VkMemoryGetAndroidHardwareBufferInfoANDROID(); + ~safe_VkMemoryGetAndroidHardwareBufferInfoANDROID(); + void initialize(const VkMemoryGetAndroidHardwareBufferInfoANDROID* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID* copy_src, PNextCopyState* copy_state = {}); + VkMemoryGetAndroidHardwareBufferInfoANDROID* ptr() { + return reinterpret_cast(this); + } + VkMemoryGetAndroidHardwareBufferInfoANDROID const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkExternalFormatANDROID { + VkStructureType sType; + void* pNext{}; + uint64_t externalFormat; + + safe_VkExternalFormatANDROID(const VkExternalFormatANDROID* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkExternalFormatANDROID(const safe_VkExternalFormatANDROID& copy_src); + safe_VkExternalFormatANDROID& operator=(const safe_VkExternalFormatANDROID& copy_src); + safe_VkExternalFormatANDROID(); + ~safe_VkExternalFormatANDROID(); + void initialize(const VkExternalFormatANDROID* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExternalFormatANDROID* copy_src, PNextCopyState* copy_state = {}); + VkExternalFormatANDROID* ptr() { return reinterpret_cast(this); } + VkExternalFormatANDROID const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkAndroidHardwareBufferFormatProperties2ANDROID { + VkStructureType sType; + void* pNext{}; + VkFormat format; + uint64_t externalFormat; + VkFormatFeatureFlags2 formatFeatures; + VkComponentMapping samplerYcbcrConversionComponents; + VkSamplerYcbcrModelConversion suggestedYcbcrModel; + VkSamplerYcbcrRange suggestedYcbcrRange; + VkChromaLocation suggestedXChromaOffset; + VkChromaLocation suggestedYChromaOffset; + + safe_VkAndroidHardwareBufferFormatProperties2ANDROID(const VkAndroidHardwareBufferFormatProperties2ANDROID* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAndroidHardwareBufferFormatProperties2ANDROID(const safe_VkAndroidHardwareBufferFormatProperties2ANDROID& copy_src); + safe_VkAndroidHardwareBufferFormatProperties2ANDROID& operator=( + const safe_VkAndroidHardwareBufferFormatProperties2ANDROID& copy_src); + safe_VkAndroidHardwareBufferFormatProperties2ANDROID(); + ~safe_VkAndroidHardwareBufferFormatProperties2ANDROID(); + void initialize(const VkAndroidHardwareBufferFormatProperties2ANDROID* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAndroidHardwareBufferFormatProperties2ANDROID* copy_src, PNextCopyState* copy_state = {}); + VkAndroidHardwareBufferFormatProperties2ANDROID* ptr() { + return reinterpret_cast(this); + } + VkAndroidHardwareBufferFormatProperties2ANDROID const* ptr() const { + return reinterpret_cast(this); + } +}; +#endif // VK_USE_PLATFORM_ANDROID_KHR +#ifdef VK_ENABLE_BETA_EXTENSIONS +struct safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderEnqueue; + + safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(const VkPhysicalDeviceShaderEnqueueFeaturesAMDX* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(const safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX& copy_src); + safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX& operator=(const safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX& copy_src); + safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(); + ~safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(); + void initialize(const VkPhysicalDeviceShaderEnqueueFeaturesAMDX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderEnqueueFeaturesAMDX* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceShaderEnqueueFeaturesAMDX const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX { + VkStructureType sType; + void* pNext{}; + uint32_t maxExecutionGraphDepth; + uint32_t maxExecutionGraphShaderOutputNodes; + uint32_t maxExecutionGraphShaderPayloadSize; + uint32_t maxExecutionGraphShaderPayloadCount; + uint32_t executionGraphDispatchAddressAlignment; + + safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(const VkPhysicalDeviceShaderEnqueuePropertiesAMDX* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(const safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX& copy_src); + safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX& operator=(const safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX& copy_src); + safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(); + ~safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(); + void initialize(const VkPhysicalDeviceShaderEnqueuePropertiesAMDX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderEnqueuePropertiesAMDX* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderEnqueuePropertiesAMDX const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkExecutionGraphPipelineScratchSizeAMDX { + VkStructureType sType; + void* pNext{}; + VkDeviceSize size; + + safe_VkExecutionGraphPipelineScratchSizeAMDX(const VkExecutionGraphPipelineScratchSizeAMDX* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkExecutionGraphPipelineScratchSizeAMDX(const safe_VkExecutionGraphPipelineScratchSizeAMDX& copy_src); + safe_VkExecutionGraphPipelineScratchSizeAMDX& operator=(const safe_VkExecutionGraphPipelineScratchSizeAMDX& copy_src); + safe_VkExecutionGraphPipelineScratchSizeAMDX(); + ~safe_VkExecutionGraphPipelineScratchSizeAMDX(); + void initialize(const VkExecutionGraphPipelineScratchSizeAMDX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExecutionGraphPipelineScratchSizeAMDX* copy_src, PNextCopyState* copy_state = {}); + VkExecutionGraphPipelineScratchSizeAMDX* ptr() { return reinterpret_cast(this); } + VkExecutionGraphPipelineScratchSizeAMDX const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkExecutionGraphPipelineCreateInfoAMDX { + VkStructureType sType; + const void* pNext{}; + VkPipelineCreateFlags flags; + uint32_t stageCount; + safe_VkPipelineShaderStageCreateInfo* pStages{}; + safe_VkPipelineLibraryCreateInfoKHR* pLibraryInfo{}; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; + + safe_VkExecutionGraphPipelineCreateInfoAMDX(const VkExecutionGraphPipelineCreateInfoAMDX* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkExecutionGraphPipelineCreateInfoAMDX(const safe_VkExecutionGraphPipelineCreateInfoAMDX& copy_src); + safe_VkExecutionGraphPipelineCreateInfoAMDX& operator=(const safe_VkExecutionGraphPipelineCreateInfoAMDX& copy_src); + safe_VkExecutionGraphPipelineCreateInfoAMDX(); + ~safe_VkExecutionGraphPipelineCreateInfoAMDX(); + void initialize(const VkExecutionGraphPipelineCreateInfoAMDX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExecutionGraphPipelineCreateInfoAMDX* copy_src, PNextCopyState* copy_state = {}); + VkExecutionGraphPipelineCreateInfoAMDX* ptr() { return reinterpret_cast(this); } + VkExecutionGraphPipelineCreateInfoAMDX const* ptr() const { + return reinterpret_cast(this); + } +}; +union safe_VkDeviceOrHostAddressConstAMDX { + VkDeviceAddress deviceAddress; + const void* hostAddress{}; + + safe_VkDeviceOrHostAddressConstAMDX(const VkDeviceOrHostAddressConstAMDX* in_struct, PNextCopyState* copy_state = {}); + safe_VkDeviceOrHostAddressConstAMDX(const safe_VkDeviceOrHostAddressConstAMDX& copy_src); + safe_VkDeviceOrHostAddressConstAMDX& operator=(const safe_VkDeviceOrHostAddressConstAMDX& copy_src); + safe_VkDeviceOrHostAddressConstAMDX(); + ~safe_VkDeviceOrHostAddressConstAMDX(); + void initialize(const VkDeviceOrHostAddressConstAMDX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceOrHostAddressConstAMDX* copy_src, PNextCopyState* copy_state = {}); + VkDeviceOrHostAddressConstAMDX* ptr() { return reinterpret_cast(this); } + VkDeviceOrHostAddressConstAMDX const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPipelineShaderStageNodeCreateInfoAMDX { + VkStructureType sType; + const void* pNext{}; + const char* pName{}; + uint32_t index; + + safe_VkPipelineShaderStageNodeCreateInfoAMDX(const VkPipelineShaderStageNodeCreateInfoAMDX* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineShaderStageNodeCreateInfoAMDX(const safe_VkPipelineShaderStageNodeCreateInfoAMDX& copy_src); + safe_VkPipelineShaderStageNodeCreateInfoAMDX& operator=(const safe_VkPipelineShaderStageNodeCreateInfoAMDX& copy_src); + safe_VkPipelineShaderStageNodeCreateInfoAMDX(); + ~safe_VkPipelineShaderStageNodeCreateInfoAMDX(); + void initialize(const VkPipelineShaderStageNodeCreateInfoAMDX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineShaderStageNodeCreateInfoAMDX* copy_src, PNextCopyState* copy_state = {}); + VkPipelineShaderStageNodeCreateInfoAMDX* ptr() { return reinterpret_cast(this); } + VkPipelineShaderStageNodeCreateInfoAMDX const* ptr() const { + return reinterpret_cast(this); + } +}; +#endif // VK_ENABLE_BETA_EXTENSIONS +struct safe_VkSampleLocationsInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkSampleCountFlagBits sampleLocationsPerPixel; + VkExtent2D sampleLocationGridSize; + uint32_t sampleLocationsCount; + const VkSampleLocationEXT* pSampleLocations{}; + + safe_VkSampleLocationsInfoEXT(const VkSampleLocationsInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSampleLocationsInfoEXT(const safe_VkSampleLocationsInfoEXT& copy_src); + safe_VkSampleLocationsInfoEXT& operator=(const safe_VkSampleLocationsInfoEXT& copy_src); + safe_VkSampleLocationsInfoEXT(); + ~safe_VkSampleLocationsInfoEXT(); + void initialize(const VkSampleLocationsInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSampleLocationsInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkSampleLocationsInfoEXT* ptr() { return reinterpret_cast(this); } + VkSampleLocationsInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkRenderPassSampleLocationsBeginInfoEXT { + VkStructureType sType; + const void* pNext{}; + uint32_t attachmentInitialSampleLocationsCount; + const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations{}; + uint32_t postSubpassSampleLocationsCount; + const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations{}; + + safe_VkRenderPassSampleLocationsBeginInfoEXT(const VkRenderPassSampleLocationsBeginInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkRenderPassSampleLocationsBeginInfoEXT(const safe_VkRenderPassSampleLocationsBeginInfoEXT& copy_src); + safe_VkRenderPassSampleLocationsBeginInfoEXT& operator=(const safe_VkRenderPassSampleLocationsBeginInfoEXT& copy_src); + safe_VkRenderPassSampleLocationsBeginInfoEXT(); + ~safe_VkRenderPassSampleLocationsBeginInfoEXT(); + void initialize(const VkRenderPassSampleLocationsBeginInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderPassSampleLocationsBeginInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkRenderPassSampleLocationsBeginInfoEXT* ptr() { return reinterpret_cast(this); } + VkRenderPassSampleLocationsBeginInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineSampleLocationsStateCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkBool32 sampleLocationsEnable; + safe_VkSampleLocationsInfoEXT sampleLocationsInfo; + + safe_VkPipelineSampleLocationsStateCreateInfoEXT(const VkPipelineSampleLocationsStateCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineSampleLocationsStateCreateInfoEXT(const safe_VkPipelineSampleLocationsStateCreateInfoEXT& copy_src); + safe_VkPipelineSampleLocationsStateCreateInfoEXT& operator=(const safe_VkPipelineSampleLocationsStateCreateInfoEXT& copy_src); + safe_VkPipelineSampleLocationsStateCreateInfoEXT(); + ~safe_VkPipelineSampleLocationsStateCreateInfoEXT(); + void initialize(const VkPipelineSampleLocationsStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineSampleLocationsStateCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkPipelineSampleLocationsStateCreateInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkPipelineSampleLocationsStateCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceSampleLocationsPropertiesEXT { + VkStructureType sType; + void* pNext{}; + VkSampleCountFlags sampleLocationSampleCounts; + VkExtent2D maxSampleLocationGridSize; + float sampleLocationCoordinateRange[2]; + uint32_t sampleLocationSubPixelBits; + VkBool32 variableSampleLocations; + + safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(const VkPhysicalDeviceSampleLocationsPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& copy_src); + safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& operator=(const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& copy_src); + safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(); + ~safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(); + void initialize(const VkPhysicalDeviceSampleLocationsPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceSampleLocationsPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceSampleLocationsPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkMultisamplePropertiesEXT { + VkStructureType sType; + void* pNext{}; + VkExtent2D maxSampleLocationGridSize; + + safe_VkMultisamplePropertiesEXT(const VkMultisamplePropertiesEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkMultisamplePropertiesEXT(const safe_VkMultisamplePropertiesEXT& copy_src); + safe_VkMultisamplePropertiesEXT& operator=(const safe_VkMultisamplePropertiesEXT& copy_src); + safe_VkMultisamplePropertiesEXT(); + ~safe_VkMultisamplePropertiesEXT(); + void initialize(const VkMultisamplePropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMultisamplePropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkMultisamplePropertiesEXT* ptr() { return reinterpret_cast(this); } + VkMultisamplePropertiesEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 advancedBlendCoherentOperations; + + safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& copy_src); + safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=( + const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& copy_src); + safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(); + ~safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(); + void initialize(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { + VkStructureType sType; + void* pNext{}; + uint32_t advancedBlendMaxColorAttachments; + VkBool32 advancedBlendIndependentBlend; + VkBool32 advancedBlendNonPremultipliedSrcColor; + VkBool32 advancedBlendNonPremultipliedDstColor; + VkBool32 advancedBlendCorrelatedOverlap; + VkBool32 advancedBlendAllOperations; + + safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT( + const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& copy_src); + safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& operator=( + const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& copy_src); + safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(); + ~safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(); + void initialize(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkBool32 srcPremultiplied; + VkBool32 dstPremultiplied; + VkBlendOverlapEXT blendOverlap; + + safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& copy_src); + safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& operator=( + const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& copy_src); + safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(); + ~safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(); + void initialize(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkPipelineColorBlendAdvancedStateCreateInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkPipelineColorBlendAdvancedStateCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineCoverageToColorStateCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkPipelineCoverageToColorStateCreateFlagsNV flags; + VkBool32 coverageToColorEnable; + uint32_t coverageToColorLocation; + + safe_VkPipelineCoverageToColorStateCreateInfoNV(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineCoverageToColorStateCreateInfoNV(const safe_VkPipelineCoverageToColorStateCreateInfoNV& copy_src); + safe_VkPipelineCoverageToColorStateCreateInfoNV& operator=(const safe_VkPipelineCoverageToColorStateCreateInfoNV& copy_src); + safe_VkPipelineCoverageToColorStateCreateInfoNV(); + ~safe_VkPipelineCoverageToColorStateCreateInfoNV(); + void initialize(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineCoverageToColorStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkPipelineCoverageToColorStateCreateInfoNV* ptr() { + return reinterpret_cast(this); + } + VkPipelineCoverageToColorStateCreateInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineCoverageModulationStateCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkPipelineCoverageModulationStateCreateFlagsNV flags; + VkCoverageModulationModeNV coverageModulationMode; + VkBool32 coverageModulationTableEnable; + uint32_t coverageModulationTableCount; + const float* pCoverageModulationTable{}; + + safe_VkPipelineCoverageModulationStateCreateInfoNV(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineCoverageModulationStateCreateInfoNV(const safe_VkPipelineCoverageModulationStateCreateInfoNV& copy_src); + safe_VkPipelineCoverageModulationStateCreateInfoNV& operator=( + const safe_VkPipelineCoverageModulationStateCreateInfoNV& copy_src); + safe_VkPipelineCoverageModulationStateCreateInfoNV(); + ~safe_VkPipelineCoverageModulationStateCreateInfoNV(); + void initialize(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineCoverageModulationStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkPipelineCoverageModulationStateCreateInfoNV* ptr() { + return reinterpret_cast(this); + } + VkPipelineCoverageModulationStateCreateInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV { + VkStructureType sType; + void* pNext{}; + uint32_t shaderSMCount; + uint32_t shaderWarpsPerSM; + + safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& copy_src); + safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& operator=(const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& copy_src); + safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(); + ~safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(); + void initialize(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderSMBuiltins; + + safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& copy_src); + safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& operator=(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& copy_src); + safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(); + ~safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(); + void initialize(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDrmFormatModifierPropertiesListEXT { + VkStructureType sType; + void* pNext{}; + uint32_t drmFormatModifierCount; + VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties{}; + + safe_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDrmFormatModifierPropertiesListEXT(const safe_VkDrmFormatModifierPropertiesListEXT& copy_src); + safe_VkDrmFormatModifierPropertiesListEXT& operator=(const safe_VkDrmFormatModifierPropertiesListEXT& copy_src); + safe_VkDrmFormatModifierPropertiesListEXT(); + ~safe_VkDrmFormatModifierPropertiesListEXT(); + void initialize(const VkDrmFormatModifierPropertiesListEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDrmFormatModifierPropertiesListEXT* copy_src, PNextCopyState* copy_state = {}); + VkDrmFormatModifierPropertiesListEXT* ptr() { return reinterpret_cast(this); } + VkDrmFormatModifierPropertiesListEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT { + VkStructureType sType; + const void* pNext{}; + uint64_t drmFormatModifier; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices{}; + + safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& copy_src); + safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& operator=( + const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& copy_src); + safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(); + ~safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(); + void initialize(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceImageDrmFormatModifierInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceImageDrmFormatModifierInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImageDrmFormatModifierListCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + uint32_t drmFormatModifierCount; + const uint64_t* pDrmFormatModifiers{}; + + safe_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImageDrmFormatModifierListCreateInfoEXT(const safe_VkImageDrmFormatModifierListCreateInfoEXT& copy_src); + safe_VkImageDrmFormatModifierListCreateInfoEXT& operator=(const safe_VkImageDrmFormatModifierListCreateInfoEXT& copy_src); + safe_VkImageDrmFormatModifierListCreateInfoEXT(); + ~safe_VkImageDrmFormatModifierListCreateInfoEXT(); + void initialize(const VkImageDrmFormatModifierListCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageDrmFormatModifierListCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkImageDrmFormatModifierListCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkImageDrmFormatModifierListCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImageDrmFormatModifierExplicitCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + const VkSubresourceLayout* pPlaneLayouts{}; + + safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& copy_src); + safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& operator=( + const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& copy_src); + safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(); + ~safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(); + void initialize(const VkImageDrmFormatModifierExplicitCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkImageDrmFormatModifierExplicitCreateInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkImageDrmFormatModifierExplicitCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImageDrmFormatModifierPropertiesEXT { + VkStructureType sType; + void* pNext{}; + uint64_t drmFormatModifier; + + safe_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImageDrmFormatModifierPropertiesEXT(const safe_VkImageDrmFormatModifierPropertiesEXT& copy_src); + safe_VkImageDrmFormatModifierPropertiesEXT& operator=(const safe_VkImageDrmFormatModifierPropertiesEXT& copy_src); + safe_VkImageDrmFormatModifierPropertiesEXT(); + ~safe_VkImageDrmFormatModifierPropertiesEXT(); + void initialize(const VkImageDrmFormatModifierPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageDrmFormatModifierPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkImageDrmFormatModifierPropertiesEXT* ptr() { return reinterpret_cast(this); } + VkImageDrmFormatModifierPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDrmFormatModifierPropertiesList2EXT { + VkStructureType sType; + void* pNext{}; + uint32_t drmFormatModifierCount; + VkDrmFormatModifierProperties2EXT* pDrmFormatModifierProperties{}; + + safe_VkDrmFormatModifierPropertiesList2EXT(const VkDrmFormatModifierPropertiesList2EXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDrmFormatModifierPropertiesList2EXT(const safe_VkDrmFormatModifierPropertiesList2EXT& copy_src); + safe_VkDrmFormatModifierPropertiesList2EXT& operator=(const safe_VkDrmFormatModifierPropertiesList2EXT& copy_src); + safe_VkDrmFormatModifierPropertiesList2EXT(); + ~safe_VkDrmFormatModifierPropertiesList2EXT(); + void initialize(const VkDrmFormatModifierPropertiesList2EXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDrmFormatModifierPropertiesList2EXT* copy_src, PNextCopyState* copy_state = {}); + VkDrmFormatModifierPropertiesList2EXT* ptr() { return reinterpret_cast(this); } + VkDrmFormatModifierPropertiesList2EXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkValidationCacheCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkValidationCacheCreateFlagsEXT flags; + size_t initialDataSize; + const void* pInitialData{}; + + safe_VkValidationCacheCreateInfoEXT(const VkValidationCacheCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkValidationCacheCreateInfoEXT(const safe_VkValidationCacheCreateInfoEXT& copy_src); + safe_VkValidationCacheCreateInfoEXT& operator=(const safe_VkValidationCacheCreateInfoEXT& copy_src); + safe_VkValidationCacheCreateInfoEXT(); + ~safe_VkValidationCacheCreateInfoEXT(); + void initialize(const VkValidationCacheCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkValidationCacheCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkValidationCacheCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkValidationCacheCreateInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkShaderModuleValidationCacheCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkValidationCacheEXT validationCache; + + safe_VkShaderModuleValidationCacheCreateInfoEXT(const VkShaderModuleValidationCacheCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkShaderModuleValidationCacheCreateInfoEXT(const safe_VkShaderModuleValidationCacheCreateInfoEXT& copy_src); + safe_VkShaderModuleValidationCacheCreateInfoEXT& operator=(const safe_VkShaderModuleValidationCacheCreateInfoEXT& copy_src); + safe_VkShaderModuleValidationCacheCreateInfoEXT(); + ~safe_VkShaderModuleValidationCacheCreateInfoEXT(); + void initialize(const VkShaderModuleValidationCacheCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkShaderModuleValidationCacheCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkShaderModuleValidationCacheCreateInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkShaderModuleValidationCacheCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkShadingRatePaletteNV { + uint32_t shadingRatePaletteEntryCount; + const VkShadingRatePaletteEntryNV* pShadingRatePaletteEntries{}; + + safe_VkShadingRatePaletteNV(const VkShadingRatePaletteNV* in_struct, PNextCopyState* copy_state = {}); + safe_VkShadingRatePaletteNV(const safe_VkShadingRatePaletteNV& copy_src); + safe_VkShadingRatePaletteNV& operator=(const safe_VkShadingRatePaletteNV& copy_src); + safe_VkShadingRatePaletteNV(); + ~safe_VkShadingRatePaletteNV(); + void initialize(const VkShadingRatePaletteNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkShadingRatePaletteNV* copy_src, PNextCopyState* copy_state = {}); + VkShadingRatePaletteNV* ptr() { return reinterpret_cast(this); } + VkShadingRatePaletteNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPipelineViewportShadingRateImageStateCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkBool32 shadingRateImageEnable; + uint32_t viewportCount; + safe_VkShadingRatePaletteNV* pShadingRatePalettes{}; + + safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(const VkPipelineViewportShadingRateImageStateCreateInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineViewportShadingRateImageStateCreateInfoNV( + const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& copy_src); + safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& operator=( + const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& copy_src); + safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(); + ~safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(); + void initialize(const VkPipelineViewportShadingRateImageStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkPipelineViewportShadingRateImageStateCreateInfoNV* ptr() { + return reinterpret_cast(this); + } + VkPipelineViewportShadingRateImageStateCreateInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShadingRateImageFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 shadingRateImage; + VkBool32 shadingRateCoarseSampleOrder; + + safe_VkPhysicalDeviceShadingRateImageFeaturesNV(const VkPhysicalDeviceShadingRateImageFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShadingRateImageFeaturesNV(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV& copy_src); + safe_VkPhysicalDeviceShadingRateImageFeaturesNV& operator=(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV& copy_src); + safe_VkPhysicalDeviceShadingRateImageFeaturesNV(); + ~safe_VkPhysicalDeviceShadingRateImageFeaturesNV(); + void initialize(const VkPhysicalDeviceShadingRateImageFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShadingRateImageFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShadingRateImageFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShadingRateImagePropertiesNV { + VkStructureType sType; + void* pNext{}; + VkExtent2D shadingRateTexelSize; + uint32_t shadingRatePaletteSize; + uint32_t shadingRateMaxCoarseSamples; + + safe_VkPhysicalDeviceShadingRateImagePropertiesNV(const VkPhysicalDeviceShadingRateImagePropertiesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShadingRateImagePropertiesNV(const safe_VkPhysicalDeviceShadingRateImagePropertiesNV& copy_src); + safe_VkPhysicalDeviceShadingRateImagePropertiesNV& operator=(const safe_VkPhysicalDeviceShadingRateImagePropertiesNV& copy_src); + safe_VkPhysicalDeviceShadingRateImagePropertiesNV(); + ~safe_VkPhysicalDeviceShadingRateImagePropertiesNV(); + void initialize(const VkPhysicalDeviceShadingRateImagePropertiesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShadingRateImagePropertiesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShadingRateImagePropertiesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShadingRateImagePropertiesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkCoarseSampleOrderCustomNV { + VkShadingRatePaletteEntryNV shadingRate; + uint32_t sampleCount; + uint32_t sampleLocationCount; + const VkCoarseSampleLocationNV* pSampleLocations{}; + + safe_VkCoarseSampleOrderCustomNV(const VkCoarseSampleOrderCustomNV* in_struct, PNextCopyState* copy_state = {}); + safe_VkCoarseSampleOrderCustomNV(const safe_VkCoarseSampleOrderCustomNV& copy_src); + safe_VkCoarseSampleOrderCustomNV& operator=(const safe_VkCoarseSampleOrderCustomNV& copy_src); + safe_VkCoarseSampleOrderCustomNV(); + ~safe_VkCoarseSampleOrderCustomNV(); + void initialize(const VkCoarseSampleOrderCustomNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCoarseSampleOrderCustomNV* copy_src, PNextCopyState* copy_state = {}); + VkCoarseSampleOrderCustomNV* ptr() { return reinterpret_cast(this); } + VkCoarseSampleOrderCustomNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkCoarseSampleOrderTypeNV sampleOrderType; + uint32_t customSampleOrderCount; + safe_VkCoarseSampleOrderCustomNV* pCustomSampleOrders{}; + + safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV( + const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& copy_src); + safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=( + const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& copy_src); + safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(); + ~safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(); + void initialize(const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* ptr() { + return reinterpret_cast(this); + } + VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRayTracingShaderGroupCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkRayTracingShaderGroupTypeKHR type; + uint32_t generalShader; + uint32_t closestHitShader; + uint32_t anyHitShader; + uint32_t intersectionShader; + + safe_VkRayTracingShaderGroupCreateInfoNV(const VkRayTracingShaderGroupCreateInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkRayTracingShaderGroupCreateInfoNV(const safe_VkRayTracingShaderGroupCreateInfoNV& copy_src); + safe_VkRayTracingShaderGroupCreateInfoNV& operator=(const safe_VkRayTracingShaderGroupCreateInfoNV& copy_src); + safe_VkRayTracingShaderGroupCreateInfoNV(); + ~safe_VkRayTracingShaderGroupCreateInfoNV(); + void initialize(const VkRayTracingShaderGroupCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRayTracingShaderGroupCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkRayTracingShaderGroupCreateInfoNV* ptr() { return reinterpret_cast(this); } + VkRayTracingShaderGroupCreateInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRayTracingPipelineCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkPipelineCreateFlags flags; + uint32_t stageCount; + safe_VkPipelineShaderStageCreateInfo* pStages{}; + uint32_t groupCount; + safe_VkRayTracingShaderGroupCreateInfoNV* pGroups{}; + uint32_t maxRecursionDepth; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; + + safe_VkRayTracingPipelineCreateInfoNV(const VkRayTracingPipelineCreateInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkRayTracingPipelineCreateInfoNV(const safe_VkRayTracingPipelineCreateInfoNV& copy_src); + safe_VkRayTracingPipelineCreateInfoNV& operator=(const safe_VkRayTracingPipelineCreateInfoNV& copy_src); + safe_VkRayTracingPipelineCreateInfoNV(); + ~safe_VkRayTracingPipelineCreateInfoNV(); + void initialize(const VkRayTracingPipelineCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRayTracingPipelineCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkRayTracingPipelineCreateInfoNV* ptr() { return reinterpret_cast(this); } + VkRayTracingPipelineCreateInfoNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkGeometryTrianglesNV { + VkStructureType sType; + const void* pNext{}; + VkBuffer vertexData; + VkDeviceSize vertexOffset; + uint32_t vertexCount; + VkDeviceSize vertexStride; + VkFormat vertexFormat; + VkBuffer indexData; + VkDeviceSize indexOffset; + uint32_t indexCount; + VkIndexType indexType; + VkBuffer transformData; + VkDeviceSize transformOffset; + + safe_VkGeometryTrianglesNV(const VkGeometryTrianglesNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkGeometryTrianglesNV(const safe_VkGeometryTrianglesNV& copy_src); + safe_VkGeometryTrianglesNV& operator=(const safe_VkGeometryTrianglesNV& copy_src); + safe_VkGeometryTrianglesNV(); + ~safe_VkGeometryTrianglesNV(); + void initialize(const VkGeometryTrianglesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkGeometryTrianglesNV* copy_src, PNextCopyState* copy_state = {}); + VkGeometryTrianglesNV* ptr() { return reinterpret_cast(this); } + VkGeometryTrianglesNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkGeometryAABBNV { + VkStructureType sType; + const void* pNext{}; + VkBuffer aabbData; + uint32_t numAABBs; + uint32_t stride; + VkDeviceSize offset; + + safe_VkGeometryAABBNV(const VkGeometryAABBNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkGeometryAABBNV(const safe_VkGeometryAABBNV& copy_src); + safe_VkGeometryAABBNV& operator=(const safe_VkGeometryAABBNV& copy_src); + safe_VkGeometryAABBNV(); + ~safe_VkGeometryAABBNV(); + void initialize(const VkGeometryAABBNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkGeometryAABBNV* copy_src, PNextCopyState* copy_state = {}); + VkGeometryAABBNV* ptr() { return reinterpret_cast(this); } + VkGeometryAABBNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkGeometryNV { + VkStructureType sType; + const void* pNext{}; + VkGeometryTypeKHR geometryType; + VkGeometryDataNV geometry; + VkGeometryFlagsKHR flags; + + safe_VkGeometryNV(const VkGeometryNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkGeometryNV(const safe_VkGeometryNV& copy_src); + safe_VkGeometryNV& operator=(const safe_VkGeometryNV& copy_src); + safe_VkGeometryNV(); + ~safe_VkGeometryNV(); + void initialize(const VkGeometryNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkGeometryNV* copy_src, PNextCopyState* copy_state = {}); + VkGeometryNV* ptr() { return reinterpret_cast(this); } + VkGeometryNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkAccelerationStructureInfoNV { + VkStructureType sType; + const void* pNext{}; + VkAccelerationStructureTypeNV type; + VkBuildAccelerationStructureFlagsNV flags; + uint32_t instanceCount; + uint32_t geometryCount; + safe_VkGeometryNV* pGeometries{}; + + safe_VkAccelerationStructureInfoNV(const VkAccelerationStructureInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkAccelerationStructureInfoNV(const safe_VkAccelerationStructureInfoNV& copy_src); + safe_VkAccelerationStructureInfoNV& operator=(const safe_VkAccelerationStructureInfoNV& copy_src); + safe_VkAccelerationStructureInfoNV(); + ~safe_VkAccelerationStructureInfoNV(); + void initialize(const VkAccelerationStructureInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkAccelerationStructureInfoNV* ptr() { return reinterpret_cast(this); } + VkAccelerationStructureInfoNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkAccelerationStructureCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkDeviceSize compactedSize; + safe_VkAccelerationStructureInfoNV info; + + safe_VkAccelerationStructureCreateInfoNV(const VkAccelerationStructureCreateInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkAccelerationStructureCreateInfoNV(const safe_VkAccelerationStructureCreateInfoNV& copy_src); + safe_VkAccelerationStructureCreateInfoNV& operator=(const safe_VkAccelerationStructureCreateInfoNV& copy_src); + safe_VkAccelerationStructureCreateInfoNV(); + ~safe_VkAccelerationStructureCreateInfoNV(); + void initialize(const VkAccelerationStructureCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkAccelerationStructureCreateInfoNV* ptr() { return reinterpret_cast(this); } + VkAccelerationStructureCreateInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkBindAccelerationStructureMemoryInfoNV { + VkStructureType sType; + const void* pNext{}; + VkAccelerationStructureNV accelerationStructure; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices{}; + + safe_VkBindAccelerationStructureMemoryInfoNV(const VkBindAccelerationStructureMemoryInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkBindAccelerationStructureMemoryInfoNV(const safe_VkBindAccelerationStructureMemoryInfoNV& copy_src); + safe_VkBindAccelerationStructureMemoryInfoNV& operator=(const safe_VkBindAccelerationStructureMemoryInfoNV& copy_src); + safe_VkBindAccelerationStructureMemoryInfoNV(); + ~safe_VkBindAccelerationStructureMemoryInfoNV(); + void initialize(const VkBindAccelerationStructureMemoryInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBindAccelerationStructureMemoryInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkBindAccelerationStructureMemoryInfoNV* ptr() { return reinterpret_cast(this); } + VkBindAccelerationStructureMemoryInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkWriteDescriptorSetAccelerationStructureNV { + VkStructureType sType; + const void* pNext{}; + uint32_t accelerationStructureCount; + VkAccelerationStructureNV* pAccelerationStructures{}; + + safe_VkWriteDescriptorSetAccelerationStructureNV(const VkWriteDescriptorSetAccelerationStructureNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkWriteDescriptorSetAccelerationStructureNV(const safe_VkWriteDescriptorSetAccelerationStructureNV& copy_src); + safe_VkWriteDescriptorSetAccelerationStructureNV& operator=(const safe_VkWriteDescriptorSetAccelerationStructureNV& copy_src); + safe_VkWriteDescriptorSetAccelerationStructureNV(); + ~safe_VkWriteDescriptorSetAccelerationStructureNV(); + void initialize(const VkWriteDescriptorSetAccelerationStructureNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkWriteDescriptorSetAccelerationStructureNV* copy_src, PNextCopyState* copy_state = {}); + VkWriteDescriptorSetAccelerationStructureNV* ptr() { + return reinterpret_cast(this); + } + VkWriteDescriptorSetAccelerationStructureNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAccelerationStructureMemoryRequirementsInfoNV { + VkStructureType sType; + const void* pNext{}; + VkAccelerationStructureMemoryRequirementsTypeNV type; + VkAccelerationStructureNV accelerationStructure; + + safe_VkAccelerationStructureMemoryRequirementsInfoNV(const VkAccelerationStructureMemoryRequirementsInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAccelerationStructureMemoryRequirementsInfoNV(const safe_VkAccelerationStructureMemoryRequirementsInfoNV& copy_src); + safe_VkAccelerationStructureMemoryRequirementsInfoNV& operator=( + const safe_VkAccelerationStructureMemoryRequirementsInfoNV& copy_src); + safe_VkAccelerationStructureMemoryRequirementsInfoNV(); + ~safe_VkAccelerationStructureMemoryRequirementsInfoNV(); + void initialize(const VkAccelerationStructureMemoryRequirementsInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureMemoryRequirementsInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkAccelerationStructureMemoryRequirementsInfoNV* ptr() { + return reinterpret_cast(this); + } + VkAccelerationStructureMemoryRequirementsInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceRayTracingPropertiesNV { + VkStructureType sType; + void* pNext{}; + uint32_t shaderGroupHandleSize; + uint32_t maxRecursionDepth; + uint32_t maxShaderGroupStride; + uint32_t shaderGroupBaseAlignment; + uint64_t maxGeometryCount; + uint64_t maxInstanceCount; + uint64_t maxTriangleCount; + uint32_t maxDescriptorSetAccelerationStructures; + + safe_VkPhysicalDeviceRayTracingPropertiesNV(const VkPhysicalDeviceRayTracingPropertiesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceRayTracingPropertiesNV(const safe_VkPhysicalDeviceRayTracingPropertiesNV& copy_src); + safe_VkPhysicalDeviceRayTracingPropertiesNV& operator=(const safe_VkPhysicalDeviceRayTracingPropertiesNV& copy_src); + safe_VkPhysicalDeviceRayTracingPropertiesNV(); + ~safe_VkPhysicalDeviceRayTracingPropertiesNV(); + void initialize(const VkPhysicalDeviceRayTracingPropertiesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceRayTracingPropertiesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceRayTracingPropertiesNV* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceRayTracingPropertiesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 representativeFragmentTest; + + safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV( + const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& copy_src); + safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=( + const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& copy_src); + safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(); + ~safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(); + void initialize(const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkBool32 representativeFragmentTestEnable; + + safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV( + const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV( + const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& copy_src); + safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& operator=( + const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& copy_src); + safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(); + ~safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(); + void initialize(const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkPipelineRepresentativeFragmentTestStateCreateInfoNV* ptr() { + return reinterpret_cast(this); + } + VkPipelineRepresentativeFragmentTestStateCreateInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceImageViewImageFormatInfoEXT { + VkStructureType sType; + void* pNext{}; + VkImageViewType imageViewType; + + safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(const VkPhysicalDeviceImageViewImageFormatInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& copy_src); + safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& operator=(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& copy_src); + safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(); + ~safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(); + void initialize(const VkPhysicalDeviceImageViewImageFormatInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceImageViewImageFormatInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceImageViewImageFormatInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkFilterCubicImageViewImageFormatPropertiesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 filterCubic; + VkBool32 filterCubicMinmax; + + safe_VkFilterCubicImageViewImageFormatPropertiesEXT(const VkFilterCubicImageViewImageFormatPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkFilterCubicImageViewImageFormatPropertiesEXT(const safe_VkFilterCubicImageViewImageFormatPropertiesEXT& copy_src); + safe_VkFilterCubicImageViewImageFormatPropertiesEXT& operator=( + const safe_VkFilterCubicImageViewImageFormatPropertiesEXT& copy_src); + safe_VkFilterCubicImageViewImageFormatPropertiesEXT(); + ~safe_VkFilterCubicImageViewImageFormatPropertiesEXT(); + void initialize(const VkFilterCubicImageViewImageFormatPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkFilterCubicImageViewImageFormatPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkFilterCubicImageViewImageFormatPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkFilterCubicImageViewImageFormatPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImportMemoryHostPointerInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkExternalMemoryHandleTypeFlagBits handleType; + void* pHostPointer{}; + + safe_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImportMemoryHostPointerInfoEXT(const safe_VkImportMemoryHostPointerInfoEXT& copy_src); + safe_VkImportMemoryHostPointerInfoEXT& operator=(const safe_VkImportMemoryHostPointerInfoEXT& copy_src); + safe_VkImportMemoryHostPointerInfoEXT(); + ~safe_VkImportMemoryHostPointerInfoEXT(); + void initialize(const VkImportMemoryHostPointerInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImportMemoryHostPointerInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkImportMemoryHostPointerInfoEXT* ptr() { return reinterpret_cast(this); } + VkImportMemoryHostPointerInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkMemoryHostPointerPropertiesEXT { + VkStructureType sType; + void* pNext{}; + uint32_t memoryTypeBits; + + safe_VkMemoryHostPointerPropertiesEXT(const VkMemoryHostPointerPropertiesEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkMemoryHostPointerPropertiesEXT(const safe_VkMemoryHostPointerPropertiesEXT& copy_src); + safe_VkMemoryHostPointerPropertiesEXT& operator=(const safe_VkMemoryHostPointerPropertiesEXT& copy_src); + safe_VkMemoryHostPointerPropertiesEXT(); + ~safe_VkMemoryHostPointerPropertiesEXT(); + void initialize(const VkMemoryHostPointerPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryHostPointerPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkMemoryHostPointerPropertiesEXT* ptr() { return reinterpret_cast(this); } + VkMemoryHostPointerPropertiesEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT { + VkStructureType sType; + void* pNext{}; + VkDeviceSize minImportedHostPointerAlignment; + + safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& copy_src); + safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& operator=( + const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& copy_src); + safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(); + ~safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(); + void initialize(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceExternalMemoryHostPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceExternalMemoryHostPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineCompilerControlCreateInfoAMD { + VkStructureType sType; + const void* pNext{}; + VkPipelineCompilerControlFlagsAMD compilerControlFlags; + + safe_VkPipelineCompilerControlCreateInfoAMD(const VkPipelineCompilerControlCreateInfoAMD* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineCompilerControlCreateInfoAMD(const safe_VkPipelineCompilerControlCreateInfoAMD& copy_src); + safe_VkPipelineCompilerControlCreateInfoAMD& operator=(const safe_VkPipelineCompilerControlCreateInfoAMD& copy_src); + safe_VkPipelineCompilerControlCreateInfoAMD(); + ~safe_VkPipelineCompilerControlCreateInfoAMD(); + void initialize(const VkPipelineCompilerControlCreateInfoAMD* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineCompilerControlCreateInfoAMD* copy_src, PNextCopyState* copy_state = {}); + VkPipelineCompilerControlCreateInfoAMD* ptr() { return reinterpret_cast(this); } + VkPipelineCompilerControlCreateInfoAMD const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderCorePropertiesAMD { + VkStructureType sType; + void* pNext{}; + uint32_t shaderEngineCount; + uint32_t shaderArraysPerEngineCount; + uint32_t computeUnitsPerShaderArray; + uint32_t simdPerComputeUnit; + uint32_t wavefrontsPerSimd; + uint32_t wavefrontSize; + uint32_t sgprsPerSimd; + uint32_t minSgprAllocation; + uint32_t maxSgprAllocation; + uint32_t sgprAllocationGranularity; + uint32_t vgprsPerSimd; + uint32_t minVgprAllocation; + uint32_t maxVgprAllocation; + uint32_t vgprAllocationGranularity; + + safe_VkPhysicalDeviceShaderCorePropertiesAMD(const VkPhysicalDeviceShaderCorePropertiesAMD* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderCorePropertiesAMD(const safe_VkPhysicalDeviceShaderCorePropertiesAMD& copy_src); + safe_VkPhysicalDeviceShaderCorePropertiesAMD& operator=(const safe_VkPhysicalDeviceShaderCorePropertiesAMD& copy_src); + safe_VkPhysicalDeviceShaderCorePropertiesAMD(); + ~safe_VkPhysicalDeviceShaderCorePropertiesAMD(); + void initialize(const VkPhysicalDeviceShaderCorePropertiesAMD* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderCorePropertiesAMD* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderCorePropertiesAMD* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceShaderCorePropertiesAMD const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDeviceMemoryOverallocationCreateInfoAMD { + VkStructureType sType; + const void* pNext{}; + VkMemoryOverallocationBehaviorAMD overallocationBehavior; + + safe_VkDeviceMemoryOverallocationCreateInfoAMD(const VkDeviceMemoryOverallocationCreateInfoAMD* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDeviceMemoryOverallocationCreateInfoAMD(const safe_VkDeviceMemoryOverallocationCreateInfoAMD& copy_src); + safe_VkDeviceMemoryOverallocationCreateInfoAMD& operator=(const safe_VkDeviceMemoryOverallocationCreateInfoAMD& copy_src); + safe_VkDeviceMemoryOverallocationCreateInfoAMD(); + ~safe_VkDeviceMemoryOverallocationCreateInfoAMD(); + void initialize(const VkDeviceMemoryOverallocationCreateInfoAMD* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceMemoryOverallocationCreateInfoAMD* copy_src, PNextCopyState* copy_state = {}); + VkDeviceMemoryOverallocationCreateInfoAMD* ptr() { return reinterpret_cast(this); } + VkDeviceMemoryOverallocationCreateInfoAMD const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT { + VkStructureType sType; + void* pNext{}; + uint32_t maxVertexAttribDivisor; + + safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT( + const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& copy_src); + safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& operator=( + const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& copy_src); + safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(); + ~safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(); + void initialize(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +#ifdef VK_USE_PLATFORM_GGP +struct safe_VkPresentFrameTokenGGP { + VkStructureType sType; + const void* pNext{}; + GgpFrameToken frameToken; + + safe_VkPresentFrameTokenGGP(const VkPresentFrameTokenGGP* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPresentFrameTokenGGP(const safe_VkPresentFrameTokenGGP& copy_src); + safe_VkPresentFrameTokenGGP& operator=(const safe_VkPresentFrameTokenGGP& copy_src); + safe_VkPresentFrameTokenGGP(); + ~safe_VkPresentFrameTokenGGP(); + void initialize(const VkPresentFrameTokenGGP* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPresentFrameTokenGGP* copy_src, PNextCopyState* copy_state = {}); + VkPresentFrameTokenGGP* ptr() { return reinterpret_cast(this); } + VkPresentFrameTokenGGP const* ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_GGP +struct safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 computeDerivativeGroupQuads; + VkBool32 computeDerivativeGroupLinear; + + safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV( + const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& copy_src); + safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=( + const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& copy_src); + safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(); + ~safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(); + void initialize(const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMeshShaderFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 taskShader; + VkBool32 meshShader; + + safe_VkPhysicalDeviceMeshShaderFeaturesNV(const VkPhysicalDeviceMeshShaderFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMeshShaderFeaturesNV(const safe_VkPhysicalDeviceMeshShaderFeaturesNV& copy_src); + safe_VkPhysicalDeviceMeshShaderFeaturesNV& operator=(const safe_VkPhysicalDeviceMeshShaderFeaturesNV& copy_src); + safe_VkPhysicalDeviceMeshShaderFeaturesNV(); + ~safe_VkPhysicalDeviceMeshShaderFeaturesNV(); + void initialize(const VkPhysicalDeviceMeshShaderFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMeshShaderFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMeshShaderFeaturesNV* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMeshShaderFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMeshShaderPropertiesNV { + VkStructureType sType; + void* pNext{}; + uint32_t maxDrawMeshTasksCount; + uint32_t maxTaskWorkGroupInvocations; + uint32_t maxTaskWorkGroupSize[3]; + uint32_t maxTaskTotalMemorySize; + uint32_t maxTaskOutputCount; + uint32_t maxMeshWorkGroupInvocations; + uint32_t maxMeshWorkGroupSize[3]; + uint32_t maxMeshTotalMemorySize; + uint32_t maxMeshOutputVertices; + uint32_t maxMeshOutputPrimitives; + uint32_t maxMeshMultiviewViewCount; + uint32_t meshOutputPerVertexGranularity; + uint32_t meshOutputPerPrimitiveGranularity; + + safe_VkPhysicalDeviceMeshShaderPropertiesNV(const VkPhysicalDeviceMeshShaderPropertiesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMeshShaderPropertiesNV(const safe_VkPhysicalDeviceMeshShaderPropertiesNV& copy_src); + safe_VkPhysicalDeviceMeshShaderPropertiesNV& operator=(const safe_VkPhysicalDeviceMeshShaderPropertiesNV& copy_src); + safe_VkPhysicalDeviceMeshShaderPropertiesNV(); + ~safe_VkPhysicalDeviceMeshShaderPropertiesNV(); + void initialize(const VkPhysicalDeviceMeshShaderPropertiesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMeshShaderPropertiesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMeshShaderPropertiesNV* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMeshShaderPropertiesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 imageFootprint; + + safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(const VkPhysicalDeviceShaderImageFootprintFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& copy_src); + safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& operator=( + const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& copy_src); + safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(); + ~safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(); + void initialize(const VkPhysicalDeviceShaderImageFootprintFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderImageFootprintFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderImageFootprintFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + uint32_t exclusiveScissorCount; + const VkRect2D* pExclusiveScissors{}; + + safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(const VkPipelineViewportExclusiveScissorStateCreateInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV( + const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& copy_src); + safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& operator=( + const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& copy_src); + safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(); + ~safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(); + void initialize(const VkPipelineViewportExclusiveScissorStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkPipelineViewportExclusiveScissorStateCreateInfoNV* ptr() { + return reinterpret_cast(this); + } + VkPipelineViewportExclusiveScissorStateCreateInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceExclusiveScissorFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 exclusiveScissor; + + safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(const VkPhysicalDeviceExclusiveScissorFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& copy_src); + safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& operator=(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& copy_src); + safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(); + ~safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(); + void initialize(const VkPhysicalDeviceExclusiveScissorFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceExclusiveScissorFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceExclusiveScissorFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkQueueFamilyCheckpointPropertiesNV { + VkStructureType sType; + void* pNext{}; + VkPipelineStageFlags checkpointExecutionStageMask; + + safe_VkQueueFamilyCheckpointPropertiesNV(const VkQueueFamilyCheckpointPropertiesNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkQueueFamilyCheckpointPropertiesNV(const safe_VkQueueFamilyCheckpointPropertiesNV& copy_src); + safe_VkQueueFamilyCheckpointPropertiesNV& operator=(const safe_VkQueueFamilyCheckpointPropertiesNV& copy_src); + safe_VkQueueFamilyCheckpointPropertiesNV(); + ~safe_VkQueueFamilyCheckpointPropertiesNV(); + void initialize(const VkQueueFamilyCheckpointPropertiesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkQueueFamilyCheckpointPropertiesNV* copy_src, PNextCopyState* copy_state = {}); + VkQueueFamilyCheckpointPropertiesNV* ptr() { return reinterpret_cast(this); } + VkQueueFamilyCheckpointPropertiesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkCheckpointDataNV { + VkStructureType sType; + void* pNext{}; + VkPipelineStageFlagBits stage; + void* pCheckpointMarker{}; + + safe_VkCheckpointDataNV(const VkCheckpointDataNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkCheckpointDataNV(const safe_VkCheckpointDataNV& copy_src); + safe_VkCheckpointDataNV& operator=(const safe_VkCheckpointDataNV& copy_src); + safe_VkCheckpointDataNV(); + ~safe_VkCheckpointDataNV(); + void initialize(const VkCheckpointDataNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCheckpointDataNV* copy_src, PNextCopyState* copy_state = {}); + VkCheckpointDataNV* ptr() { return reinterpret_cast(this); } + VkCheckpointDataNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderIntegerFunctions2; + + safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( + const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& copy_src); + safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& operator=( + const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& copy_src); + safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(); + ~safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(); + void initialize(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const* ptr() const { + return reinterpret_cast(this); + } +}; +union safe_VkPerformanceValueDataINTEL { + uint32_t value32; + uint64_t value64; + float valueFloat; + VkBool32 valueBool; + const char* valueString{}; + + safe_VkPerformanceValueDataINTEL(const VkPerformanceValueDataINTEL* in_struct, PNextCopyState* copy_state = {}); + safe_VkPerformanceValueDataINTEL(const safe_VkPerformanceValueDataINTEL& copy_src); + safe_VkPerformanceValueDataINTEL& operator=(const safe_VkPerformanceValueDataINTEL& copy_src); + safe_VkPerformanceValueDataINTEL(); + ~safe_VkPerformanceValueDataINTEL(); + void initialize(const VkPerformanceValueDataINTEL* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPerformanceValueDataINTEL* copy_src, PNextCopyState* copy_state = {}); + VkPerformanceValueDataINTEL* ptr() { return reinterpret_cast(this); } + VkPerformanceValueDataINTEL const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkInitializePerformanceApiInfoINTEL { + VkStructureType sType; + const void* pNext{}; + void* pUserData{}; + + safe_VkInitializePerformanceApiInfoINTEL(const VkInitializePerformanceApiInfoINTEL* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkInitializePerformanceApiInfoINTEL(const safe_VkInitializePerformanceApiInfoINTEL& copy_src); + safe_VkInitializePerformanceApiInfoINTEL& operator=(const safe_VkInitializePerformanceApiInfoINTEL& copy_src); + safe_VkInitializePerformanceApiInfoINTEL(); + ~safe_VkInitializePerformanceApiInfoINTEL(); + void initialize(const VkInitializePerformanceApiInfoINTEL* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkInitializePerformanceApiInfoINTEL* copy_src, PNextCopyState* copy_state = {}); + VkInitializePerformanceApiInfoINTEL* ptr() { return reinterpret_cast(this); } + VkInitializePerformanceApiInfoINTEL const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkQueryPoolPerformanceQueryCreateInfoINTEL { + VkStructureType sType; + const void* pNext{}; + VkQueryPoolSamplingModeINTEL performanceCountersSampling; + + safe_VkQueryPoolPerformanceQueryCreateInfoINTEL(const VkQueryPoolPerformanceQueryCreateInfoINTEL* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkQueryPoolPerformanceQueryCreateInfoINTEL(const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL& copy_src); + safe_VkQueryPoolPerformanceQueryCreateInfoINTEL& operator=(const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL& copy_src); + safe_VkQueryPoolPerformanceQueryCreateInfoINTEL(); + ~safe_VkQueryPoolPerformanceQueryCreateInfoINTEL(); + void initialize(const VkQueryPoolPerformanceQueryCreateInfoINTEL* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL* copy_src, PNextCopyState* copy_state = {}); + VkQueryPoolPerformanceQueryCreateInfoINTEL* ptr() { + return reinterpret_cast(this); + } + VkQueryPoolPerformanceQueryCreateInfoINTEL const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPerformanceMarkerInfoINTEL { + VkStructureType sType; + const void* pNext{}; + uint64_t marker; + + safe_VkPerformanceMarkerInfoINTEL(const VkPerformanceMarkerInfoINTEL* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPerformanceMarkerInfoINTEL(const safe_VkPerformanceMarkerInfoINTEL& copy_src); + safe_VkPerformanceMarkerInfoINTEL& operator=(const safe_VkPerformanceMarkerInfoINTEL& copy_src); + safe_VkPerformanceMarkerInfoINTEL(); + ~safe_VkPerformanceMarkerInfoINTEL(); + void initialize(const VkPerformanceMarkerInfoINTEL* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPerformanceMarkerInfoINTEL* copy_src, PNextCopyState* copy_state = {}); + VkPerformanceMarkerInfoINTEL* ptr() { return reinterpret_cast(this); } + VkPerformanceMarkerInfoINTEL const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPerformanceStreamMarkerInfoINTEL { + VkStructureType sType; + const void* pNext{}; + uint32_t marker; + + safe_VkPerformanceStreamMarkerInfoINTEL(const VkPerformanceStreamMarkerInfoINTEL* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPerformanceStreamMarkerInfoINTEL(const safe_VkPerformanceStreamMarkerInfoINTEL& copy_src); + safe_VkPerformanceStreamMarkerInfoINTEL& operator=(const safe_VkPerformanceStreamMarkerInfoINTEL& copy_src); + safe_VkPerformanceStreamMarkerInfoINTEL(); + ~safe_VkPerformanceStreamMarkerInfoINTEL(); + void initialize(const VkPerformanceStreamMarkerInfoINTEL* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPerformanceStreamMarkerInfoINTEL* copy_src, PNextCopyState* copy_state = {}); + VkPerformanceStreamMarkerInfoINTEL* ptr() { return reinterpret_cast(this); } + VkPerformanceStreamMarkerInfoINTEL const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPerformanceOverrideInfoINTEL { + VkStructureType sType; + const void* pNext{}; + VkPerformanceOverrideTypeINTEL type; + VkBool32 enable; + uint64_t parameter; + + safe_VkPerformanceOverrideInfoINTEL(const VkPerformanceOverrideInfoINTEL* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPerformanceOverrideInfoINTEL(const safe_VkPerformanceOverrideInfoINTEL& copy_src); + safe_VkPerformanceOverrideInfoINTEL& operator=(const safe_VkPerformanceOverrideInfoINTEL& copy_src); + safe_VkPerformanceOverrideInfoINTEL(); + ~safe_VkPerformanceOverrideInfoINTEL(); + void initialize(const VkPerformanceOverrideInfoINTEL* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPerformanceOverrideInfoINTEL* copy_src, PNextCopyState* copy_state = {}); + VkPerformanceOverrideInfoINTEL* ptr() { return reinterpret_cast(this); } + VkPerformanceOverrideInfoINTEL const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPerformanceConfigurationAcquireInfoINTEL { + VkStructureType sType; + const void* pNext{}; + VkPerformanceConfigurationTypeINTEL type; + + safe_VkPerformanceConfigurationAcquireInfoINTEL(const VkPerformanceConfigurationAcquireInfoINTEL* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPerformanceConfigurationAcquireInfoINTEL(const safe_VkPerformanceConfigurationAcquireInfoINTEL& copy_src); + safe_VkPerformanceConfigurationAcquireInfoINTEL& operator=(const safe_VkPerformanceConfigurationAcquireInfoINTEL& copy_src); + safe_VkPerformanceConfigurationAcquireInfoINTEL(); + ~safe_VkPerformanceConfigurationAcquireInfoINTEL(); + void initialize(const VkPerformanceConfigurationAcquireInfoINTEL* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPerformanceConfigurationAcquireInfoINTEL* copy_src, PNextCopyState* copy_state = {}); + VkPerformanceConfigurationAcquireInfoINTEL* ptr() { + return reinterpret_cast(this); + } + VkPerformanceConfigurationAcquireInfoINTEL const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDevicePCIBusInfoPropertiesEXT { + VkStructureType sType; + void* pNext{}; + uint32_t pciDomain; + uint32_t pciBus; + uint32_t pciDevice; + uint32_t pciFunction; + + safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(const VkPhysicalDevicePCIBusInfoPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& copy_src); + safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& operator=(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& copy_src); + safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(); + ~safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(); + void initialize(const VkPhysicalDevicePCIBusInfoPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePCIBusInfoPropertiesEXT* ptr() { return reinterpret_cast(this); } + VkPhysicalDevicePCIBusInfoPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD { + VkStructureType sType; + void* pNext{}; + VkBool32 localDimmingSupport; + + safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(const VkDisplayNativeHdrSurfaceCapabilitiesAMD* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& copy_src); + safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& operator=(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& copy_src); + safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(); + ~safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(); + void initialize(const VkDisplayNativeHdrSurfaceCapabilitiesAMD* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD* copy_src, PNextCopyState* copy_state = {}); + VkDisplayNativeHdrSurfaceCapabilitiesAMD* ptr() { return reinterpret_cast(this); } + VkDisplayNativeHdrSurfaceCapabilitiesAMD const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSwapchainDisplayNativeHdrCreateInfoAMD { + VkStructureType sType; + const void* pNext{}; + VkBool32 localDimmingEnable; + + safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(const VkSwapchainDisplayNativeHdrCreateInfoAMD* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& copy_src); + safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& operator=(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& copy_src); + safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(); + ~safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(); + void initialize(const VkSwapchainDisplayNativeHdrCreateInfoAMD* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD* copy_src, PNextCopyState* copy_state = {}); + VkSwapchainDisplayNativeHdrCreateInfoAMD* ptr() { return reinterpret_cast(this); } + VkSwapchainDisplayNativeHdrCreateInfoAMD const* ptr() const { + return reinterpret_cast(this); + } +}; +#ifdef VK_USE_PLATFORM_FUCHSIA +struct safe_VkImagePipeSurfaceCreateInfoFUCHSIA { + VkStructureType sType; + const void* pNext{}; + VkImagePipeSurfaceCreateFlagsFUCHSIA flags; + zx_handle_t imagePipeHandle; + + safe_VkImagePipeSurfaceCreateInfoFUCHSIA(const VkImagePipeSurfaceCreateInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImagePipeSurfaceCreateInfoFUCHSIA(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA& copy_src); + safe_VkImagePipeSurfaceCreateInfoFUCHSIA& operator=(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA& copy_src); + safe_VkImagePipeSurfaceCreateInfoFUCHSIA(); + ~safe_VkImagePipeSurfaceCreateInfoFUCHSIA(); + void initialize(const VkImagePipeSurfaceCreateInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {}); + VkImagePipeSurfaceCreateInfoFUCHSIA* ptr() { return reinterpret_cast(this); } + VkImagePipeSurfaceCreateInfoFUCHSIA const* ptr() const { + return reinterpret_cast(this); + } +}; +#endif // VK_USE_PLATFORM_FUCHSIA +struct safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 fragmentDensityMap; + VkBool32 fragmentDensityMapDynamic; + VkBool32 fragmentDensityMapNonSubsampledImages; + + safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& copy_src); + safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& operator=( + const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& copy_src); + safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(); + ~safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(); + void initialize(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceFragmentDensityMapFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceFragmentDensityMapFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT { + VkStructureType sType; + void* pNext{}; + VkExtent2D minFragmentDensityTexelSize; + VkExtent2D maxFragmentDensityTexelSize; + VkBool32 fragmentDensityInvocations; + + safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& copy_src); + safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& operator=( + const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& copy_src); + safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(); + ~safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(); + void initialize(const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceFragmentDensityMapPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceFragmentDensityMapPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRenderPassFragmentDensityMapCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkAttachmentReference fragmentDensityMapAttachment; + + safe_VkRenderPassFragmentDensityMapCreateInfoEXT(const VkRenderPassFragmentDensityMapCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkRenderPassFragmentDensityMapCreateInfoEXT(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT& copy_src); + safe_VkRenderPassFragmentDensityMapCreateInfoEXT& operator=(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT& copy_src); + safe_VkRenderPassFragmentDensityMapCreateInfoEXT(); + ~safe_VkRenderPassFragmentDensityMapCreateInfoEXT(); + void initialize(const VkRenderPassFragmentDensityMapCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkRenderPassFragmentDensityMapCreateInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkRenderPassFragmentDensityMapCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderCoreProperties2AMD { + VkStructureType sType; + void* pNext{}; + VkShaderCorePropertiesFlagsAMD shaderCoreFeatures; + uint32_t activeComputeUnitCount; + + safe_VkPhysicalDeviceShaderCoreProperties2AMD(const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderCoreProperties2AMD(const safe_VkPhysicalDeviceShaderCoreProperties2AMD& copy_src); + safe_VkPhysicalDeviceShaderCoreProperties2AMD& operator=(const safe_VkPhysicalDeviceShaderCoreProperties2AMD& copy_src); + safe_VkPhysicalDeviceShaderCoreProperties2AMD(); + ~safe_VkPhysicalDeviceShaderCoreProperties2AMD(); + void initialize(const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderCoreProperties2AMD* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderCoreProperties2AMD* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceShaderCoreProperties2AMD const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD { + VkStructureType sType; + void* pNext{}; + VkBool32 deviceCoherentMemory; + + safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& copy_src); + safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& operator=(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& copy_src); + safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(); + ~safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(); + void initialize(const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceCoherentMemoryFeaturesAMD* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceCoherentMemoryFeaturesAMD const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderImageInt64Atomics; + VkBool32 sparseImageInt64Atomics; + + safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& copy_src); + safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& operator=( + const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& copy_src); + safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(); + ~safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(); + void initialize(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT { + VkStructureType sType; + void* pNext{}; + VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS]; + VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS]; + + safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const VkPhysicalDeviceMemoryBudgetPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& copy_src); + safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& operator=(const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& copy_src); + safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(); + ~safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(); + void initialize(const VkPhysicalDeviceMemoryBudgetPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMemoryBudgetPropertiesEXT* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMemoryBudgetPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 memoryPriority; + + safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(const VkPhysicalDeviceMemoryPriorityFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& copy_src); + safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& operator=(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& copy_src); + safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(); + ~safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(); + void initialize(const VkPhysicalDeviceMemoryPriorityFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMemoryPriorityFeaturesEXT* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMemoryPriorityFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkMemoryPriorityAllocateInfoEXT { + VkStructureType sType; + const void* pNext{}; + float priority; + + safe_VkMemoryPriorityAllocateInfoEXT(const VkMemoryPriorityAllocateInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkMemoryPriorityAllocateInfoEXT(const safe_VkMemoryPriorityAllocateInfoEXT& copy_src); + safe_VkMemoryPriorityAllocateInfoEXT& operator=(const safe_VkMemoryPriorityAllocateInfoEXT& copy_src); + safe_VkMemoryPriorityAllocateInfoEXT(); + ~safe_VkMemoryPriorityAllocateInfoEXT(); + void initialize(const VkMemoryPriorityAllocateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryPriorityAllocateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkMemoryPriorityAllocateInfoEXT* ptr() { return reinterpret_cast(this); } + VkMemoryPriorityAllocateInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 dedicatedAllocationImageAliasing; + + safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( + const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( + const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& copy_src); + safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& operator=( + const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& copy_src); + safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(); + ~safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(); + void initialize(const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* copy_src, + PNextCopyState* copy_state = {}); + VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; + + safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& copy_src); + safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& operator=( + const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& copy_src); + safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(); + ~safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(); + void initialize(const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkBufferDeviceAddressCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkDeviceAddress deviceAddress; + + safe_VkBufferDeviceAddressCreateInfoEXT(const VkBufferDeviceAddressCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkBufferDeviceAddressCreateInfoEXT(const safe_VkBufferDeviceAddressCreateInfoEXT& copy_src); + safe_VkBufferDeviceAddressCreateInfoEXT& operator=(const safe_VkBufferDeviceAddressCreateInfoEXT& copy_src); + safe_VkBufferDeviceAddressCreateInfoEXT(); + ~safe_VkBufferDeviceAddressCreateInfoEXT(); + void initialize(const VkBufferDeviceAddressCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBufferDeviceAddressCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkBufferDeviceAddressCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkBufferDeviceAddressCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkValidationFeaturesEXT { + VkStructureType sType; + const void* pNext{}; + uint32_t enabledValidationFeatureCount; + const VkValidationFeatureEnableEXT* pEnabledValidationFeatures{}; + uint32_t disabledValidationFeatureCount; + const VkValidationFeatureDisableEXT* pDisabledValidationFeatures{}; + + safe_VkValidationFeaturesEXT(const VkValidationFeaturesEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkValidationFeaturesEXT(const safe_VkValidationFeaturesEXT& copy_src); + safe_VkValidationFeaturesEXT& operator=(const safe_VkValidationFeaturesEXT& copy_src); + safe_VkValidationFeaturesEXT(); + ~safe_VkValidationFeaturesEXT(); + void initialize(const VkValidationFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkValidationFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkValidationFeaturesEXT* ptr() { return reinterpret_cast(this); } + VkValidationFeaturesEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCooperativeMatrixPropertiesNV { + VkStructureType sType; + void* pNext{}; + uint32_t MSize; + uint32_t NSize; + uint32_t KSize; + VkComponentTypeNV AType; + VkComponentTypeNV BType; + VkComponentTypeNV CType; + VkComponentTypeNV DType; + VkScopeNV scope; + + safe_VkCooperativeMatrixPropertiesNV(const VkCooperativeMatrixPropertiesNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCooperativeMatrixPropertiesNV(const safe_VkCooperativeMatrixPropertiesNV& copy_src); + safe_VkCooperativeMatrixPropertiesNV& operator=(const safe_VkCooperativeMatrixPropertiesNV& copy_src); + safe_VkCooperativeMatrixPropertiesNV(); + ~safe_VkCooperativeMatrixPropertiesNV(); + void initialize(const VkCooperativeMatrixPropertiesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCooperativeMatrixPropertiesNV* copy_src, PNextCopyState* copy_state = {}); + VkCooperativeMatrixPropertiesNV* ptr() { return reinterpret_cast(this); } + VkCooperativeMatrixPropertiesNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 cooperativeMatrix; + VkBool32 cooperativeMatrixRobustBufferAccess; + + safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(const VkPhysicalDeviceCooperativeMatrixFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& copy_src); + safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& operator=(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& copy_src); + safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(); + ~safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(); + void initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceCooperativeMatrixFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceCooperativeMatrixFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV { + VkStructureType sType; + void* pNext{}; + VkShaderStageFlags cooperativeMatrixSupportedStages; + + safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(const VkPhysicalDeviceCooperativeMatrixPropertiesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& copy_src); + safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& operator=( + const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& copy_src); + safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(); + ~safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(); + void initialize(const VkPhysicalDeviceCooperativeMatrixPropertiesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceCooperativeMatrixPropertiesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceCooperativeMatrixPropertiesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 coverageReductionMode; + + safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(const VkPhysicalDeviceCoverageReductionModeFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& copy_src); + safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& operator=( + const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& copy_src); + safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(); + ~safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(); + void initialize(const VkPhysicalDeviceCoverageReductionModeFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceCoverageReductionModeFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceCoverageReductionModeFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineCoverageReductionStateCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkPipelineCoverageReductionStateCreateFlagsNV flags; + VkCoverageReductionModeNV coverageReductionMode; + + safe_VkPipelineCoverageReductionStateCreateInfoNV(const VkPipelineCoverageReductionStateCreateInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineCoverageReductionStateCreateInfoNV(const safe_VkPipelineCoverageReductionStateCreateInfoNV& copy_src); + safe_VkPipelineCoverageReductionStateCreateInfoNV& operator=(const safe_VkPipelineCoverageReductionStateCreateInfoNV& copy_src); + safe_VkPipelineCoverageReductionStateCreateInfoNV(); + ~safe_VkPipelineCoverageReductionStateCreateInfoNV(); + void initialize(const VkPipelineCoverageReductionStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineCoverageReductionStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkPipelineCoverageReductionStateCreateInfoNV* ptr() { + return reinterpret_cast(this); + } + VkPipelineCoverageReductionStateCreateInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkFramebufferMixedSamplesCombinationNV { + VkStructureType sType; + void* pNext{}; + VkCoverageReductionModeNV coverageReductionMode; + VkSampleCountFlagBits rasterizationSamples; + VkSampleCountFlags depthStencilSamples; + VkSampleCountFlags colorSamples; + + safe_VkFramebufferMixedSamplesCombinationNV(const VkFramebufferMixedSamplesCombinationNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkFramebufferMixedSamplesCombinationNV(const safe_VkFramebufferMixedSamplesCombinationNV& copy_src); + safe_VkFramebufferMixedSamplesCombinationNV& operator=(const safe_VkFramebufferMixedSamplesCombinationNV& copy_src); + safe_VkFramebufferMixedSamplesCombinationNV(); + ~safe_VkFramebufferMixedSamplesCombinationNV(); + void initialize(const VkFramebufferMixedSamplesCombinationNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkFramebufferMixedSamplesCombinationNV* copy_src, PNextCopyState* copy_state = {}); + VkFramebufferMixedSamplesCombinationNV* ptr() { return reinterpret_cast(this); } + VkFramebufferMixedSamplesCombinationNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 fragmentShaderSampleInterlock; + VkBool32 fragmentShaderPixelInterlock; + VkBool32 fragmentShaderShadingRateInterlock; + + safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT( + const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& copy_src); + safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& operator=( + const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& copy_src); + safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(); + ~safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(); + void initialize(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 ycbcrImageArrays; + + safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& copy_src); + safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& operator=(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& copy_src); + safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(); + ~safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(); + void initialize(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceProvokingVertexFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 provokingVertexLast; + VkBool32 transformFeedbackPreservesProvokingVertex; + + safe_VkPhysicalDeviceProvokingVertexFeaturesEXT(const VkPhysicalDeviceProvokingVertexFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceProvokingVertexFeaturesEXT(const safe_VkPhysicalDeviceProvokingVertexFeaturesEXT& copy_src); + safe_VkPhysicalDeviceProvokingVertexFeaturesEXT& operator=(const safe_VkPhysicalDeviceProvokingVertexFeaturesEXT& copy_src); + safe_VkPhysicalDeviceProvokingVertexFeaturesEXT(); + ~safe_VkPhysicalDeviceProvokingVertexFeaturesEXT(); + void initialize(const VkPhysicalDeviceProvokingVertexFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceProvokingVertexFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceProvokingVertexFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceProvokingVertexFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceProvokingVertexPropertiesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 provokingVertexModePerPipeline; + VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex; + + safe_VkPhysicalDeviceProvokingVertexPropertiesEXT(const VkPhysicalDeviceProvokingVertexPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceProvokingVertexPropertiesEXT(const safe_VkPhysicalDeviceProvokingVertexPropertiesEXT& copy_src); + safe_VkPhysicalDeviceProvokingVertexPropertiesEXT& operator=(const safe_VkPhysicalDeviceProvokingVertexPropertiesEXT& copy_src); + safe_VkPhysicalDeviceProvokingVertexPropertiesEXT(); + ~safe_VkPhysicalDeviceProvokingVertexPropertiesEXT(); + void initialize(const VkPhysicalDeviceProvokingVertexPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceProvokingVertexPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceProvokingVertexPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceProvokingVertexPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkProvokingVertexModeEXT provokingVertexMode; + + safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT( + const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT( + const safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& copy_src); + safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& operator=( + const safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& copy_src); + safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(); + ~safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(); + void initialize(const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +#ifdef VK_USE_PLATFORM_WIN32_KHR +struct safe_VkSurfaceFullScreenExclusiveInfoEXT { + VkStructureType sType; + void* pNext{}; + VkFullScreenExclusiveEXT fullScreenExclusive; + + safe_VkSurfaceFullScreenExclusiveInfoEXT(const VkSurfaceFullScreenExclusiveInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSurfaceFullScreenExclusiveInfoEXT(const safe_VkSurfaceFullScreenExclusiveInfoEXT& copy_src); + safe_VkSurfaceFullScreenExclusiveInfoEXT& operator=(const safe_VkSurfaceFullScreenExclusiveInfoEXT& copy_src); + safe_VkSurfaceFullScreenExclusiveInfoEXT(); + ~safe_VkSurfaceFullScreenExclusiveInfoEXT(); + void initialize(const VkSurfaceFullScreenExclusiveInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSurfaceFullScreenExclusiveInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkSurfaceFullScreenExclusiveInfoEXT* ptr() { return reinterpret_cast(this); } + VkSurfaceFullScreenExclusiveInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 fullScreenExclusiveSupported; + + safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& copy_src); + safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& operator=(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& copy_src); + safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(); + ~safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(); + void initialize(const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT* copy_src, PNextCopyState* copy_state = {}); + VkSurfaceCapabilitiesFullScreenExclusiveEXT* ptr() { + return reinterpret_cast(this); + } + VkSurfaceCapabilitiesFullScreenExclusiveEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSurfaceFullScreenExclusiveWin32InfoEXT { + VkStructureType sType; + const void* pNext{}; + HMONITOR hmonitor; + + safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& copy_src); + safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& operator=(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& copy_src); + safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(); + ~safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(); + void initialize(const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkSurfaceFullScreenExclusiveWin32InfoEXT* ptr() { return reinterpret_cast(this); } + VkSurfaceFullScreenExclusiveWin32InfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +#endif // VK_USE_PLATFORM_WIN32_KHR +struct safe_VkHeadlessSurfaceCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkHeadlessSurfaceCreateFlagsEXT flags; + + safe_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkHeadlessSurfaceCreateInfoEXT(const safe_VkHeadlessSurfaceCreateInfoEXT& copy_src); + safe_VkHeadlessSurfaceCreateInfoEXT& operator=(const safe_VkHeadlessSurfaceCreateInfoEXT& copy_src); + safe_VkHeadlessSurfaceCreateInfoEXT(); + ~safe_VkHeadlessSurfaceCreateInfoEXT(); + void initialize(const VkHeadlessSurfaceCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkHeadlessSurfaceCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkHeadlessSurfaceCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkHeadlessSurfaceCreateInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderBufferFloat32Atomics; + VkBool32 shaderBufferFloat32AtomicAdd; + VkBool32 shaderBufferFloat64Atomics; + VkBool32 shaderBufferFloat64AtomicAdd; + VkBool32 shaderSharedFloat32Atomics; + VkBool32 shaderSharedFloat32AtomicAdd; + VkBool32 shaderSharedFloat64Atomics; + VkBool32 shaderSharedFloat64AtomicAdd; + VkBool32 shaderImageFloat32Atomics; + VkBool32 shaderImageFloat32AtomicAdd; + VkBool32 sparseImageFloat32Atomics; + VkBool32 sparseImageFloat32AtomicAdd; + + safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& copy_src); + safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& operator=(const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& copy_src); + safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(); + ~safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(); + void initialize(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 extendedDynamicState; + + safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& copy_src); + safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& operator=( + const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& copy_src); + safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(); + ~safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(); + void initialize(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceHostImageCopyFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 hostImageCopy; + + safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(const VkPhysicalDeviceHostImageCopyFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& copy_src); + safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& operator=(const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& copy_src); + safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(); + ~safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(); + void initialize(const VkPhysicalDeviceHostImageCopyFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceHostImageCopyFeaturesEXT* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceHostImageCopyFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceHostImageCopyPropertiesEXT { + VkStructureType sType; + void* pNext{}; + uint32_t copySrcLayoutCount; + VkImageLayout* pCopySrcLayouts{}; + uint32_t copyDstLayoutCount; + VkImageLayout* pCopyDstLayouts{}; + uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE]; + VkBool32 identicalMemoryTypeRequirements; + + safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(const VkPhysicalDeviceHostImageCopyPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& copy_src); + safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& operator=(const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& copy_src); + safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(); + ~safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(); + void initialize(const VkPhysicalDeviceHostImageCopyPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceHostImageCopyPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceHostImageCopyPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkMemoryToImageCopyEXT { + VkStructureType sType; + const void* pNext{}; + const void* pHostPointer{}; + uint32_t memoryRowLength; + uint32_t memoryImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; + + safe_VkMemoryToImageCopyEXT(const VkMemoryToImageCopyEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMemoryToImageCopyEXT(const safe_VkMemoryToImageCopyEXT& copy_src); + safe_VkMemoryToImageCopyEXT& operator=(const safe_VkMemoryToImageCopyEXT& copy_src); + safe_VkMemoryToImageCopyEXT(); + ~safe_VkMemoryToImageCopyEXT(); + void initialize(const VkMemoryToImageCopyEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryToImageCopyEXT* copy_src, PNextCopyState* copy_state = {}); + VkMemoryToImageCopyEXT* ptr() { return reinterpret_cast(this); } + VkMemoryToImageCopyEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImageToMemoryCopyEXT { + VkStructureType sType; + const void* pNext{}; + void* pHostPointer{}; + uint32_t memoryRowLength; + uint32_t memoryImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; + + safe_VkImageToMemoryCopyEXT(const VkImageToMemoryCopyEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImageToMemoryCopyEXT(const safe_VkImageToMemoryCopyEXT& copy_src); + safe_VkImageToMemoryCopyEXT& operator=(const safe_VkImageToMemoryCopyEXT& copy_src); + safe_VkImageToMemoryCopyEXT(); + ~safe_VkImageToMemoryCopyEXT(); + void initialize(const VkImageToMemoryCopyEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageToMemoryCopyEXT* copy_src, PNextCopyState* copy_state = {}); + VkImageToMemoryCopyEXT* ptr() { return reinterpret_cast(this); } + VkImageToMemoryCopyEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCopyMemoryToImageInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkHostImageCopyFlagsEXT flags; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + safe_VkMemoryToImageCopyEXT* pRegions{}; + + safe_VkCopyMemoryToImageInfoEXT(const VkCopyMemoryToImageInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCopyMemoryToImageInfoEXT(const safe_VkCopyMemoryToImageInfoEXT& copy_src); + safe_VkCopyMemoryToImageInfoEXT& operator=(const safe_VkCopyMemoryToImageInfoEXT& copy_src); + safe_VkCopyMemoryToImageInfoEXT(); + ~safe_VkCopyMemoryToImageInfoEXT(); + void initialize(const VkCopyMemoryToImageInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyMemoryToImageInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkCopyMemoryToImageInfoEXT* ptr() { return reinterpret_cast(this); } + VkCopyMemoryToImageInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCopyImageToMemoryInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkHostImageCopyFlagsEXT flags; + VkImage srcImage; + VkImageLayout srcImageLayout; + uint32_t regionCount; + safe_VkImageToMemoryCopyEXT* pRegions{}; + + safe_VkCopyImageToMemoryInfoEXT(const VkCopyImageToMemoryInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCopyImageToMemoryInfoEXT(const safe_VkCopyImageToMemoryInfoEXT& copy_src); + safe_VkCopyImageToMemoryInfoEXT& operator=(const safe_VkCopyImageToMemoryInfoEXT& copy_src); + safe_VkCopyImageToMemoryInfoEXT(); + ~safe_VkCopyImageToMemoryInfoEXT(); + void initialize(const VkCopyImageToMemoryInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyImageToMemoryInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkCopyImageToMemoryInfoEXT* ptr() { return reinterpret_cast(this); } + VkCopyImageToMemoryInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCopyImageToImageInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkHostImageCopyFlagsEXT flags; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + safe_VkImageCopy2* pRegions{}; + + safe_VkCopyImageToImageInfoEXT(const VkCopyImageToImageInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCopyImageToImageInfoEXT(const safe_VkCopyImageToImageInfoEXT& copy_src); + safe_VkCopyImageToImageInfoEXT& operator=(const safe_VkCopyImageToImageInfoEXT& copy_src); + safe_VkCopyImageToImageInfoEXT(); + ~safe_VkCopyImageToImageInfoEXT(); + void initialize(const VkCopyImageToImageInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyImageToImageInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkCopyImageToImageInfoEXT* ptr() { return reinterpret_cast(this); } + VkCopyImageToImageInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkHostImageLayoutTransitionInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkImage image; + VkImageLayout oldLayout; + VkImageLayout newLayout; + VkImageSubresourceRange subresourceRange; + + safe_VkHostImageLayoutTransitionInfoEXT(const VkHostImageLayoutTransitionInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkHostImageLayoutTransitionInfoEXT(const safe_VkHostImageLayoutTransitionInfoEXT& copy_src); + safe_VkHostImageLayoutTransitionInfoEXT& operator=(const safe_VkHostImageLayoutTransitionInfoEXT& copy_src); + safe_VkHostImageLayoutTransitionInfoEXT(); + ~safe_VkHostImageLayoutTransitionInfoEXT(); + void initialize(const VkHostImageLayoutTransitionInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkHostImageLayoutTransitionInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkHostImageLayoutTransitionInfoEXT* ptr() { return reinterpret_cast(this); } + VkHostImageLayoutTransitionInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSubresourceHostMemcpySizeEXT { + VkStructureType sType; + void* pNext{}; + VkDeviceSize size; + + safe_VkSubresourceHostMemcpySizeEXT(const VkSubresourceHostMemcpySizeEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSubresourceHostMemcpySizeEXT(const safe_VkSubresourceHostMemcpySizeEXT& copy_src); + safe_VkSubresourceHostMemcpySizeEXT& operator=(const safe_VkSubresourceHostMemcpySizeEXT& copy_src); + safe_VkSubresourceHostMemcpySizeEXT(); + ~safe_VkSubresourceHostMemcpySizeEXT(); + void initialize(const VkSubresourceHostMemcpySizeEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSubresourceHostMemcpySizeEXT* copy_src, PNextCopyState* copy_state = {}); + VkSubresourceHostMemcpySizeEXT* ptr() { return reinterpret_cast(this); } + VkSubresourceHostMemcpySizeEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkHostImageCopyDevicePerformanceQueryEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 optimalDeviceAccess; + VkBool32 identicalMemoryLayout; + + safe_VkHostImageCopyDevicePerformanceQueryEXT(const VkHostImageCopyDevicePerformanceQueryEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkHostImageCopyDevicePerformanceQueryEXT(const safe_VkHostImageCopyDevicePerformanceQueryEXT& copy_src); + safe_VkHostImageCopyDevicePerformanceQueryEXT& operator=(const safe_VkHostImageCopyDevicePerformanceQueryEXT& copy_src); + safe_VkHostImageCopyDevicePerformanceQueryEXT(); + ~safe_VkHostImageCopyDevicePerformanceQueryEXT(); + void initialize(const VkHostImageCopyDevicePerformanceQueryEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkHostImageCopyDevicePerformanceQueryEXT* copy_src, PNextCopyState* copy_state = {}); + VkHostImageCopyDevicePerformanceQueryEXT* ptr() { return reinterpret_cast(this); } + VkHostImageCopyDevicePerformanceQueryEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 memoryMapPlaced; + VkBool32 memoryMapRangePlaced; + VkBool32 memoryUnmapReserve; + + safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT(const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT(const safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT& copy_src); + safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT& operator=(const safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT& copy_src); + safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT(); + ~safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT(); + void initialize(const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceMapMemoryPlacedFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT { + VkStructureType sType; + void* pNext{}; + VkDeviceSize minPlacedMemoryMapAlignment; + + safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT(const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT(const safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT& copy_src); + safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT& operator=(const safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT& copy_src); + safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT(); + ~safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT(); + void initialize(const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceMapMemoryPlacedPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkMemoryMapPlacedInfoEXT { + VkStructureType sType; + const void* pNext{}; + void* pPlacedAddress{}; + + safe_VkMemoryMapPlacedInfoEXT(const VkMemoryMapPlacedInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkMemoryMapPlacedInfoEXT(const safe_VkMemoryMapPlacedInfoEXT& copy_src); + safe_VkMemoryMapPlacedInfoEXT& operator=(const safe_VkMemoryMapPlacedInfoEXT& copy_src); + safe_VkMemoryMapPlacedInfoEXT(); + ~safe_VkMemoryMapPlacedInfoEXT(); + void initialize(const VkMemoryMapPlacedInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryMapPlacedInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkMemoryMapPlacedInfoEXT* ptr() { return reinterpret_cast(this); } + VkMemoryMapPlacedInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderBufferFloat16Atomics; + VkBool32 shaderBufferFloat16AtomicAdd; + VkBool32 shaderBufferFloat16AtomicMinMax; + VkBool32 shaderBufferFloat32AtomicMinMax; + VkBool32 shaderBufferFloat64AtomicMinMax; + VkBool32 shaderSharedFloat16Atomics; + VkBool32 shaderSharedFloat16AtomicAdd; + VkBool32 shaderSharedFloat16AtomicMinMax; + VkBool32 shaderSharedFloat32AtomicMinMax; + VkBool32 shaderSharedFloat64AtomicMinMax; + VkBool32 shaderImageFloat32AtomicMinMax; + VkBool32 sparseImageFloat32AtomicMinMax; + + safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(const safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& copy_src); + safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& operator=( + const safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& copy_src); + safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(); + ~safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(); + void initialize(const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSurfacePresentModeEXT { + VkStructureType sType; + void* pNext{}; + VkPresentModeKHR presentMode; + + safe_VkSurfacePresentModeEXT(const VkSurfacePresentModeEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSurfacePresentModeEXT(const safe_VkSurfacePresentModeEXT& copy_src); + safe_VkSurfacePresentModeEXT& operator=(const safe_VkSurfacePresentModeEXT& copy_src); + safe_VkSurfacePresentModeEXT(); + ~safe_VkSurfacePresentModeEXT(); + void initialize(const VkSurfacePresentModeEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSurfacePresentModeEXT* copy_src, PNextCopyState* copy_state = {}); + VkSurfacePresentModeEXT* ptr() { return reinterpret_cast(this); } + VkSurfacePresentModeEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSurfacePresentScalingCapabilitiesEXT { + VkStructureType sType; + void* pNext{}; + VkPresentScalingFlagsEXT supportedPresentScaling; + VkPresentGravityFlagsEXT supportedPresentGravityX; + VkPresentGravityFlagsEXT supportedPresentGravityY; + VkExtent2D minScaledImageExtent; + VkExtent2D maxScaledImageExtent; + + safe_VkSurfacePresentScalingCapabilitiesEXT(const VkSurfacePresentScalingCapabilitiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSurfacePresentScalingCapabilitiesEXT(const safe_VkSurfacePresentScalingCapabilitiesEXT& copy_src); + safe_VkSurfacePresentScalingCapabilitiesEXT& operator=(const safe_VkSurfacePresentScalingCapabilitiesEXT& copy_src); + safe_VkSurfacePresentScalingCapabilitiesEXT(); + ~safe_VkSurfacePresentScalingCapabilitiesEXT(); + void initialize(const VkSurfacePresentScalingCapabilitiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSurfacePresentScalingCapabilitiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkSurfacePresentScalingCapabilitiesEXT* ptr() { return reinterpret_cast(this); } + VkSurfacePresentScalingCapabilitiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSurfacePresentModeCompatibilityEXT { + VkStructureType sType; + void* pNext{}; + uint32_t presentModeCount; + VkPresentModeKHR* pPresentModes{}; + + safe_VkSurfacePresentModeCompatibilityEXT(const VkSurfacePresentModeCompatibilityEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSurfacePresentModeCompatibilityEXT(const safe_VkSurfacePresentModeCompatibilityEXT& copy_src); + safe_VkSurfacePresentModeCompatibilityEXT& operator=(const safe_VkSurfacePresentModeCompatibilityEXT& copy_src); + safe_VkSurfacePresentModeCompatibilityEXT(); + ~safe_VkSurfacePresentModeCompatibilityEXT(); + void initialize(const VkSurfacePresentModeCompatibilityEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSurfacePresentModeCompatibilityEXT* copy_src, PNextCopyState* copy_state = {}); + VkSurfacePresentModeCompatibilityEXT* ptr() { return reinterpret_cast(this); } + VkSurfacePresentModeCompatibilityEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 swapchainMaintenance1; + + safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT& copy_src); + safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT& operator=( + const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT& copy_src); + safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(); + ~safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(); + void initialize(const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSwapchainPresentFenceInfoEXT { + VkStructureType sType; + const void* pNext{}; + uint32_t swapchainCount; + VkFence* pFences{}; + + safe_VkSwapchainPresentFenceInfoEXT(const VkSwapchainPresentFenceInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSwapchainPresentFenceInfoEXT(const safe_VkSwapchainPresentFenceInfoEXT& copy_src); + safe_VkSwapchainPresentFenceInfoEXT& operator=(const safe_VkSwapchainPresentFenceInfoEXT& copy_src); + safe_VkSwapchainPresentFenceInfoEXT(); + ~safe_VkSwapchainPresentFenceInfoEXT(); + void initialize(const VkSwapchainPresentFenceInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSwapchainPresentFenceInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkSwapchainPresentFenceInfoEXT* ptr() { return reinterpret_cast(this); } + VkSwapchainPresentFenceInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSwapchainPresentModesCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + uint32_t presentModeCount; + const VkPresentModeKHR* pPresentModes{}; + + safe_VkSwapchainPresentModesCreateInfoEXT(const VkSwapchainPresentModesCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSwapchainPresentModesCreateInfoEXT(const safe_VkSwapchainPresentModesCreateInfoEXT& copy_src); + safe_VkSwapchainPresentModesCreateInfoEXT& operator=(const safe_VkSwapchainPresentModesCreateInfoEXT& copy_src); + safe_VkSwapchainPresentModesCreateInfoEXT(); + ~safe_VkSwapchainPresentModesCreateInfoEXT(); + void initialize(const VkSwapchainPresentModesCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSwapchainPresentModesCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkSwapchainPresentModesCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkSwapchainPresentModesCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSwapchainPresentModeInfoEXT { + VkStructureType sType; + const void* pNext{}; + uint32_t swapchainCount; + const VkPresentModeKHR* pPresentModes{}; + + safe_VkSwapchainPresentModeInfoEXT(const VkSwapchainPresentModeInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSwapchainPresentModeInfoEXT(const safe_VkSwapchainPresentModeInfoEXT& copy_src); + safe_VkSwapchainPresentModeInfoEXT& operator=(const safe_VkSwapchainPresentModeInfoEXT& copy_src); + safe_VkSwapchainPresentModeInfoEXT(); + ~safe_VkSwapchainPresentModeInfoEXT(); + void initialize(const VkSwapchainPresentModeInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSwapchainPresentModeInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkSwapchainPresentModeInfoEXT* ptr() { return reinterpret_cast(this); } + VkSwapchainPresentModeInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSwapchainPresentScalingCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkPresentScalingFlagsEXT scalingBehavior; + VkPresentGravityFlagsEXT presentGravityX; + VkPresentGravityFlagsEXT presentGravityY; + + safe_VkSwapchainPresentScalingCreateInfoEXT(const VkSwapchainPresentScalingCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSwapchainPresentScalingCreateInfoEXT(const safe_VkSwapchainPresentScalingCreateInfoEXT& copy_src); + safe_VkSwapchainPresentScalingCreateInfoEXT& operator=(const safe_VkSwapchainPresentScalingCreateInfoEXT& copy_src); + safe_VkSwapchainPresentScalingCreateInfoEXT(); + ~safe_VkSwapchainPresentScalingCreateInfoEXT(); + void initialize(const VkSwapchainPresentScalingCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSwapchainPresentScalingCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkSwapchainPresentScalingCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkSwapchainPresentScalingCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkReleaseSwapchainImagesInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkSwapchainKHR swapchain; + uint32_t imageIndexCount; + const uint32_t* pImageIndices{}; + + safe_VkReleaseSwapchainImagesInfoEXT(const VkReleaseSwapchainImagesInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkReleaseSwapchainImagesInfoEXT(const safe_VkReleaseSwapchainImagesInfoEXT& copy_src); + safe_VkReleaseSwapchainImagesInfoEXT& operator=(const safe_VkReleaseSwapchainImagesInfoEXT& copy_src); + safe_VkReleaseSwapchainImagesInfoEXT(); + ~safe_VkReleaseSwapchainImagesInfoEXT(); + void initialize(const VkReleaseSwapchainImagesInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkReleaseSwapchainImagesInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkReleaseSwapchainImagesInfoEXT* ptr() { return reinterpret_cast(this); } + VkReleaseSwapchainImagesInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV { + VkStructureType sType; + void* pNext{}; + uint32_t maxGraphicsShaderGroupCount; + uint32_t maxIndirectSequenceCount; + uint32_t maxIndirectCommandsTokenCount; + uint32_t maxIndirectCommandsStreamCount; + uint32_t maxIndirectCommandsTokenOffset; + uint32_t maxIndirectCommandsStreamStride; + uint32_t minSequencesCountBufferOffsetAlignment; + uint32_t minSequencesIndexBufferOffsetAlignment; + uint32_t minIndirectCommandsBufferOffsetAlignment; + + safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& copy_src); + safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& operator=( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& copy_src); + safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(); + ~safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(); + void initialize(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 deviceGeneratedCommands; + + safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& copy_src); + safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& operator=( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& copy_src); + safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(); + ~safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(); + void initialize(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkGraphicsShaderGroupCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + uint32_t stageCount; + safe_VkPipelineShaderStageCreateInfo* pStages{}; + safe_VkPipelineVertexInputStateCreateInfo* pVertexInputState{}; + safe_VkPipelineTessellationStateCreateInfo* pTessellationState{}; + + safe_VkGraphicsShaderGroupCreateInfoNV(const VkGraphicsShaderGroupCreateInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkGraphicsShaderGroupCreateInfoNV(const safe_VkGraphicsShaderGroupCreateInfoNV& copy_src); + safe_VkGraphicsShaderGroupCreateInfoNV& operator=(const safe_VkGraphicsShaderGroupCreateInfoNV& copy_src); + safe_VkGraphicsShaderGroupCreateInfoNV(); + ~safe_VkGraphicsShaderGroupCreateInfoNV(); + void initialize(const VkGraphicsShaderGroupCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkGraphicsShaderGroupCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkGraphicsShaderGroupCreateInfoNV* ptr() { return reinterpret_cast(this); } + VkGraphicsShaderGroupCreateInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkGraphicsPipelineShaderGroupsCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + uint32_t groupCount; + safe_VkGraphicsShaderGroupCreateInfoNV* pGroups{}; + uint32_t pipelineCount; + VkPipeline* pPipelines{}; + + safe_VkGraphicsPipelineShaderGroupsCreateInfoNV(const VkGraphicsPipelineShaderGroupsCreateInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkGraphicsPipelineShaderGroupsCreateInfoNV(const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV& copy_src); + safe_VkGraphicsPipelineShaderGroupsCreateInfoNV& operator=(const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV& copy_src); + safe_VkGraphicsPipelineShaderGroupsCreateInfoNV(); + ~safe_VkGraphicsPipelineShaderGroupsCreateInfoNV(); + void initialize(const VkGraphicsPipelineShaderGroupsCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkGraphicsPipelineShaderGroupsCreateInfoNV* ptr() { + return reinterpret_cast(this); + } + VkGraphicsPipelineShaderGroupsCreateInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkIndirectCommandsLayoutTokenNV { + VkStructureType sType; + const void* pNext{}; + VkIndirectCommandsTokenTypeNV tokenType; + uint32_t stream; + uint32_t offset; + uint32_t vertexBindingUnit; + VkBool32 vertexDynamicStride; + VkPipelineLayout pushconstantPipelineLayout; + VkShaderStageFlags pushconstantShaderStageFlags; + uint32_t pushconstantOffset; + uint32_t pushconstantSize; + VkIndirectStateFlagsNV indirectStateFlags; + uint32_t indexTypeCount; + const VkIndexType* pIndexTypes{}; + const uint32_t* pIndexTypeValues{}; + + safe_VkIndirectCommandsLayoutTokenNV(const VkIndirectCommandsLayoutTokenNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkIndirectCommandsLayoutTokenNV(const safe_VkIndirectCommandsLayoutTokenNV& copy_src); + safe_VkIndirectCommandsLayoutTokenNV& operator=(const safe_VkIndirectCommandsLayoutTokenNV& copy_src); + safe_VkIndirectCommandsLayoutTokenNV(); + ~safe_VkIndirectCommandsLayoutTokenNV(); + void initialize(const VkIndirectCommandsLayoutTokenNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkIndirectCommandsLayoutTokenNV* copy_src, PNextCopyState* copy_state = {}); + VkIndirectCommandsLayoutTokenNV* ptr() { return reinterpret_cast(this); } + VkIndirectCommandsLayoutTokenNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkIndirectCommandsLayoutCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkIndirectCommandsLayoutUsageFlagsNV flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t tokenCount; + safe_VkIndirectCommandsLayoutTokenNV* pTokens{}; + uint32_t streamCount; + const uint32_t* pStreamStrides{}; + + safe_VkIndirectCommandsLayoutCreateInfoNV(const VkIndirectCommandsLayoutCreateInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkIndirectCommandsLayoutCreateInfoNV(const safe_VkIndirectCommandsLayoutCreateInfoNV& copy_src); + safe_VkIndirectCommandsLayoutCreateInfoNV& operator=(const safe_VkIndirectCommandsLayoutCreateInfoNV& copy_src); + safe_VkIndirectCommandsLayoutCreateInfoNV(); + ~safe_VkIndirectCommandsLayoutCreateInfoNV(); + void initialize(const VkIndirectCommandsLayoutCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkIndirectCommandsLayoutCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkIndirectCommandsLayoutCreateInfoNV* ptr() { return reinterpret_cast(this); } + VkIndirectCommandsLayoutCreateInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkGeneratedCommandsInfoNV { + VkStructureType sType; + const void* pNext{}; + VkPipelineBindPoint pipelineBindPoint; + VkPipeline pipeline; + VkIndirectCommandsLayoutNV indirectCommandsLayout; + uint32_t streamCount; + VkIndirectCommandsStreamNV* pStreams{}; + uint32_t sequencesCount; + VkBuffer preprocessBuffer; + VkDeviceSize preprocessOffset; + VkDeviceSize preprocessSize; + VkBuffer sequencesCountBuffer; + VkDeviceSize sequencesCountOffset; + VkBuffer sequencesIndexBuffer; + VkDeviceSize sequencesIndexOffset; + + safe_VkGeneratedCommandsInfoNV(const VkGeneratedCommandsInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkGeneratedCommandsInfoNV(const safe_VkGeneratedCommandsInfoNV& copy_src); + safe_VkGeneratedCommandsInfoNV& operator=(const safe_VkGeneratedCommandsInfoNV& copy_src); + safe_VkGeneratedCommandsInfoNV(); + ~safe_VkGeneratedCommandsInfoNV(); + void initialize(const VkGeneratedCommandsInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkGeneratedCommandsInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkGeneratedCommandsInfoNV* ptr() { return reinterpret_cast(this); } + VkGeneratedCommandsInfoNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkGeneratedCommandsMemoryRequirementsInfoNV { + VkStructureType sType; + const void* pNext{}; + VkPipelineBindPoint pipelineBindPoint; + VkPipeline pipeline; + VkIndirectCommandsLayoutNV indirectCommandsLayout; + uint32_t maxSequencesCount; + + safe_VkGeneratedCommandsMemoryRequirementsInfoNV(const VkGeneratedCommandsMemoryRequirementsInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkGeneratedCommandsMemoryRequirementsInfoNV(const safe_VkGeneratedCommandsMemoryRequirementsInfoNV& copy_src); + safe_VkGeneratedCommandsMemoryRequirementsInfoNV& operator=(const safe_VkGeneratedCommandsMemoryRequirementsInfoNV& copy_src); + safe_VkGeneratedCommandsMemoryRequirementsInfoNV(); + ~safe_VkGeneratedCommandsMemoryRequirementsInfoNV(); + void initialize(const VkGeneratedCommandsMemoryRequirementsInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkGeneratedCommandsMemoryRequirementsInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkGeneratedCommandsMemoryRequirementsInfoNV* ptr() { + return reinterpret_cast(this); + } + VkGeneratedCommandsMemoryRequirementsInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 inheritedViewportScissor2D; + + safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV( + const safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV& copy_src); + safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV& operator=( + const safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV& copy_src); + safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(); + ~safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(); + void initialize(const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceInheritedViewportScissorFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceInheritedViewportScissorFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkCommandBufferInheritanceViewportScissorInfoNV { + VkStructureType sType; + const void* pNext{}; + VkBool32 viewportScissor2D; + uint32_t viewportDepthCount; + const VkViewport* pViewportDepths{}; + + safe_VkCommandBufferInheritanceViewportScissorInfoNV(const VkCommandBufferInheritanceViewportScissorInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkCommandBufferInheritanceViewportScissorInfoNV(const safe_VkCommandBufferInheritanceViewportScissorInfoNV& copy_src); + safe_VkCommandBufferInheritanceViewportScissorInfoNV& operator=( + const safe_VkCommandBufferInheritanceViewportScissorInfoNV& copy_src); + safe_VkCommandBufferInheritanceViewportScissorInfoNV(); + ~safe_VkCommandBufferInheritanceViewportScissorInfoNV(); + void initialize(const VkCommandBufferInheritanceViewportScissorInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCommandBufferInheritanceViewportScissorInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkCommandBufferInheritanceViewportScissorInfoNV* ptr() { + return reinterpret_cast(this); + } + VkCommandBufferInheritanceViewportScissorInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 texelBufferAlignment; + + safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& copy_src); + safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& operator=( + const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& copy_src); + safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(); + ~safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(); + void initialize(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRenderPassTransformBeginInfoQCOM { + VkStructureType sType; + void* pNext{}; + VkSurfaceTransformFlagBitsKHR transform; + + safe_VkRenderPassTransformBeginInfoQCOM(const VkRenderPassTransformBeginInfoQCOM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkRenderPassTransformBeginInfoQCOM(const safe_VkRenderPassTransformBeginInfoQCOM& copy_src); + safe_VkRenderPassTransformBeginInfoQCOM& operator=(const safe_VkRenderPassTransformBeginInfoQCOM& copy_src); + safe_VkRenderPassTransformBeginInfoQCOM(); + ~safe_VkRenderPassTransformBeginInfoQCOM(); + void initialize(const VkRenderPassTransformBeginInfoQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderPassTransformBeginInfoQCOM* copy_src, PNextCopyState* copy_state = {}); + VkRenderPassTransformBeginInfoQCOM* ptr() { return reinterpret_cast(this); } + VkRenderPassTransformBeginInfoQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM { + VkStructureType sType; + void* pNext{}; + VkSurfaceTransformFlagBitsKHR transform; + VkRect2D renderArea; + + safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM( + const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM( + const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM& copy_src); + safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM& operator=( + const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM& copy_src); + safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(); + ~safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(); + void initialize(const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM* copy_src, PNextCopyState* copy_state = {}); + VkCommandBufferInheritanceRenderPassTransformInfoQCOM* ptr() { + return reinterpret_cast(this); + } + VkCommandBufferInheritanceRenderPassTransformInfoQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 depthBiasControl; + VkBool32 leastRepresentableValueForceUnormRepresentation; + VkBool32 floatRepresentation; + VkBool32 depthBiasExact; + + safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT(const VkPhysicalDeviceDepthBiasControlFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT(const safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT& copy_src); + safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT& operator=(const safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT& copy_src); + safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT(); + ~safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT(); + void initialize(const VkPhysicalDeviceDepthBiasControlFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDepthBiasControlFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDepthBiasControlFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDepthBiasInfoEXT { + VkStructureType sType; + const void* pNext{}; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + + safe_VkDepthBiasInfoEXT(const VkDepthBiasInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDepthBiasInfoEXT(const safe_VkDepthBiasInfoEXT& copy_src); + safe_VkDepthBiasInfoEXT& operator=(const safe_VkDepthBiasInfoEXT& copy_src); + safe_VkDepthBiasInfoEXT(); + ~safe_VkDepthBiasInfoEXT(); + void initialize(const VkDepthBiasInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDepthBiasInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkDepthBiasInfoEXT* ptr() { return reinterpret_cast(this); } + VkDepthBiasInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDepthBiasRepresentationInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkDepthBiasRepresentationEXT depthBiasRepresentation; + VkBool32 depthBiasExact; + + safe_VkDepthBiasRepresentationInfoEXT(const VkDepthBiasRepresentationInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDepthBiasRepresentationInfoEXT(const safe_VkDepthBiasRepresentationInfoEXT& copy_src); + safe_VkDepthBiasRepresentationInfoEXT& operator=(const safe_VkDepthBiasRepresentationInfoEXT& copy_src); + safe_VkDepthBiasRepresentationInfoEXT(); + ~safe_VkDepthBiasRepresentationInfoEXT(); + void initialize(const VkDepthBiasRepresentationInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDepthBiasRepresentationInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkDepthBiasRepresentationInfoEXT* ptr() { return reinterpret_cast(this); } + VkDepthBiasRepresentationInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 deviceMemoryReport; + + safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& copy_src); + safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& operator=( + const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& copy_src); + safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(); + ~safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(); + void initialize(const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDeviceMemoryReportCallbackDataEXT { + VkStructureType sType; + void* pNext{}; + VkDeviceMemoryReportFlagsEXT flags; + VkDeviceMemoryReportEventTypeEXT type; + uint64_t memoryObjectId; + VkDeviceSize size; + VkObjectType objectType; + uint64_t objectHandle; + uint32_t heapIndex; + + safe_VkDeviceMemoryReportCallbackDataEXT(const VkDeviceMemoryReportCallbackDataEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDeviceMemoryReportCallbackDataEXT(const safe_VkDeviceMemoryReportCallbackDataEXT& copy_src); + safe_VkDeviceMemoryReportCallbackDataEXT& operator=(const safe_VkDeviceMemoryReportCallbackDataEXT& copy_src); + safe_VkDeviceMemoryReportCallbackDataEXT(); + ~safe_VkDeviceMemoryReportCallbackDataEXT(); + void initialize(const VkDeviceMemoryReportCallbackDataEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceMemoryReportCallbackDataEXT* copy_src, PNextCopyState* copy_state = {}); + VkDeviceMemoryReportCallbackDataEXT* ptr() { return reinterpret_cast(this); } + VkDeviceMemoryReportCallbackDataEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDeviceDeviceMemoryReportCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkDeviceMemoryReportFlagsEXT flags; + PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback; + void* pUserData{}; + + safe_VkDeviceDeviceMemoryReportCreateInfoEXT(const VkDeviceDeviceMemoryReportCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDeviceDeviceMemoryReportCreateInfoEXT(const safe_VkDeviceDeviceMemoryReportCreateInfoEXT& copy_src); + safe_VkDeviceDeviceMemoryReportCreateInfoEXT& operator=(const safe_VkDeviceDeviceMemoryReportCreateInfoEXT& copy_src); + safe_VkDeviceDeviceMemoryReportCreateInfoEXT(); + ~safe_VkDeviceDeviceMemoryReportCreateInfoEXT(); + void initialize(const VkDeviceDeviceMemoryReportCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceDeviceMemoryReportCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkDeviceDeviceMemoryReportCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkDeviceDeviceMemoryReportCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceRobustness2FeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 robustBufferAccess2; + VkBool32 robustImageAccess2; + VkBool32 nullDescriptor; + + safe_VkPhysicalDeviceRobustness2FeaturesEXT(const VkPhysicalDeviceRobustness2FeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceRobustness2FeaturesEXT(const safe_VkPhysicalDeviceRobustness2FeaturesEXT& copy_src); + safe_VkPhysicalDeviceRobustness2FeaturesEXT& operator=(const safe_VkPhysicalDeviceRobustness2FeaturesEXT& copy_src); + safe_VkPhysicalDeviceRobustness2FeaturesEXT(); + ~safe_VkPhysicalDeviceRobustness2FeaturesEXT(); + void initialize(const VkPhysicalDeviceRobustness2FeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceRobustness2FeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceRobustness2FeaturesEXT* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceRobustness2FeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceRobustness2PropertiesEXT { + VkStructureType sType; + void* pNext{}; + VkDeviceSize robustStorageBufferAccessSizeAlignment; + VkDeviceSize robustUniformBufferAccessSizeAlignment; + + safe_VkPhysicalDeviceRobustness2PropertiesEXT(const VkPhysicalDeviceRobustness2PropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceRobustness2PropertiesEXT(const safe_VkPhysicalDeviceRobustness2PropertiesEXT& copy_src); + safe_VkPhysicalDeviceRobustness2PropertiesEXT& operator=(const safe_VkPhysicalDeviceRobustness2PropertiesEXT& copy_src); + safe_VkPhysicalDeviceRobustness2PropertiesEXT(); + ~safe_VkPhysicalDeviceRobustness2PropertiesEXT(); + void initialize(const VkPhysicalDeviceRobustness2PropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceRobustness2PropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceRobustness2PropertiesEXT* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceRobustness2PropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSamplerCustomBorderColorCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkClearColorValue customBorderColor; + VkFormat format; + + safe_VkSamplerCustomBorderColorCreateInfoEXT(const VkSamplerCustomBorderColorCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSamplerCustomBorderColorCreateInfoEXT(const safe_VkSamplerCustomBorderColorCreateInfoEXT& copy_src); + safe_VkSamplerCustomBorderColorCreateInfoEXT& operator=(const safe_VkSamplerCustomBorderColorCreateInfoEXT& copy_src); + safe_VkSamplerCustomBorderColorCreateInfoEXT(); + ~safe_VkSamplerCustomBorderColorCreateInfoEXT(); + void initialize(const VkSamplerCustomBorderColorCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSamplerCustomBorderColorCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkSamplerCustomBorderColorCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkSamplerCustomBorderColorCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT { + VkStructureType sType; + void* pNext{}; + uint32_t maxCustomBorderColorSamplers; + + safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const VkPhysicalDeviceCustomBorderColorPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT& copy_src); + safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT& operator=( + const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT& copy_src); + safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT(); + ~safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT(); + void initialize(const VkPhysicalDeviceCustomBorderColorPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceCustomBorderColorPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceCustomBorderColorPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 customBorderColors; + VkBool32 customBorderColorWithoutFormat; + + safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const VkPhysicalDeviceCustomBorderColorFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT& copy_src); + safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT& operator=(const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT& copy_src); + safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT(); + ~safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT(); + void initialize(const VkPhysicalDeviceCustomBorderColorFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceCustomBorderColorFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceCustomBorderColorFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDevicePresentBarrierFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 presentBarrier; + + safe_VkPhysicalDevicePresentBarrierFeaturesNV(const VkPhysicalDevicePresentBarrierFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePresentBarrierFeaturesNV(const safe_VkPhysicalDevicePresentBarrierFeaturesNV& copy_src); + safe_VkPhysicalDevicePresentBarrierFeaturesNV& operator=(const safe_VkPhysicalDevicePresentBarrierFeaturesNV& copy_src); + safe_VkPhysicalDevicePresentBarrierFeaturesNV(); + ~safe_VkPhysicalDevicePresentBarrierFeaturesNV(); + void initialize(const VkPhysicalDevicePresentBarrierFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePresentBarrierFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePresentBarrierFeaturesNV* ptr() { return reinterpret_cast(this); } + VkPhysicalDevicePresentBarrierFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSurfaceCapabilitiesPresentBarrierNV { + VkStructureType sType; + void* pNext{}; + VkBool32 presentBarrierSupported; + + safe_VkSurfaceCapabilitiesPresentBarrierNV(const VkSurfaceCapabilitiesPresentBarrierNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSurfaceCapabilitiesPresentBarrierNV(const safe_VkSurfaceCapabilitiesPresentBarrierNV& copy_src); + safe_VkSurfaceCapabilitiesPresentBarrierNV& operator=(const safe_VkSurfaceCapabilitiesPresentBarrierNV& copy_src); + safe_VkSurfaceCapabilitiesPresentBarrierNV(); + ~safe_VkSurfaceCapabilitiesPresentBarrierNV(); + void initialize(const VkSurfaceCapabilitiesPresentBarrierNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSurfaceCapabilitiesPresentBarrierNV* copy_src, PNextCopyState* copy_state = {}); + VkSurfaceCapabilitiesPresentBarrierNV* ptr() { return reinterpret_cast(this); } + VkSurfaceCapabilitiesPresentBarrierNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSwapchainPresentBarrierCreateInfoNV { + VkStructureType sType; + void* pNext{}; + VkBool32 presentBarrierEnable; + + safe_VkSwapchainPresentBarrierCreateInfoNV(const VkSwapchainPresentBarrierCreateInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSwapchainPresentBarrierCreateInfoNV(const safe_VkSwapchainPresentBarrierCreateInfoNV& copy_src); + safe_VkSwapchainPresentBarrierCreateInfoNV& operator=(const safe_VkSwapchainPresentBarrierCreateInfoNV& copy_src); + safe_VkSwapchainPresentBarrierCreateInfoNV(); + ~safe_VkSwapchainPresentBarrierCreateInfoNV(); + void initialize(const VkSwapchainPresentBarrierCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSwapchainPresentBarrierCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkSwapchainPresentBarrierCreateInfoNV* ptr() { return reinterpret_cast(this); } + VkSwapchainPresentBarrierCreateInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 diagnosticsConfig; + + safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV& copy_src); + safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV& operator=(const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV& copy_src); + safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(); + ~safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(); + void initialize(const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDiagnosticsConfigFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDiagnosticsConfigFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDeviceDiagnosticsConfigCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkDeviceDiagnosticsConfigFlagsNV flags; + + safe_VkDeviceDiagnosticsConfigCreateInfoNV(const VkDeviceDiagnosticsConfigCreateInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDeviceDiagnosticsConfigCreateInfoNV(const safe_VkDeviceDiagnosticsConfigCreateInfoNV& copy_src); + safe_VkDeviceDiagnosticsConfigCreateInfoNV& operator=(const safe_VkDeviceDiagnosticsConfigCreateInfoNV& copy_src); + safe_VkDeviceDiagnosticsConfigCreateInfoNV(); + ~safe_VkDeviceDiagnosticsConfigCreateInfoNV(); + void initialize(const VkDeviceDiagnosticsConfigCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceDiagnosticsConfigCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkDeviceDiagnosticsConfigCreateInfoNV* ptr() { return reinterpret_cast(this); } + VkDeviceDiagnosticsConfigCreateInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkCudaModuleCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + size_t dataSize; + const void* pData{}; + + safe_VkCudaModuleCreateInfoNV(const VkCudaModuleCreateInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCudaModuleCreateInfoNV(const safe_VkCudaModuleCreateInfoNV& copy_src); + safe_VkCudaModuleCreateInfoNV& operator=(const safe_VkCudaModuleCreateInfoNV& copy_src); + safe_VkCudaModuleCreateInfoNV(); + ~safe_VkCudaModuleCreateInfoNV(); + void initialize(const VkCudaModuleCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCudaModuleCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkCudaModuleCreateInfoNV* ptr() { return reinterpret_cast(this); } + VkCudaModuleCreateInfoNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCudaFunctionCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkCudaModuleNV module; + const char* pName{}; + + safe_VkCudaFunctionCreateInfoNV(const VkCudaFunctionCreateInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCudaFunctionCreateInfoNV(const safe_VkCudaFunctionCreateInfoNV& copy_src); + safe_VkCudaFunctionCreateInfoNV& operator=(const safe_VkCudaFunctionCreateInfoNV& copy_src); + safe_VkCudaFunctionCreateInfoNV(); + ~safe_VkCudaFunctionCreateInfoNV(); + void initialize(const VkCudaFunctionCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCudaFunctionCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkCudaFunctionCreateInfoNV* ptr() { return reinterpret_cast(this); } + VkCudaFunctionCreateInfoNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCudaLaunchInfoNV { + VkStructureType sType; + const void* pNext{}; + VkCudaFunctionNV 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_VkCudaLaunchInfoNV(const VkCudaLaunchInfoNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkCudaLaunchInfoNV(const safe_VkCudaLaunchInfoNV& copy_src); + safe_VkCudaLaunchInfoNV& operator=(const safe_VkCudaLaunchInfoNV& copy_src); + safe_VkCudaLaunchInfoNV(); + ~safe_VkCudaLaunchInfoNV(); + void initialize(const VkCudaLaunchInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCudaLaunchInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkCudaLaunchInfoNV* ptr() { return reinterpret_cast(this); } + VkCudaLaunchInfoNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 cudaKernelLaunchFeatures; + + safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV(const VkPhysicalDeviceCudaKernelLaunchFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV(const safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV& copy_src); + safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV& operator=(const safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV& copy_src); + safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV(); + ~safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV(); + void initialize(const VkPhysicalDeviceCudaKernelLaunchFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceCudaKernelLaunchFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceCudaKernelLaunchFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV { + VkStructureType sType; + void* pNext{}; + uint32_t computeCapabilityMinor; + uint32_t computeCapabilityMajor; + + safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(const VkPhysicalDeviceCudaKernelLaunchPropertiesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(const safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV& copy_src); + safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV& operator=(const safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV& copy_src); + safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(); + ~safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(); + void initialize(const VkPhysicalDeviceCudaKernelLaunchPropertiesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceCudaKernelLaunchPropertiesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceCudaKernelLaunchPropertiesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkQueryLowLatencySupportNV { + VkStructureType sType; + const void* pNext{}; + void* pQueriedLowLatencyData{}; + + safe_VkQueryLowLatencySupportNV(const VkQueryLowLatencySupportNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkQueryLowLatencySupportNV(const safe_VkQueryLowLatencySupportNV& copy_src); + safe_VkQueryLowLatencySupportNV& operator=(const safe_VkQueryLowLatencySupportNV& copy_src); + safe_VkQueryLowLatencySupportNV(); + ~safe_VkQueryLowLatencySupportNV(); + void initialize(const VkQueryLowLatencySupportNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkQueryLowLatencySupportNV* copy_src, PNextCopyState* copy_state = {}); + VkQueryLowLatencySupportNV* ptr() { return reinterpret_cast(this); } + VkQueryLowLatencySupportNV const* ptr() const { return reinterpret_cast(this); } +}; +#ifdef VK_USE_PLATFORM_METAL_EXT +struct safe_VkExportMetalObjectCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkExportMetalObjectTypeFlagBitsEXT exportObjectType; + + safe_VkExportMetalObjectCreateInfoEXT(const VkExportMetalObjectCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExportMetalObjectCreateInfoEXT(const safe_VkExportMetalObjectCreateInfoEXT& copy_src); + safe_VkExportMetalObjectCreateInfoEXT& operator=(const safe_VkExportMetalObjectCreateInfoEXT& copy_src); + safe_VkExportMetalObjectCreateInfoEXT(); + ~safe_VkExportMetalObjectCreateInfoEXT(); + void initialize(const VkExportMetalObjectCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExportMetalObjectCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkExportMetalObjectCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkExportMetalObjectCreateInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkExportMetalObjectsInfoEXT { + VkStructureType sType; + const void* pNext{}; + + safe_VkExportMetalObjectsInfoEXT(const VkExportMetalObjectsInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExportMetalObjectsInfoEXT(const safe_VkExportMetalObjectsInfoEXT& copy_src); + safe_VkExportMetalObjectsInfoEXT& operator=(const safe_VkExportMetalObjectsInfoEXT& copy_src); + safe_VkExportMetalObjectsInfoEXT(); + ~safe_VkExportMetalObjectsInfoEXT(); + void initialize(const VkExportMetalObjectsInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExportMetalObjectsInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkExportMetalObjectsInfoEXT* ptr() { return reinterpret_cast(this); } + VkExportMetalObjectsInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkExportMetalDeviceInfoEXT { + VkStructureType sType; + const void* pNext{}; + MTLDevice_id mtlDevice; + + safe_VkExportMetalDeviceInfoEXT(const VkExportMetalDeviceInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExportMetalDeviceInfoEXT(const safe_VkExportMetalDeviceInfoEXT& copy_src); + safe_VkExportMetalDeviceInfoEXT& operator=(const safe_VkExportMetalDeviceInfoEXT& copy_src); + safe_VkExportMetalDeviceInfoEXT(); + ~safe_VkExportMetalDeviceInfoEXT(); + void initialize(const VkExportMetalDeviceInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExportMetalDeviceInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkExportMetalDeviceInfoEXT* ptr() { return reinterpret_cast(this); } + VkExportMetalDeviceInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkExportMetalCommandQueueInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkQueue queue; + MTLCommandQueue_id mtlCommandQueue; + + safe_VkExportMetalCommandQueueInfoEXT(const VkExportMetalCommandQueueInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExportMetalCommandQueueInfoEXT(const safe_VkExportMetalCommandQueueInfoEXT& copy_src); + safe_VkExportMetalCommandQueueInfoEXT& operator=(const safe_VkExportMetalCommandQueueInfoEXT& copy_src); + safe_VkExportMetalCommandQueueInfoEXT(); + ~safe_VkExportMetalCommandQueueInfoEXT(); + void initialize(const VkExportMetalCommandQueueInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExportMetalCommandQueueInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkExportMetalCommandQueueInfoEXT* ptr() { return reinterpret_cast(this); } + VkExportMetalCommandQueueInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkExportMetalBufferInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkDeviceMemory memory; + MTLBuffer_id mtlBuffer; + + safe_VkExportMetalBufferInfoEXT(const VkExportMetalBufferInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExportMetalBufferInfoEXT(const safe_VkExportMetalBufferInfoEXT& copy_src); + safe_VkExportMetalBufferInfoEXT& operator=(const safe_VkExportMetalBufferInfoEXT& copy_src); + safe_VkExportMetalBufferInfoEXT(); + ~safe_VkExportMetalBufferInfoEXT(); + void initialize(const VkExportMetalBufferInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExportMetalBufferInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkExportMetalBufferInfoEXT* ptr() { return reinterpret_cast(this); } + VkExportMetalBufferInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImportMetalBufferInfoEXT { + VkStructureType sType; + const void* pNext{}; + MTLBuffer_id mtlBuffer; + + safe_VkImportMetalBufferInfoEXT(const VkImportMetalBufferInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImportMetalBufferInfoEXT(const safe_VkImportMetalBufferInfoEXT& copy_src); + safe_VkImportMetalBufferInfoEXT& operator=(const safe_VkImportMetalBufferInfoEXT& copy_src); + safe_VkImportMetalBufferInfoEXT(); + ~safe_VkImportMetalBufferInfoEXT(); + void initialize(const VkImportMetalBufferInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImportMetalBufferInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkImportMetalBufferInfoEXT* ptr() { return reinterpret_cast(this); } + VkImportMetalBufferInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkExportMetalTextureInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkImage image; + VkImageView imageView; + VkBufferView bufferView; + VkImageAspectFlagBits plane; + MTLTexture_id mtlTexture; + + safe_VkExportMetalTextureInfoEXT(const VkExportMetalTextureInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExportMetalTextureInfoEXT(const safe_VkExportMetalTextureInfoEXT& copy_src); + safe_VkExportMetalTextureInfoEXT& operator=(const safe_VkExportMetalTextureInfoEXT& copy_src); + safe_VkExportMetalTextureInfoEXT(); + ~safe_VkExportMetalTextureInfoEXT(); + void initialize(const VkExportMetalTextureInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExportMetalTextureInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkExportMetalTextureInfoEXT* ptr() { return reinterpret_cast(this); } + VkExportMetalTextureInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImportMetalTextureInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkImageAspectFlagBits plane; + MTLTexture_id mtlTexture; + + safe_VkImportMetalTextureInfoEXT(const VkImportMetalTextureInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImportMetalTextureInfoEXT(const safe_VkImportMetalTextureInfoEXT& copy_src); + safe_VkImportMetalTextureInfoEXT& operator=(const safe_VkImportMetalTextureInfoEXT& copy_src); + safe_VkImportMetalTextureInfoEXT(); + ~safe_VkImportMetalTextureInfoEXT(); + void initialize(const VkImportMetalTextureInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImportMetalTextureInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkImportMetalTextureInfoEXT* ptr() { return reinterpret_cast(this); } + VkImportMetalTextureInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkExportMetalIOSurfaceInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkImage image; + IOSurfaceRef ioSurface; + + safe_VkExportMetalIOSurfaceInfoEXT(const VkExportMetalIOSurfaceInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExportMetalIOSurfaceInfoEXT(const safe_VkExportMetalIOSurfaceInfoEXT& copy_src); + safe_VkExportMetalIOSurfaceInfoEXT& operator=(const safe_VkExportMetalIOSurfaceInfoEXT& copy_src); + safe_VkExportMetalIOSurfaceInfoEXT(); + ~safe_VkExportMetalIOSurfaceInfoEXT(); + void initialize(const VkExportMetalIOSurfaceInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExportMetalIOSurfaceInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkExportMetalIOSurfaceInfoEXT* ptr() { return reinterpret_cast(this); } + VkExportMetalIOSurfaceInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImportMetalIOSurfaceInfoEXT { + VkStructureType sType; + const void* pNext{}; + IOSurfaceRef ioSurface; + + safe_VkImportMetalIOSurfaceInfoEXT(const VkImportMetalIOSurfaceInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImportMetalIOSurfaceInfoEXT(const safe_VkImportMetalIOSurfaceInfoEXT& copy_src); + safe_VkImportMetalIOSurfaceInfoEXT& operator=(const safe_VkImportMetalIOSurfaceInfoEXT& copy_src); + safe_VkImportMetalIOSurfaceInfoEXT(); + ~safe_VkImportMetalIOSurfaceInfoEXT(); + void initialize(const VkImportMetalIOSurfaceInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImportMetalIOSurfaceInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkImportMetalIOSurfaceInfoEXT* ptr() { return reinterpret_cast(this); } + VkImportMetalIOSurfaceInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkExportMetalSharedEventInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkSemaphore semaphore; + VkEvent event; + MTLSharedEvent_id mtlSharedEvent; + + safe_VkExportMetalSharedEventInfoEXT(const VkExportMetalSharedEventInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkExportMetalSharedEventInfoEXT(const safe_VkExportMetalSharedEventInfoEXT& copy_src); + safe_VkExportMetalSharedEventInfoEXT& operator=(const safe_VkExportMetalSharedEventInfoEXT& copy_src); + safe_VkExportMetalSharedEventInfoEXT(); + ~safe_VkExportMetalSharedEventInfoEXT(); + void initialize(const VkExportMetalSharedEventInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExportMetalSharedEventInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkExportMetalSharedEventInfoEXT* ptr() { return reinterpret_cast(this); } + VkExportMetalSharedEventInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImportMetalSharedEventInfoEXT { + VkStructureType sType; + const void* pNext{}; + MTLSharedEvent_id mtlSharedEvent; + + safe_VkImportMetalSharedEventInfoEXT(const VkImportMetalSharedEventInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImportMetalSharedEventInfoEXT(const safe_VkImportMetalSharedEventInfoEXT& copy_src); + safe_VkImportMetalSharedEventInfoEXT& operator=(const safe_VkImportMetalSharedEventInfoEXT& copy_src); + safe_VkImportMetalSharedEventInfoEXT(); + ~safe_VkImportMetalSharedEventInfoEXT(); + void initialize(const VkImportMetalSharedEventInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImportMetalSharedEventInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkImportMetalSharedEventInfoEXT* ptr() { return reinterpret_cast(this); } + VkImportMetalSharedEventInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_METAL_EXT +struct safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 combinedImageSamplerDescriptorSingleArray; + VkBool32 bufferlessPushDescriptors; + VkBool32 allowSamplerImageViewPostSubmitCreation; + VkDeviceSize descriptorBufferOffsetAlignment; + uint32_t maxDescriptorBufferBindings; + uint32_t maxResourceDescriptorBufferBindings; + uint32_t maxSamplerDescriptorBufferBindings; + uint32_t maxEmbeddedImmutableSamplerBindings; + uint32_t maxEmbeddedImmutableSamplers; + size_t bufferCaptureReplayDescriptorDataSize; + size_t imageCaptureReplayDescriptorDataSize; + size_t imageViewCaptureReplayDescriptorDataSize; + size_t samplerCaptureReplayDescriptorDataSize; + size_t accelerationStructureCaptureReplayDescriptorDataSize; + size_t samplerDescriptorSize; + size_t combinedImageSamplerDescriptorSize; + size_t sampledImageDescriptorSize; + size_t storageImageDescriptorSize; + size_t uniformTexelBufferDescriptorSize; + size_t robustUniformTexelBufferDescriptorSize; + size_t storageTexelBufferDescriptorSize; + size_t robustStorageTexelBufferDescriptorSize; + size_t uniformBufferDescriptorSize; + size_t robustUniformBufferDescriptorSize; + size_t storageBufferDescriptorSize; + size_t robustStorageBufferDescriptorSize; + size_t inputAttachmentDescriptorSize; + size_t accelerationStructureDescriptorSize; + VkDeviceSize maxSamplerDescriptorBufferRange; + VkDeviceSize maxResourceDescriptorBufferRange; + VkDeviceSize samplerDescriptorBufferAddressSpaceSize; + VkDeviceSize resourceDescriptorBufferAddressSpaceSize; + VkDeviceSize descriptorBufferAddressSpaceSize; + + safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT(const VkPhysicalDeviceDescriptorBufferPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT(const safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT& copy_src); + safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT& operator=( + const safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT& copy_src); + safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT(); + ~safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT(); + void initialize(const VkPhysicalDeviceDescriptorBufferPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDescriptorBufferPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDescriptorBufferPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT { + VkStructureType sType; + void* pNext{}; + size_t combinedImageSamplerDensityMapDescriptorSize; + + safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT( + const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT( + const safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& copy_src); + safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& operator=( + const safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& copy_src); + safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(); + ~safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(); + void initialize(const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 descriptorBuffer; + VkBool32 descriptorBufferCaptureReplay; + VkBool32 descriptorBufferImageLayoutIgnored; + VkBool32 descriptorBufferPushDescriptors; + + safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT(const VkPhysicalDeviceDescriptorBufferFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT(const safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT& copy_src); + safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT& operator=(const safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT& copy_src); + safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT(); + ~safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT(); + void initialize(const VkPhysicalDeviceDescriptorBufferFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDescriptorBufferFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDescriptorBufferFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDescriptorAddressInfoEXT { + VkStructureType sType; + void* pNext{}; + VkDeviceAddress address; + VkDeviceSize range; + VkFormat format; + + safe_VkDescriptorAddressInfoEXT(const VkDescriptorAddressInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDescriptorAddressInfoEXT(const safe_VkDescriptorAddressInfoEXT& copy_src); + safe_VkDescriptorAddressInfoEXT& operator=(const safe_VkDescriptorAddressInfoEXT& copy_src); + safe_VkDescriptorAddressInfoEXT(); + ~safe_VkDescriptorAddressInfoEXT(); + void initialize(const VkDescriptorAddressInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDescriptorAddressInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkDescriptorAddressInfoEXT* ptr() { return reinterpret_cast(this); } + VkDescriptorAddressInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDescriptorBufferBindingInfoEXT { + VkStructureType sType; + void* pNext{}; + VkDeviceAddress address; + VkBufferUsageFlags usage; + + safe_VkDescriptorBufferBindingInfoEXT(const VkDescriptorBufferBindingInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDescriptorBufferBindingInfoEXT(const safe_VkDescriptorBufferBindingInfoEXT& copy_src); + safe_VkDescriptorBufferBindingInfoEXT& operator=(const safe_VkDescriptorBufferBindingInfoEXT& copy_src); + safe_VkDescriptorBufferBindingInfoEXT(); + ~safe_VkDescriptorBufferBindingInfoEXT(); + void initialize(const VkDescriptorBufferBindingInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDescriptorBufferBindingInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkDescriptorBufferBindingInfoEXT* ptr() { return reinterpret_cast(this); } + VkDescriptorBufferBindingInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT { + VkStructureType sType; + void* pNext{}; + VkBuffer buffer; + + safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT( + const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT( + const safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT& copy_src); + safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT& operator=( + const safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT& copy_src); + safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(); + ~safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(); + void initialize(const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* copy_src, PNextCopyState* copy_state = {}); + VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* ptr() { + return reinterpret_cast(this); + } + VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +union safe_VkDescriptorDataEXT { + const VkSampler* pSampler{}; + const VkDescriptorImageInfo* pCombinedImageSampler; + const VkDescriptorImageInfo* pInputAttachmentImage; + const VkDescriptorImageInfo* pSampledImage; + const VkDescriptorImageInfo* pStorageImage; + safe_VkDescriptorAddressInfoEXT* pUniformTexelBuffer; + safe_VkDescriptorAddressInfoEXT* pStorageTexelBuffer; + safe_VkDescriptorAddressInfoEXT* pUniformBuffer; + safe_VkDescriptorAddressInfoEXT* pStorageBuffer; + VkDeviceAddress accelerationStructure; + char type_at_end[sizeof(VkDescriptorDataEXT) + sizeof(VkDescriptorGetInfoEXT::type)]; + safe_VkDescriptorDataEXT(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type, PNextCopyState* copy_state = {}); + safe_VkDescriptorDataEXT(const safe_VkDescriptorDataEXT& copy_src); + safe_VkDescriptorDataEXT& operator=(const safe_VkDescriptorDataEXT& copy_src); + safe_VkDescriptorDataEXT(); + ~safe_VkDescriptorDataEXT(); + void initialize(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDescriptorDataEXT* copy_src, PNextCopyState* copy_state = {}); + VkDescriptorDataEXT* ptr() { return reinterpret_cast(this); } + VkDescriptorDataEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDescriptorGetInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkDescriptorType type; + safe_VkDescriptorDataEXT data; + + safe_VkDescriptorGetInfoEXT(const VkDescriptorGetInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDescriptorGetInfoEXT(const safe_VkDescriptorGetInfoEXT& copy_src); + safe_VkDescriptorGetInfoEXT& operator=(const safe_VkDescriptorGetInfoEXT& copy_src); + safe_VkDescriptorGetInfoEXT(); + ~safe_VkDescriptorGetInfoEXT(); + void initialize(const VkDescriptorGetInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDescriptorGetInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkDescriptorGetInfoEXT* ptr() { return reinterpret_cast(this); } + VkDescriptorGetInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkBufferCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkBuffer buffer; + + safe_VkBufferCaptureDescriptorDataInfoEXT(const VkBufferCaptureDescriptorDataInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkBufferCaptureDescriptorDataInfoEXT(const safe_VkBufferCaptureDescriptorDataInfoEXT& copy_src); + safe_VkBufferCaptureDescriptorDataInfoEXT& operator=(const safe_VkBufferCaptureDescriptorDataInfoEXT& copy_src); + safe_VkBufferCaptureDescriptorDataInfoEXT(); + ~safe_VkBufferCaptureDescriptorDataInfoEXT(); + void initialize(const VkBufferCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBufferCaptureDescriptorDataInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkBufferCaptureDescriptorDataInfoEXT* ptr() { return reinterpret_cast(this); } + VkBufferCaptureDescriptorDataInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImageCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkImage image; + + safe_VkImageCaptureDescriptorDataInfoEXT(const VkImageCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImageCaptureDescriptorDataInfoEXT(const safe_VkImageCaptureDescriptorDataInfoEXT& copy_src); + safe_VkImageCaptureDescriptorDataInfoEXT& operator=(const safe_VkImageCaptureDescriptorDataInfoEXT& copy_src); + safe_VkImageCaptureDescriptorDataInfoEXT(); + ~safe_VkImageCaptureDescriptorDataInfoEXT(); + void initialize(const VkImageCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageCaptureDescriptorDataInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkImageCaptureDescriptorDataInfoEXT* ptr() { return reinterpret_cast(this); } + VkImageCaptureDescriptorDataInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImageViewCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkImageView imageView; + + safe_VkImageViewCaptureDescriptorDataInfoEXT(const VkImageViewCaptureDescriptorDataInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImageViewCaptureDescriptorDataInfoEXT(const safe_VkImageViewCaptureDescriptorDataInfoEXT& copy_src); + safe_VkImageViewCaptureDescriptorDataInfoEXT& operator=(const safe_VkImageViewCaptureDescriptorDataInfoEXT& copy_src); + safe_VkImageViewCaptureDescriptorDataInfoEXT(); + ~safe_VkImageViewCaptureDescriptorDataInfoEXT(); + void initialize(const VkImageViewCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageViewCaptureDescriptorDataInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkImageViewCaptureDescriptorDataInfoEXT* ptr() { return reinterpret_cast(this); } + VkImageViewCaptureDescriptorDataInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSamplerCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkSampler sampler; + + safe_VkSamplerCaptureDescriptorDataInfoEXT(const VkSamplerCaptureDescriptorDataInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSamplerCaptureDescriptorDataInfoEXT(const safe_VkSamplerCaptureDescriptorDataInfoEXT& copy_src); + safe_VkSamplerCaptureDescriptorDataInfoEXT& operator=(const safe_VkSamplerCaptureDescriptorDataInfoEXT& copy_src); + safe_VkSamplerCaptureDescriptorDataInfoEXT(); + ~safe_VkSamplerCaptureDescriptorDataInfoEXT(); + void initialize(const VkSamplerCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSamplerCaptureDescriptorDataInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkSamplerCaptureDescriptorDataInfoEXT* ptr() { return reinterpret_cast(this); } + VkSamplerCaptureDescriptorDataInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + const void* opaqueCaptureDescriptorData{}; + + safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT(const VkOpaqueCaptureDescriptorDataCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT(const safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT& copy_src); + safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT& operator=(const safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT& copy_src); + safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT(); + ~safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT(); + void initialize(const VkOpaqueCaptureDescriptorDataCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkOpaqueCaptureDescriptorDataCreateInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkOpaqueCaptureDescriptorDataCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkAccelerationStructureKHR accelerationStructure; + VkAccelerationStructureNV accelerationStructureNV; + + safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT(const VkAccelerationStructureCaptureDescriptorDataInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT( + const safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT& copy_src); + safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT& operator=( + const safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT& copy_src); + safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT(); + ~safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT(); + void initialize(const VkAccelerationStructureCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkAccelerationStructureCaptureDescriptorDataInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkAccelerationStructureCaptureDescriptorDataInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 graphicsPipelineLibrary; + + safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT( + const safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& copy_src); + safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& operator=( + const safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& copy_src); + safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(); + ~safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(); + void initialize(const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 graphicsPipelineLibraryFastLinking; + VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration; + + safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT( + const safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& copy_src); + safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& operator=( + const safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& copy_src); + safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(); + ~safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(); + void initialize(const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkGraphicsPipelineLibraryCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkGraphicsPipelineLibraryFlagsEXT flags; + + safe_VkGraphicsPipelineLibraryCreateInfoEXT(const VkGraphicsPipelineLibraryCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkGraphicsPipelineLibraryCreateInfoEXT(const safe_VkGraphicsPipelineLibraryCreateInfoEXT& copy_src); + safe_VkGraphicsPipelineLibraryCreateInfoEXT& operator=(const safe_VkGraphicsPipelineLibraryCreateInfoEXT& copy_src); + safe_VkGraphicsPipelineLibraryCreateInfoEXT(); + ~safe_VkGraphicsPipelineLibraryCreateInfoEXT(); + void initialize(const VkGraphicsPipelineLibraryCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkGraphicsPipelineLibraryCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkGraphicsPipelineLibraryCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkGraphicsPipelineLibraryCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderEarlyAndLateFragmentTests; + + safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD( + const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD( + const safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& copy_src); + safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& operator=( + const safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& copy_src); + safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(); + ~safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(); + void initialize(const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* copy_src, + PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 fragmentShadingRateEnums; + VkBool32 supersampleFragmentShadingRates; + VkBool32 noInvocationFragmentShadingRates; + + safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV( + const safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& copy_src); + safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& operator=( + const safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& copy_src); + safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(); + ~safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(); + void initialize(const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + VkStructureType sType; + void* pNext{}; + VkSampleCountFlagBits maxFragmentShadingRateInvocationCount; + + safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV( + const safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& copy_src); + safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& operator=( + const safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& copy_src); + safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(); + ~safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(); + void initialize(const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkFragmentShadingRateTypeNV shadingRateType; + VkFragmentShadingRateNV shadingRate; + VkFragmentShadingRateCombinerOpKHR combinerOps[2]; + + safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV( + const safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV& copy_src); + safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV& operator=( + const safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV& copy_src); + safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(); + ~safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(); + void initialize(const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkPipelineFragmentShadingRateEnumStateCreateInfoNV* ptr() { + return reinterpret_cast(this); + } + VkPipelineFragmentShadingRateEnumStateCreateInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +union safe_VkDeviceOrHostAddressConstKHR { + VkDeviceAddress deviceAddress; + const void* hostAddress{}; + + safe_VkDeviceOrHostAddressConstKHR(const VkDeviceOrHostAddressConstKHR* in_struct, PNextCopyState* copy_state = {}); + safe_VkDeviceOrHostAddressConstKHR(const safe_VkDeviceOrHostAddressConstKHR& copy_src); + safe_VkDeviceOrHostAddressConstKHR& operator=(const safe_VkDeviceOrHostAddressConstKHR& copy_src); + safe_VkDeviceOrHostAddressConstKHR(); + ~safe_VkDeviceOrHostAddressConstKHR(); + void initialize(const VkDeviceOrHostAddressConstKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceOrHostAddressConstKHR* copy_src, PNextCopyState* copy_state = {}); + VkDeviceOrHostAddressConstKHR* ptr() { return reinterpret_cast(this); } + VkDeviceOrHostAddressConstKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkAccelerationStructureGeometryMotionTrianglesDataNV { + VkStructureType sType; + const void* pNext{}; + safe_VkDeviceOrHostAddressConstKHR vertexData; + + safe_VkAccelerationStructureGeometryMotionTrianglesDataNV(const VkAccelerationStructureGeometryMotionTrianglesDataNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAccelerationStructureGeometryMotionTrianglesDataNV( + const safe_VkAccelerationStructureGeometryMotionTrianglesDataNV& copy_src); + safe_VkAccelerationStructureGeometryMotionTrianglesDataNV& operator=( + const safe_VkAccelerationStructureGeometryMotionTrianglesDataNV& copy_src); + safe_VkAccelerationStructureGeometryMotionTrianglesDataNV(); + ~safe_VkAccelerationStructureGeometryMotionTrianglesDataNV(); + void initialize(const VkAccelerationStructureGeometryMotionTrianglesDataNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureGeometryMotionTrianglesDataNV* copy_src, PNextCopyState* copy_state = {}); + VkAccelerationStructureGeometryMotionTrianglesDataNV* ptr() { + return reinterpret_cast(this); + } + VkAccelerationStructureGeometryMotionTrianglesDataNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAccelerationStructureMotionInfoNV { + VkStructureType sType; + const void* pNext{}; + uint32_t maxInstances; + VkAccelerationStructureMotionInfoFlagsNV flags; + + safe_VkAccelerationStructureMotionInfoNV(const VkAccelerationStructureMotionInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkAccelerationStructureMotionInfoNV(const safe_VkAccelerationStructureMotionInfoNV& copy_src); + safe_VkAccelerationStructureMotionInfoNV& operator=(const safe_VkAccelerationStructureMotionInfoNV& copy_src); + safe_VkAccelerationStructureMotionInfoNV(); + ~safe_VkAccelerationStructureMotionInfoNV(); + void initialize(const VkAccelerationStructureMotionInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureMotionInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkAccelerationStructureMotionInfoNV* ptr() { return reinterpret_cast(this); } + VkAccelerationStructureMotionInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 rayTracingMotionBlur; + VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect; + + safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(const safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& copy_src); + safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& operator=( + const safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& copy_src); + safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(); + ~safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(); + void initialize(const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 ycbcr2plane444Formats; + + safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& copy_src); + safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& operator=( + const safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& copy_src); + safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(); + ~safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(); + void initialize(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 fragmentDensityMapDeferred; + + safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& copy_src); + safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& operator=( + const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& copy_src); + safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(); + ~safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(); + void initialize(const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 subsampledLoads; + VkBool32 subsampledCoarseReconstructionEarlyAccess; + uint32_t maxSubsampledArrayLayers; + uint32_t maxDescriptorSetSubsampledSamplers; + + safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& copy_src); + safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& operator=( + const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& copy_src); + safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(); + ~safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(); + void initialize(const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkCopyCommandTransformInfoQCOM { + VkStructureType sType; + const void* pNext{}; + VkSurfaceTransformFlagBitsKHR transform; + + safe_VkCopyCommandTransformInfoQCOM(const VkCopyCommandTransformInfoQCOM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCopyCommandTransformInfoQCOM(const safe_VkCopyCommandTransformInfoQCOM& copy_src); + safe_VkCopyCommandTransformInfoQCOM& operator=(const safe_VkCopyCommandTransformInfoQCOM& copy_src); + safe_VkCopyCommandTransformInfoQCOM(); + ~safe_VkCopyCommandTransformInfoQCOM(); + void initialize(const VkCopyCommandTransformInfoQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyCommandTransformInfoQCOM* copy_src, PNextCopyState* copy_state = {}); + VkCopyCommandTransformInfoQCOM* ptr() { return reinterpret_cast(this); } + VkCopyCommandTransformInfoQCOM const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 imageCompressionControl; + + safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT(const VkPhysicalDeviceImageCompressionControlFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT( + const safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT& copy_src); + safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT& operator=( + const safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT& copy_src); + safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT(); + ~safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT(); + void initialize(const VkPhysicalDeviceImageCompressionControlFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceImageCompressionControlFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceImageCompressionControlFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImageCompressionControlEXT { + VkStructureType sType; + const void* pNext{}; + VkImageCompressionFlagsEXT flags; + uint32_t compressionControlPlaneCount; + VkImageCompressionFixedRateFlagsEXT* pFixedRateFlags{}; + + safe_VkImageCompressionControlEXT(const VkImageCompressionControlEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImageCompressionControlEXT(const safe_VkImageCompressionControlEXT& copy_src); + safe_VkImageCompressionControlEXT& operator=(const safe_VkImageCompressionControlEXT& copy_src); + safe_VkImageCompressionControlEXT(); + ~safe_VkImageCompressionControlEXT(); + void initialize(const VkImageCompressionControlEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageCompressionControlEXT* copy_src, PNextCopyState* copy_state = {}); + VkImageCompressionControlEXT* ptr() { return reinterpret_cast(this); } + VkImageCompressionControlEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkImageCompressionPropertiesEXT { + VkStructureType sType; + void* pNext{}; + VkImageCompressionFlagsEXT imageCompressionFlags; + VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags; + + safe_VkImageCompressionPropertiesEXT(const VkImageCompressionPropertiesEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImageCompressionPropertiesEXT(const safe_VkImageCompressionPropertiesEXT& copy_src); + safe_VkImageCompressionPropertiesEXT& operator=(const safe_VkImageCompressionPropertiesEXT& copy_src); + safe_VkImageCompressionPropertiesEXT(); + ~safe_VkImageCompressionPropertiesEXT(); + void initialize(const VkImageCompressionPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageCompressionPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkImageCompressionPropertiesEXT* ptr() { return reinterpret_cast(this); } + VkImageCompressionPropertiesEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 attachmentFeedbackLoopLayout; + + safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT( + const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT( + const safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& copy_src); + safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& operator=( + const safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& copy_src); + safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(); + ~safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(); + void initialize(const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDevice4444FormatsFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 formatA4R4G4B4; + VkBool32 formatA4B4G4R4; + + safe_VkPhysicalDevice4444FormatsFeaturesEXT(const VkPhysicalDevice4444FormatsFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevice4444FormatsFeaturesEXT(const safe_VkPhysicalDevice4444FormatsFeaturesEXT& copy_src); + safe_VkPhysicalDevice4444FormatsFeaturesEXT& operator=(const safe_VkPhysicalDevice4444FormatsFeaturesEXT& copy_src); + safe_VkPhysicalDevice4444FormatsFeaturesEXT(); + ~safe_VkPhysicalDevice4444FormatsFeaturesEXT(); + void initialize(const VkPhysicalDevice4444FormatsFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevice4444FormatsFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevice4444FormatsFeaturesEXT* ptr() { return reinterpret_cast(this); } + VkPhysicalDevice4444FormatsFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceFaultFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 deviceFault; + VkBool32 deviceFaultVendorBinary; + + safe_VkPhysicalDeviceFaultFeaturesEXT(const VkPhysicalDeviceFaultFeaturesEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceFaultFeaturesEXT(const safe_VkPhysicalDeviceFaultFeaturesEXT& copy_src); + safe_VkPhysicalDeviceFaultFeaturesEXT& operator=(const safe_VkPhysicalDeviceFaultFeaturesEXT& copy_src); + safe_VkPhysicalDeviceFaultFeaturesEXT(); + ~safe_VkPhysicalDeviceFaultFeaturesEXT(); + void initialize(const VkPhysicalDeviceFaultFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceFaultFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceFaultFeaturesEXT* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceFaultFeaturesEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDeviceFaultCountsEXT { + VkStructureType sType; + void* pNext{}; + uint32_t addressInfoCount; + uint32_t vendorInfoCount; + VkDeviceSize vendorBinarySize; + + safe_VkDeviceFaultCountsEXT(const VkDeviceFaultCountsEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDeviceFaultCountsEXT(const safe_VkDeviceFaultCountsEXT& copy_src); + safe_VkDeviceFaultCountsEXT& operator=(const safe_VkDeviceFaultCountsEXT& copy_src); + safe_VkDeviceFaultCountsEXT(); + ~safe_VkDeviceFaultCountsEXT(); + void initialize(const VkDeviceFaultCountsEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceFaultCountsEXT* copy_src, PNextCopyState* copy_state = {}); + VkDeviceFaultCountsEXT* ptr() { return reinterpret_cast(this); } + VkDeviceFaultCountsEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDeviceFaultInfoEXT { + VkStructureType sType; + void* pNext{}; + char description[VK_MAX_DESCRIPTION_SIZE]; + VkDeviceFaultAddressInfoEXT* pAddressInfos{}; + VkDeviceFaultVendorInfoEXT* pVendorInfos{}; + void* pVendorBinaryData{}; + + safe_VkDeviceFaultInfoEXT(const VkDeviceFaultInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDeviceFaultInfoEXT(const safe_VkDeviceFaultInfoEXT& copy_src); + safe_VkDeviceFaultInfoEXT& operator=(const safe_VkDeviceFaultInfoEXT& copy_src); + safe_VkDeviceFaultInfoEXT(); + ~safe_VkDeviceFaultInfoEXT(); + void initialize(const VkDeviceFaultInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceFaultInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkDeviceFaultInfoEXT* ptr() { return reinterpret_cast(this); } + VkDeviceFaultInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 rasterizationOrderColorAttachmentAccess; + VkBool32 rasterizationOrderDepthAttachmentAccess; + VkBool32 rasterizationOrderStencilAttachmentAccess; + + safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT( + const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT( + const safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& copy_src); + safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& operator=( + const safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& copy_src); + safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(); + ~safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(); + void initialize(const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* copy_src, + PNextCopyState* copy_state = {}); + VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 formatRgba10x6WithoutYCbCrSampler; + + safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(const safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& copy_src); + safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& operator=(const safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& copy_src); + safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(); + ~safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(); + void initialize(const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +#ifdef VK_USE_PLATFORM_DIRECTFB_EXT +struct safe_VkDirectFBSurfaceCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkDirectFBSurfaceCreateFlagsEXT flags; + IDirectFB* dfb{}; + IDirectFBSurface* surface{}; + + safe_VkDirectFBSurfaceCreateInfoEXT(const VkDirectFBSurfaceCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDirectFBSurfaceCreateInfoEXT(const safe_VkDirectFBSurfaceCreateInfoEXT& copy_src); + safe_VkDirectFBSurfaceCreateInfoEXT& operator=(const safe_VkDirectFBSurfaceCreateInfoEXT& copy_src); + safe_VkDirectFBSurfaceCreateInfoEXT(); + ~safe_VkDirectFBSurfaceCreateInfoEXT(); + void initialize(const VkDirectFBSurfaceCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDirectFBSurfaceCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkDirectFBSurfaceCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkDirectFBSurfaceCreateInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_DIRECTFB_EXT +struct safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 mutableDescriptorType; + + safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(const safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT& copy_src); + safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT& operator=( + const safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT& copy_src); + safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(); + ~safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(); + void initialize(const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkMutableDescriptorTypeListEXT { + uint32_t descriptorTypeCount; + const VkDescriptorType* pDescriptorTypes{}; + + safe_VkMutableDescriptorTypeListEXT(const VkMutableDescriptorTypeListEXT* in_struct, PNextCopyState* copy_state = {}); + safe_VkMutableDescriptorTypeListEXT(const safe_VkMutableDescriptorTypeListEXT& copy_src); + safe_VkMutableDescriptorTypeListEXT& operator=(const safe_VkMutableDescriptorTypeListEXT& copy_src); + safe_VkMutableDescriptorTypeListEXT(); + ~safe_VkMutableDescriptorTypeListEXT(); + void initialize(const VkMutableDescriptorTypeListEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMutableDescriptorTypeListEXT* copy_src, PNextCopyState* copy_state = {}); + VkMutableDescriptorTypeListEXT* ptr() { return reinterpret_cast(this); } + VkMutableDescriptorTypeListEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkMutableDescriptorTypeCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + uint32_t mutableDescriptorTypeListCount; + safe_VkMutableDescriptorTypeListEXT* pMutableDescriptorTypeLists{}; + + safe_VkMutableDescriptorTypeCreateInfoEXT(const VkMutableDescriptorTypeCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMutableDescriptorTypeCreateInfoEXT(const safe_VkMutableDescriptorTypeCreateInfoEXT& copy_src); + safe_VkMutableDescriptorTypeCreateInfoEXT& operator=(const safe_VkMutableDescriptorTypeCreateInfoEXT& copy_src); + safe_VkMutableDescriptorTypeCreateInfoEXT(); + ~safe_VkMutableDescriptorTypeCreateInfoEXT(); + void initialize(const VkMutableDescriptorTypeCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMutableDescriptorTypeCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkMutableDescriptorTypeCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkMutableDescriptorTypeCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 vertexInputDynamicState; + + safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT( + const safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& copy_src); + safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& operator=( + const safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& copy_src); + safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(); + ~safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(); + void initialize(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkVertexInputBindingDescription2EXT { + VkStructureType sType; + void* pNext{}; + uint32_t binding; + uint32_t stride; + VkVertexInputRate inputRate; + uint32_t divisor; + + safe_VkVertexInputBindingDescription2EXT(const VkVertexInputBindingDescription2EXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkVertexInputBindingDescription2EXT(const safe_VkVertexInputBindingDescription2EXT& copy_src); + safe_VkVertexInputBindingDescription2EXT& operator=(const safe_VkVertexInputBindingDescription2EXT& copy_src); + safe_VkVertexInputBindingDescription2EXT(); + ~safe_VkVertexInputBindingDescription2EXT(); + void initialize(const VkVertexInputBindingDescription2EXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVertexInputBindingDescription2EXT* copy_src, PNextCopyState* copy_state = {}); + VkVertexInputBindingDescription2EXT* ptr() { return reinterpret_cast(this); } + VkVertexInputBindingDescription2EXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkVertexInputAttributeDescription2EXT { + VkStructureType sType; + void* pNext{}; + uint32_t location; + uint32_t binding; + VkFormat format; + uint32_t offset; + + safe_VkVertexInputAttributeDescription2EXT(const VkVertexInputAttributeDescription2EXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVertexInputAttributeDescription2EXT(const safe_VkVertexInputAttributeDescription2EXT& copy_src); + safe_VkVertexInputAttributeDescription2EXT& operator=(const safe_VkVertexInputAttributeDescription2EXT& copy_src); + safe_VkVertexInputAttributeDescription2EXT(); + ~safe_VkVertexInputAttributeDescription2EXT(); + void initialize(const VkVertexInputAttributeDescription2EXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVertexInputAttributeDescription2EXT* copy_src, PNextCopyState* copy_state = {}); + VkVertexInputAttributeDescription2EXT* ptr() { return reinterpret_cast(this); } + VkVertexInputAttributeDescription2EXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDrmPropertiesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 hasPrimary; + VkBool32 hasRender; + int64_t primaryMajor; + int64_t primaryMinor; + int64_t renderMajor; + int64_t renderMinor; + + safe_VkPhysicalDeviceDrmPropertiesEXT(const VkPhysicalDeviceDrmPropertiesEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceDrmPropertiesEXT(const safe_VkPhysicalDeviceDrmPropertiesEXT& copy_src); + safe_VkPhysicalDeviceDrmPropertiesEXT& operator=(const safe_VkPhysicalDeviceDrmPropertiesEXT& copy_src); + safe_VkPhysicalDeviceDrmPropertiesEXT(); + ~safe_VkPhysicalDeviceDrmPropertiesEXT(); + void initialize(const VkPhysicalDeviceDrmPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDrmPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDrmPropertiesEXT* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceDrmPropertiesEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 reportAddressBinding; + + safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT(const VkPhysicalDeviceAddressBindingReportFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT(const safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT& copy_src); + safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT& operator=( + const safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT& copy_src); + safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT(); + ~safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT(); + void initialize(const VkPhysicalDeviceAddressBindingReportFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceAddressBindingReportFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceAddressBindingReportFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDeviceAddressBindingCallbackDataEXT { + VkStructureType sType; + void* pNext{}; + VkDeviceAddressBindingFlagsEXT flags; + VkDeviceAddress baseAddress; + VkDeviceSize size; + VkDeviceAddressBindingTypeEXT bindingType; + + safe_VkDeviceAddressBindingCallbackDataEXT(const VkDeviceAddressBindingCallbackDataEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDeviceAddressBindingCallbackDataEXT(const safe_VkDeviceAddressBindingCallbackDataEXT& copy_src); + safe_VkDeviceAddressBindingCallbackDataEXT& operator=(const safe_VkDeviceAddressBindingCallbackDataEXT& copy_src); + safe_VkDeviceAddressBindingCallbackDataEXT(); + ~safe_VkDeviceAddressBindingCallbackDataEXT(); + void initialize(const VkDeviceAddressBindingCallbackDataEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceAddressBindingCallbackDataEXT* copy_src, PNextCopyState* copy_state = {}); + VkDeviceAddressBindingCallbackDataEXT* ptr() { return reinterpret_cast(this); } + VkDeviceAddressBindingCallbackDataEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDepthClipControlFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 depthClipControl; + + safe_VkPhysicalDeviceDepthClipControlFeaturesEXT(const VkPhysicalDeviceDepthClipControlFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDepthClipControlFeaturesEXT(const safe_VkPhysicalDeviceDepthClipControlFeaturesEXT& copy_src); + safe_VkPhysicalDeviceDepthClipControlFeaturesEXT& operator=(const safe_VkPhysicalDeviceDepthClipControlFeaturesEXT& copy_src); + safe_VkPhysicalDeviceDepthClipControlFeaturesEXT(); + ~safe_VkPhysicalDeviceDepthClipControlFeaturesEXT(); + void initialize(const VkPhysicalDeviceDepthClipControlFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDepthClipControlFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDepthClipControlFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDepthClipControlFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineViewportDepthClipControlCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkBool32 negativeOneToOne; + + safe_VkPipelineViewportDepthClipControlCreateInfoEXT(const VkPipelineViewportDepthClipControlCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineViewportDepthClipControlCreateInfoEXT(const safe_VkPipelineViewportDepthClipControlCreateInfoEXT& copy_src); + safe_VkPipelineViewportDepthClipControlCreateInfoEXT& operator=( + const safe_VkPipelineViewportDepthClipControlCreateInfoEXT& copy_src); + safe_VkPipelineViewportDepthClipControlCreateInfoEXT(); + ~safe_VkPipelineViewportDepthClipControlCreateInfoEXT(); + void initialize(const VkPipelineViewportDepthClipControlCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineViewportDepthClipControlCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkPipelineViewportDepthClipControlCreateInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkPipelineViewportDepthClipControlCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 primitiveTopologyListRestart; + VkBool32 primitiveTopologyPatchListRestart; + + safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT( + const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT( + const safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& copy_src); + safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& operator=( + const safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& copy_src); + safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(); + ~safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(); + void initialize(const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +#ifdef VK_USE_PLATFORM_FUCHSIA +struct safe_VkImportMemoryZirconHandleInfoFUCHSIA { + VkStructureType sType; + const void* pNext{}; + VkExternalMemoryHandleTypeFlagBits handleType; + zx_handle_t handle; + + safe_VkImportMemoryZirconHandleInfoFUCHSIA(const VkImportMemoryZirconHandleInfoFUCHSIA* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImportMemoryZirconHandleInfoFUCHSIA(const safe_VkImportMemoryZirconHandleInfoFUCHSIA& copy_src); + safe_VkImportMemoryZirconHandleInfoFUCHSIA& operator=(const safe_VkImportMemoryZirconHandleInfoFUCHSIA& copy_src); + safe_VkImportMemoryZirconHandleInfoFUCHSIA(); + ~safe_VkImportMemoryZirconHandleInfoFUCHSIA(); + void initialize(const VkImportMemoryZirconHandleInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImportMemoryZirconHandleInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {}); + VkImportMemoryZirconHandleInfoFUCHSIA* ptr() { return reinterpret_cast(this); } + VkImportMemoryZirconHandleInfoFUCHSIA const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkMemoryZirconHandlePropertiesFUCHSIA { + VkStructureType sType; + void* pNext{}; + uint32_t memoryTypeBits; + + safe_VkMemoryZirconHandlePropertiesFUCHSIA(const VkMemoryZirconHandlePropertiesFUCHSIA* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMemoryZirconHandlePropertiesFUCHSIA(const safe_VkMemoryZirconHandlePropertiesFUCHSIA& copy_src); + safe_VkMemoryZirconHandlePropertiesFUCHSIA& operator=(const safe_VkMemoryZirconHandlePropertiesFUCHSIA& copy_src); + safe_VkMemoryZirconHandlePropertiesFUCHSIA(); + ~safe_VkMemoryZirconHandlePropertiesFUCHSIA(); + void initialize(const VkMemoryZirconHandlePropertiesFUCHSIA* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryZirconHandlePropertiesFUCHSIA* copy_src, PNextCopyState* copy_state = {}); + VkMemoryZirconHandlePropertiesFUCHSIA* ptr() { return reinterpret_cast(this); } + VkMemoryZirconHandlePropertiesFUCHSIA const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkMemoryGetZirconHandleInfoFUCHSIA { + VkStructureType sType; + const void* pNext{}; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; + + safe_VkMemoryGetZirconHandleInfoFUCHSIA(const VkMemoryGetZirconHandleInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkMemoryGetZirconHandleInfoFUCHSIA(const safe_VkMemoryGetZirconHandleInfoFUCHSIA& copy_src); + safe_VkMemoryGetZirconHandleInfoFUCHSIA& operator=(const safe_VkMemoryGetZirconHandleInfoFUCHSIA& copy_src); + safe_VkMemoryGetZirconHandleInfoFUCHSIA(); + ~safe_VkMemoryGetZirconHandleInfoFUCHSIA(); + void initialize(const VkMemoryGetZirconHandleInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryGetZirconHandleInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {}); + VkMemoryGetZirconHandleInfoFUCHSIA* ptr() { return reinterpret_cast(this); } + VkMemoryGetZirconHandleInfoFUCHSIA const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImportSemaphoreZirconHandleInfoFUCHSIA { + VkStructureType sType; + const void* pNext{}; + VkSemaphore semaphore; + VkSemaphoreImportFlags flags; + VkExternalSemaphoreHandleTypeFlagBits handleType; + zx_handle_t zirconHandle; + + safe_VkImportSemaphoreZirconHandleInfoFUCHSIA(const VkImportSemaphoreZirconHandleInfoFUCHSIA* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImportSemaphoreZirconHandleInfoFUCHSIA(const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& copy_src); + safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& operator=(const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& copy_src); + safe_VkImportSemaphoreZirconHandleInfoFUCHSIA(); + ~safe_VkImportSemaphoreZirconHandleInfoFUCHSIA(); + void initialize(const VkImportSemaphoreZirconHandleInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {}); + VkImportSemaphoreZirconHandleInfoFUCHSIA* ptr() { return reinterpret_cast(this); } + VkImportSemaphoreZirconHandleInfoFUCHSIA const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSemaphoreGetZirconHandleInfoFUCHSIA { + VkStructureType sType; + const void* pNext{}; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBits handleType; + + safe_VkSemaphoreGetZirconHandleInfoFUCHSIA(const VkSemaphoreGetZirconHandleInfoFUCHSIA* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSemaphoreGetZirconHandleInfoFUCHSIA(const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& copy_src); + safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& operator=(const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& copy_src); + safe_VkSemaphoreGetZirconHandleInfoFUCHSIA(); + ~safe_VkSemaphoreGetZirconHandleInfoFUCHSIA(); + void initialize(const VkSemaphoreGetZirconHandleInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {}); + VkSemaphoreGetZirconHandleInfoFUCHSIA* ptr() { return reinterpret_cast(this); } + VkSemaphoreGetZirconHandleInfoFUCHSIA const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkBufferCollectionCreateInfoFUCHSIA { + VkStructureType sType; + const void* pNext{}; + zx_handle_t collectionToken; + + safe_VkBufferCollectionCreateInfoFUCHSIA(const VkBufferCollectionCreateInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkBufferCollectionCreateInfoFUCHSIA(const safe_VkBufferCollectionCreateInfoFUCHSIA& copy_src); + safe_VkBufferCollectionCreateInfoFUCHSIA& operator=(const safe_VkBufferCollectionCreateInfoFUCHSIA& copy_src); + safe_VkBufferCollectionCreateInfoFUCHSIA(); + ~safe_VkBufferCollectionCreateInfoFUCHSIA(); + void initialize(const VkBufferCollectionCreateInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBufferCollectionCreateInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {}); + VkBufferCollectionCreateInfoFUCHSIA* ptr() { return reinterpret_cast(this); } + VkBufferCollectionCreateInfoFUCHSIA const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImportMemoryBufferCollectionFUCHSIA { + VkStructureType sType; + const void* pNext{}; + VkBufferCollectionFUCHSIA collection; + uint32_t index; + + safe_VkImportMemoryBufferCollectionFUCHSIA(const VkImportMemoryBufferCollectionFUCHSIA* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImportMemoryBufferCollectionFUCHSIA(const safe_VkImportMemoryBufferCollectionFUCHSIA& copy_src); + safe_VkImportMemoryBufferCollectionFUCHSIA& operator=(const safe_VkImportMemoryBufferCollectionFUCHSIA& copy_src); + safe_VkImportMemoryBufferCollectionFUCHSIA(); + ~safe_VkImportMemoryBufferCollectionFUCHSIA(); + void initialize(const VkImportMemoryBufferCollectionFUCHSIA* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImportMemoryBufferCollectionFUCHSIA* copy_src, PNextCopyState* copy_state = {}); + VkImportMemoryBufferCollectionFUCHSIA* ptr() { return reinterpret_cast(this); } + VkImportMemoryBufferCollectionFUCHSIA const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkBufferCollectionImageCreateInfoFUCHSIA { + VkStructureType sType; + const void* pNext{}; + VkBufferCollectionFUCHSIA collection; + uint32_t index; + + safe_VkBufferCollectionImageCreateInfoFUCHSIA(const VkBufferCollectionImageCreateInfoFUCHSIA* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkBufferCollectionImageCreateInfoFUCHSIA(const safe_VkBufferCollectionImageCreateInfoFUCHSIA& copy_src); + safe_VkBufferCollectionImageCreateInfoFUCHSIA& operator=(const safe_VkBufferCollectionImageCreateInfoFUCHSIA& copy_src); + safe_VkBufferCollectionImageCreateInfoFUCHSIA(); + ~safe_VkBufferCollectionImageCreateInfoFUCHSIA(); + void initialize(const VkBufferCollectionImageCreateInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBufferCollectionImageCreateInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {}); + VkBufferCollectionImageCreateInfoFUCHSIA* ptr() { return reinterpret_cast(this); } + VkBufferCollectionImageCreateInfoFUCHSIA const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkBufferCollectionConstraintsInfoFUCHSIA { + VkStructureType sType; + const void* pNext{}; + uint32_t minBufferCount; + uint32_t maxBufferCount; + uint32_t minBufferCountForCamping; + uint32_t minBufferCountForDedicatedSlack; + uint32_t minBufferCountForSharedSlack; + + safe_VkBufferCollectionConstraintsInfoFUCHSIA(const VkBufferCollectionConstraintsInfoFUCHSIA* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkBufferCollectionConstraintsInfoFUCHSIA(const safe_VkBufferCollectionConstraintsInfoFUCHSIA& copy_src); + safe_VkBufferCollectionConstraintsInfoFUCHSIA& operator=(const safe_VkBufferCollectionConstraintsInfoFUCHSIA& copy_src); + safe_VkBufferCollectionConstraintsInfoFUCHSIA(); + ~safe_VkBufferCollectionConstraintsInfoFUCHSIA(); + void initialize(const VkBufferCollectionConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBufferCollectionConstraintsInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {}); + VkBufferCollectionConstraintsInfoFUCHSIA* ptr() { return reinterpret_cast(this); } + VkBufferCollectionConstraintsInfoFUCHSIA const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkBufferConstraintsInfoFUCHSIA { + VkStructureType sType; + const void* pNext{}; + safe_VkBufferCreateInfo createInfo; + VkFormatFeatureFlags requiredFormatFeatures; + safe_VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints; + + safe_VkBufferConstraintsInfoFUCHSIA(const VkBufferConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkBufferConstraintsInfoFUCHSIA(const safe_VkBufferConstraintsInfoFUCHSIA& copy_src); + safe_VkBufferConstraintsInfoFUCHSIA& operator=(const safe_VkBufferConstraintsInfoFUCHSIA& copy_src); + safe_VkBufferConstraintsInfoFUCHSIA(); + ~safe_VkBufferConstraintsInfoFUCHSIA(); + void initialize(const VkBufferConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBufferConstraintsInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {}); + VkBufferConstraintsInfoFUCHSIA* ptr() { return reinterpret_cast(this); } + VkBufferConstraintsInfoFUCHSIA const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkBufferCollectionBufferCreateInfoFUCHSIA { + VkStructureType sType; + const void* pNext{}; + VkBufferCollectionFUCHSIA collection; + uint32_t index; + + safe_VkBufferCollectionBufferCreateInfoFUCHSIA(const VkBufferCollectionBufferCreateInfoFUCHSIA* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkBufferCollectionBufferCreateInfoFUCHSIA(const safe_VkBufferCollectionBufferCreateInfoFUCHSIA& copy_src); + safe_VkBufferCollectionBufferCreateInfoFUCHSIA& operator=(const safe_VkBufferCollectionBufferCreateInfoFUCHSIA& copy_src); + safe_VkBufferCollectionBufferCreateInfoFUCHSIA(); + ~safe_VkBufferCollectionBufferCreateInfoFUCHSIA(); + void initialize(const VkBufferCollectionBufferCreateInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBufferCollectionBufferCreateInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {}); + VkBufferCollectionBufferCreateInfoFUCHSIA* ptr() { return reinterpret_cast(this); } + VkBufferCollectionBufferCreateInfoFUCHSIA const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSysmemColorSpaceFUCHSIA { + VkStructureType sType; + const void* pNext{}; + uint32_t colorSpace; + + safe_VkSysmemColorSpaceFUCHSIA(const VkSysmemColorSpaceFUCHSIA* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSysmemColorSpaceFUCHSIA(const safe_VkSysmemColorSpaceFUCHSIA& copy_src); + safe_VkSysmemColorSpaceFUCHSIA& operator=(const safe_VkSysmemColorSpaceFUCHSIA& copy_src); + safe_VkSysmemColorSpaceFUCHSIA(); + ~safe_VkSysmemColorSpaceFUCHSIA(); + void initialize(const VkSysmemColorSpaceFUCHSIA* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSysmemColorSpaceFUCHSIA* copy_src, PNextCopyState* copy_state = {}); + VkSysmemColorSpaceFUCHSIA* ptr() { return reinterpret_cast(this); } + VkSysmemColorSpaceFUCHSIA const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkBufferCollectionPropertiesFUCHSIA { + VkStructureType sType; + void* pNext{}; + uint32_t memoryTypeBits; + uint32_t bufferCount; + uint32_t createInfoIndex; + uint64_t sysmemPixelFormat; + VkFormatFeatureFlags formatFeatures; + safe_VkSysmemColorSpaceFUCHSIA sysmemColorSpaceIndex; + VkComponentMapping samplerYcbcrConversionComponents; + VkSamplerYcbcrModelConversion suggestedYcbcrModel; + VkSamplerYcbcrRange suggestedYcbcrRange; + VkChromaLocation suggestedXChromaOffset; + VkChromaLocation suggestedYChromaOffset; + + safe_VkBufferCollectionPropertiesFUCHSIA(const VkBufferCollectionPropertiesFUCHSIA* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkBufferCollectionPropertiesFUCHSIA(const safe_VkBufferCollectionPropertiesFUCHSIA& copy_src); + safe_VkBufferCollectionPropertiesFUCHSIA& operator=(const safe_VkBufferCollectionPropertiesFUCHSIA& copy_src); + safe_VkBufferCollectionPropertiesFUCHSIA(); + ~safe_VkBufferCollectionPropertiesFUCHSIA(); + void initialize(const VkBufferCollectionPropertiesFUCHSIA* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBufferCollectionPropertiesFUCHSIA* copy_src, PNextCopyState* copy_state = {}); + VkBufferCollectionPropertiesFUCHSIA* ptr() { return reinterpret_cast(this); } + VkBufferCollectionPropertiesFUCHSIA const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImageFormatConstraintsInfoFUCHSIA { + VkStructureType sType; + const void* pNext{}; + safe_VkImageCreateInfo imageCreateInfo; + VkFormatFeatureFlags requiredFormatFeatures; + VkImageFormatConstraintsFlagsFUCHSIA flags; + uint64_t sysmemPixelFormat; + uint32_t colorSpaceCount; + safe_VkSysmemColorSpaceFUCHSIA* pColorSpaces{}; + + safe_VkImageFormatConstraintsInfoFUCHSIA(const VkImageFormatConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImageFormatConstraintsInfoFUCHSIA(const safe_VkImageFormatConstraintsInfoFUCHSIA& copy_src); + safe_VkImageFormatConstraintsInfoFUCHSIA& operator=(const safe_VkImageFormatConstraintsInfoFUCHSIA& copy_src); + safe_VkImageFormatConstraintsInfoFUCHSIA(); + ~safe_VkImageFormatConstraintsInfoFUCHSIA(); + void initialize(const VkImageFormatConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageFormatConstraintsInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {}); + VkImageFormatConstraintsInfoFUCHSIA* ptr() { return reinterpret_cast(this); } + VkImageFormatConstraintsInfoFUCHSIA const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImageConstraintsInfoFUCHSIA { + VkStructureType sType; + const void* pNext{}; + uint32_t formatConstraintsCount; + safe_VkImageFormatConstraintsInfoFUCHSIA* pFormatConstraints{}; + safe_VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints; + VkImageConstraintsInfoFlagsFUCHSIA flags; + + safe_VkImageConstraintsInfoFUCHSIA(const VkImageConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImageConstraintsInfoFUCHSIA(const safe_VkImageConstraintsInfoFUCHSIA& copy_src); + safe_VkImageConstraintsInfoFUCHSIA& operator=(const safe_VkImageConstraintsInfoFUCHSIA& copy_src); + safe_VkImageConstraintsInfoFUCHSIA(); + ~safe_VkImageConstraintsInfoFUCHSIA(); + void initialize(const VkImageConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageConstraintsInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {}); + VkImageConstraintsInfoFUCHSIA* ptr() { return reinterpret_cast(this); } + VkImageConstraintsInfoFUCHSIA const* ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_FUCHSIA +struct safe_VkSubpassShadingPipelineCreateInfoHUAWEI { + VkStructureType sType; + void* pNext{}; + VkRenderPass renderPass; + uint32_t subpass; + + safe_VkSubpassShadingPipelineCreateInfoHUAWEI(const VkSubpassShadingPipelineCreateInfoHUAWEI* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSubpassShadingPipelineCreateInfoHUAWEI(const safe_VkSubpassShadingPipelineCreateInfoHUAWEI& copy_src); + safe_VkSubpassShadingPipelineCreateInfoHUAWEI& operator=(const safe_VkSubpassShadingPipelineCreateInfoHUAWEI& copy_src); + safe_VkSubpassShadingPipelineCreateInfoHUAWEI(); + ~safe_VkSubpassShadingPipelineCreateInfoHUAWEI(); + void initialize(const VkSubpassShadingPipelineCreateInfoHUAWEI* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSubpassShadingPipelineCreateInfoHUAWEI* copy_src, PNextCopyState* copy_state = {}); + VkSubpassShadingPipelineCreateInfoHUAWEI* ptr() { return reinterpret_cast(this); } + VkSubpassShadingPipelineCreateInfoHUAWEI const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI { + VkStructureType sType; + void* pNext{}; + VkBool32 subpassShading; + + safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(const safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& copy_src); + safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& operator=(const safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& copy_src); + safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(); + ~safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(); + void initialize(const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI { + VkStructureType sType; + void* pNext{}; + uint32_t maxSubpassShadingWorkgroupSizeAspectRatio; + + safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(const safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& copy_src); + safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& operator=( + const safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& copy_src); + safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(); + ~safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(); + void initialize(const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI { + VkStructureType sType; + void* pNext{}; + VkBool32 invocationMask; + + safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(const safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& copy_src); + safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& operator=(const safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& copy_src); + safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(); + ~safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(); + void initialize(const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkMemoryGetRemoteAddressInfoNV { + VkStructureType sType; + const void* pNext{}; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; + + safe_VkMemoryGetRemoteAddressInfoNV(const VkMemoryGetRemoteAddressInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkMemoryGetRemoteAddressInfoNV(const safe_VkMemoryGetRemoteAddressInfoNV& copy_src); + safe_VkMemoryGetRemoteAddressInfoNV& operator=(const safe_VkMemoryGetRemoteAddressInfoNV& copy_src); + safe_VkMemoryGetRemoteAddressInfoNV(); + ~safe_VkMemoryGetRemoteAddressInfoNV(); + void initialize(const VkMemoryGetRemoteAddressInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryGetRemoteAddressInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkMemoryGetRemoteAddressInfoNV* ptr() { return reinterpret_cast(this); } + VkMemoryGetRemoteAddressInfoNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 externalMemoryRDMA; + + safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(const safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& copy_src); + safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& operator=(const safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& copy_src); + safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(); + ~safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(); + void initialize(const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelinePropertiesIdentifierEXT { + VkStructureType sType; + void* pNext{}; + uint8_t pipelineIdentifier[VK_UUID_SIZE]; + + safe_VkPipelinePropertiesIdentifierEXT(const VkPipelinePropertiesIdentifierEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelinePropertiesIdentifierEXT(const safe_VkPipelinePropertiesIdentifierEXT& copy_src); + safe_VkPipelinePropertiesIdentifierEXT& operator=(const safe_VkPipelinePropertiesIdentifierEXT& copy_src); + safe_VkPipelinePropertiesIdentifierEXT(); + ~safe_VkPipelinePropertiesIdentifierEXT(); + void initialize(const VkPipelinePropertiesIdentifierEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelinePropertiesIdentifierEXT* copy_src, PNextCopyState* copy_state = {}); + VkPipelinePropertiesIdentifierEXT* ptr() { return reinterpret_cast(this); } + VkPipelinePropertiesIdentifierEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 pipelinePropertiesIdentifier; + + safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT(const VkPhysicalDevicePipelinePropertiesFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT(const safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT& copy_src); + safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT& operator=( + const safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT& copy_src); + safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT(); + ~safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT(); + void initialize(const VkPhysicalDevicePipelinePropertiesFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePipelinePropertiesFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDevicePipelinePropertiesFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 frameBoundary; + + safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT(const VkPhysicalDeviceFrameBoundaryFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT(const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT& copy_src); + safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT& operator=(const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT& copy_src); + safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT(); + ~safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT(); + void initialize(const VkPhysicalDeviceFrameBoundaryFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceFrameBoundaryFeaturesEXT* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceFrameBoundaryFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkFrameBoundaryEXT { + VkStructureType sType; + const void* pNext{}; + VkFrameBoundaryFlagsEXT flags; + uint64_t frameID; + uint32_t imageCount; + VkImage* pImages{}; + uint32_t bufferCount; + VkBuffer* pBuffers{}; + uint64_t tagName; + size_t tagSize; + const void* pTag{}; + + safe_VkFrameBoundaryEXT(const VkFrameBoundaryEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkFrameBoundaryEXT(const safe_VkFrameBoundaryEXT& copy_src); + safe_VkFrameBoundaryEXT& operator=(const safe_VkFrameBoundaryEXT& copy_src); + safe_VkFrameBoundaryEXT(); + ~safe_VkFrameBoundaryEXT(); + void initialize(const VkFrameBoundaryEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkFrameBoundaryEXT* copy_src, PNextCopyState* copy_state = {}); + VkFrameBoundaryEXT* ptr() { return reinterpret_cast(this); } + VkFrameBoundaryEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 multisampledRenderToSingleSampled; + + safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT( + const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT( + const safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& copy_src); + safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& operator=( + const safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& copy_src); + safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(); + ~safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(); + void initialize(const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* copy_src, + PNextCopyState* copy_state = {}); + VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSubpassResolvePerformanceQueryEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 optimal; + + safe_VkSubpassResolvePerformanceQueryEXT(const VkSubpassResolvePerformanceQueryEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSubpassResolvePerformanceQueryEXT(const safe_VkSubpassResolvePerformanceQueryEXT& copy_src); + safe_VkSubpassResolvePerformanceQueryEXT& operator=(const safe_VkSubpassResolvePerformanceQueryEXT& copy_src); + safe_VkSubpassResolvePerformanceQueryEXT(); + ~safe_VkSubpassResolvePerformanceQueryEXT(); + void initialize(const VkSubpassResolvePerformanceQueryEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSubpassResolvePerformanceQueryEXT* copy_src, PNextCopyState* copy_state = {}); + VkSubpassResolvePerformanceQueryEXT* ptr() { return reinterpret_cast(this); } + VkSubpassResolvePerformanceQueryEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkMultisampledRenderToSingleSampledInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkBool32 multisampledRenderToSingleSampledEnable; + VkSampleCountFlagBits rasterizationSamples; + + safe_VkMultisampledRenderToSingleSampledInfoEXT(const VkMultisampledRenderToSingleSampledInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMultisampledRenderToSingleSampledInfoEXT(const safe_VkMultisampledRenderToSingleSampledInfoEXT& copy_src); + safe_VkMultisampledRenderToSingleSampledInfoEXT& operator=(const safe_VkMultisampledRenderToSingleSampledInfoEXT& copy_src); + safe_VkMultisampledRenderToSingleSampledInfoEXT(); + ~safe_VkMultisampledRenderToSingleSampledInfoEXT(); + void initialize(const VkMultisampledRenderToSingleSampledInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMultisampledRenderToSingleSampledInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkMultisampledRenderToSingleSampledInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkMultisampledRenderToSingleSampledInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 extendedDynamicState2; + VkBool32 extendedDynamicState2LogicOp; + VkBool32 extendedDynamicState2PatchControlPoints; + + safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& copy_src); + safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& operator=( + const safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& copy_src); + safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(); + ~safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(); + void initialize(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +#ifdef VK_USE_PLATFORM_SCREEN_QNX +struct safe_VkScreenSurfaceCreateInfoQNX { + VkStructureType sType; + const void* pNext{}; + VkScreenSurfaceCreateFlagsQNX flags; + struct _screen_context* context{}; + struct _screen_window* window{}; + + safe_VkScreenSurfaceCreateInfoQNX(const VkScreenSurfaceCreateInfoQNX* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkScreenSurfaceCreateInfoQNX(const safe_VkScreenSurfaceCreateInfoQNX& copy_src); + safe_VkScreenSurfaceCreateInfoQNX& operator=(const safe_VkScreenSurfaceCreateInfoQNX& copy_src); + safe_VkScreenSurfaceCreateInfoQNX(); + ~safe_VkScreenSurfaceCreateInfoQNX(); + void initialize(const VkScreenSurfaceCreateInfoQNX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkScreenSurfaceCreateInfoQNX* copy_src, PNextCopyState* copy_state = {}); + VkScreenSurfaceCreateInfoQNX* ptr() { return reinterpret_cast(this); } + VkScreenSurfaceCreateInfoQNX const* ptr() const { return reinterpret_cast(this); } +}; +#endif // VK_USE_PLATFORM_SCREEN_QNX +struct safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 colorWriteEnable; + + safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT(const VkPhysicalDeviceColorWriteEnableFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT(const safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT& copy_src); + safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT& operator=(const safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT& copy_src); + safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT(); + ~safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT(); + void initialize(const VkPhysicalDeviceColorWriteEnableFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceColorWriteEnableFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceColorWriteEnableFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineColorWriteCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + uint32_t attachmentCount; + const VkBool32* pColorWriteEnables{}; + + safe_VkPipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPipelineColorWriteCreateInfoEXT(const safe_VkPipelineColorWriteCreateInfoEXT& copy_src); + safe_VkPipelineColorWriteCreateInfoEXT& operator=(const safe_VkPipelineColorWriteCreateInfoEXT& copy_src); + safe_VkPipelineColorWriteCreateInfoEXT(); + ~safe_VkPipelineColorWriteCreateInfoEXT(); + void initialize(const VkPipelineColorWriteCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineColorWriteCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkPipelineColorWriteCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkPipelineColorWriteCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 primitivesGeneratedQuery; + VkBool32 primitivesGeneratedQueryWithRasterizerDiscard; + VkBool32 primitivesGeneratedQueryWithNonZeroStreams; + + safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT( + const safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& copy_src); + safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& operator=( + const safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& copy_src); + safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(); + ~safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(); + void initialize(const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 minLod; + + safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT(const VkPhysicalDeviceImageViewMinLodFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT(const safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT& copy_src); + safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT& operator=(const safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT& copy_src); + safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT(); + ~safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT(); + void initialize(const VkPhysicalDeviceImageViewMinLodFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceImageViewMinLodFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceImageViewMinLodFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImageViewMinLodCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + float minLod; + + safe_VkImageViewMinLodCreateInfoEXT(const VkImageViewMinLodCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImageViewMinLodCreateInfoEXT(const safe_VkImageViewMinLodCreateInfoEXT& copy_src); + safe_VkImageViewMinLodCreateInfoEXT& operator=(const safe_VkImageViewMinLodCreateInfoEXT& copy_src); + safe_VkImageViewMinLodCreateInfoEXT(); + ~safe_VkImageViewMinLodCreateInfoEXT(); + void initialize(const VkImageViewMinLodCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageViewMinLodCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkImageViewMinLodCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkImageViewMinLodCreateInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceMultiDrawFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 multiDraw; + + safe_VkPhysicalDeviceMultiDrawFeaturesEXT(const VkPhysicalDeviceMultiDrawFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMultiDrawFeaturesEXT(const safe_VkPhysicalDeviceMultiDrawFeaturesEXT& copy_src); + safe_VkPhysicalDeviceMultiDrawFeaturesEXT& operator=(const safe_VkPhysicalDeviceMultiDrawFeaturesEXT& copy_src); + safe_VkPhysicalDeviceMultiDrawFeaturesEXT(); + ~safe_VkPhysicalDeviceMultiDrawFeaturesEXT(); + void initialize(const VkPhysicalDeviceMultiDrawFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMultiDrawFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMultiDrawFeaturesEXT* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMultiDrawFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMultiDrawPropertiesEXT { + VkStructureType sType; + void* pNext{}; + uint32_t maxMultiDrawCount; + + safe_VkPhysicalDeviceMultiDrawPropertiesEXT(const VkPhysicalDeviceMultiDrawPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMultiDrawPropertiesEXT(const safe_VkPhysicalDeviceMultiDrawPropertiesEXT& copy_src); + safe_VkPhysicalDeviceMultiDrawPropertiesEXT& operator=(const safe_VkPhysicalDeviceMultiDrawPropertiesEXT& copy_src); + safe_VkPhysicalDeviceMultiDrawPropertiesEXT(); + ~safe_VkPhysicalDeviceMultiDrawPropertiesEXT(); + void initialize(const VkPhysicalDeviceMultiDrawPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMultiDrawPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMultiDrawPropertiesEXT* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMultiDrawPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 image2DViewOf3D; + VkBool32 sampler2DViewOf3D; + + safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(const safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& copy_src); + safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& operator=(const safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& copy_src); + safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(); + ~safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(); + void initialize(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceImage2DViewOf3DFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderTileImageFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderTileImageColorReadAccess; + VkBool32 shaderTileImageDepthReadAccess; + VkBool32 shaderTileImageStencilReadAccess; + + safe_VkPhysicalDeviceShaderTileImageFeaturesEXT(const VkPhysicalDeviceShaderTileImageFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderTileImageFeaturesEXT(const safe_VkPhysicalDeviceShaderTileImageFeaturesEXT& copy_src); + safe_VkPhysicalDeviceShaderTileImageFeaturesEXT& operator=(const safe_VkPhysicalDeviceShaderTileImageFeaturesEXT& copy_src); + safe_VkPhysicalDeviceShaderTileImageFeaturesEXT(); + ~safe_VkPhysicalDeviceShaderTileImageFeaturesEXT(); + void initialize(const VkPhysicalDeviceShaderTileImageFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderTileImageFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderTileImageFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderTileImageFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderTileImagePropertiesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderTileImageCoherentReadAccelerated; + VkBool32 shaderTileImageReadSampleFromPixelRateInvocation; + VkBool32 shaderTileImageReadFromHelperInvocation; + + safe_VkPhysicalDeviceShaderTileImagePropertiesEXT(const VkPhysicalDeviceShaderTileImagePropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderTileImagePropertiesEXT(const safe_VkPhysicalDeviceShaderTileImagePropertiesEXT& copy_src); + safe_VkPhysicalDeviceShaderTileImagePropertiesEXT& operator=(const safe_VkPhysicalDeviceShaderTileImagePropertiesEXT& copy_src); + safe_VkPhysicalDeviceShaderTileImagePropertiesEXT(); + ~safe_VkPhysicalDeviceShaderTileImagePropertiesEXT(); + void initialize(const VkPhysicalDeviceShaderTileImagePropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderTileImagePropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderTileImagePropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderTileImagePropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +union safe_VkDeviceOrHostAddressKHR { + VkDeviceAddress deviceAddress; + void* hostAddress{}; + + safe_VkDeviceOrHostAddressKHR(const VkDeviceOrHostAddressKHR* in_struct, PNextCopyState* copy_state = {}); + safe_VkDeviceOrHostAddressKHR(const safe_VkDeviceOrHostAddressKHR& copy_src); + safe_VkDeviceOrHostAddressKHR& operator=(const safe_VkDeviceOrHostAddressKHR& copy_src); + safe_VkDeviceOrHostAddressKHR(); + ~safe_VkDeviceOrHostAddressKHR(); + void initialize(const VkDeviceOrHostAddressKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceOrHostAddressKHR* copy_src, PNextCopyState* copy_state = {}); + VkDeviceOrHostAddressKHR* ptr() { return reinterpret_cast(this); } + VkDeviceOrHostAddressKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkMicromapBuildInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkMicromapTypeEXT type; + VkBuildMicromapFlagsEXT flags; + VkBuildMicromapModeEXT mode; + VkMicromapEXT dstMicromap; + uint32_t usageCountsCount; + const VkMicromapUsageEXT* pUsageCounts{}; + const VkMicromapUsageEXT* const* ppUsageCounts{}; + safe_VkDeviceOrHostAddressConstKHR data; + safe_VkDeviceOrHostAddressKHR scratchData; + safe_VkDeviceOrHostAddressConstKHR triangleArray; + VkDeviceSize triangleArrayStride; + + safe_VkMicromapBuildInfoEXT(const VkMicromapBuildInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMicromapBuildInfoEXT(const safe_VkMicromapBuildInfoEXT& copy_src); + safe_VkMicromapBuildInfoEXT& operator=(const safe_VkMicromapBuildInfoEXT& copy_src); + safe_VkMicromapBuildInfoEXT(); + ~safe_VkMicromapBuildInfoEXT(); + void initialize(const VkMicromapBuildInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMicromapBuildInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkMicromapBuildInfoEXT* ptr() { return reinterpret_cast(this); } + VkMicromapBuildInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkMicromapCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkMicromapCreateFlagsEXT createFlags; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; + VkMicromapTypeEXT type; + VkDeviceAddress deviceAddress; + + safe_VkMicromapCreateInfoEXT(const VkMicromapCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMicromapCreateInfoEXT(const safe_VkMicromapCreateInfoEXT& copy_src); + safe_VkMicromapCreateInfoEXT& operator=(const safe_VkMicromapCreateInfoEXT& copy_src); + safe_VkMicromapCreateInfoEXT(); + ~safe_VkMicromapCreateInfoEXT(); + void initialize(const VkMicromapCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMicromapCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkMicromapCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkMicromapCreateInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 micromap; + VkBool32 micromapCaptureReplay; + VkBool32 micromapHostCommands; + + safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT(const VkPhysicalDeviceOpacityMicromapFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT(const safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT& copy_src); + safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT& operator=(const safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT& copy_src); + safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT(); + ~safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT(); + void initialize(const VkPhysicalDeviceOpacityMicromapFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceOpacityMicromapFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceOpacityMicromapFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT { + VkStructureType sType; + void* pNext{}; + uint32_t maxOpacity2StateSubdivisionLevel; + uint32_t maxOpacity4StateSubdivisionLevel; + + safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT(const VkPhysicalDeviceOpacityMicromapPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT(const safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT& copy_src); + safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT& operator=(const safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT& copy_src); + safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT(); + ~safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT(); + void initialize(const VkPhysicalDeviceOpacityMicromapPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceOpacityMicromapPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceOpacityMicromapPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkMicromapVersionInfoEXT { + VkStructureType sType; + const void* pNext{}; + const uint8_t* pVersionData{}; + + safe_VkMicromapVersionInfoEXT(const VkMicromapVersionInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkMicromapVersionInfoEXT(const safe_VkMicromapVersionInfoEXT& copy_src); + safe_VkMicromapVersionInfoEXT& operator=(const safe_VkMicromapVersionInfoEXT& copy_src); + safe_VkMicromapVersionInfoEXT(); + ~safe_VkMicromapVersionInfoEXT(); + void initialize(const VkMicromapVersionInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMicromapVersionInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkMicromapVersionInfoEXT* ptr() { return reinterpret_cast(this); } + VkMicromapVersionInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCopyMicromapToMemoryInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkMicromapEXT src; + safe_VkDeviceOrHostAddressKHR dst; + VkCopyMicromapModeEXT mode; + + safe_VkCopyMicromapToMemoryInfoEXT(const VkCopyMicromapToMemoryInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCopyMicromapToMemoryInfoEXT(const safe_VkCopyMicromapToMemoryInfoEXT& copy_src); + safe_VkCopyMicromapToMemoryInfoEXT& operator=(const safe_VkCopyMicromapToMemoryInfoEXT& copy_src); + safe_VkCopyMicromapToMemoryInfoEXT(); + ~safe_VkCopyMicromapToMemoryInfoEXT(); + void initialize(const VkCopyMicromapToMemoryInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyMicromapToMemoryInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkCopyMicromapToMemoryInfoEXT* ptr() { return reinterpret_cast(this); } + VkCopyMicromapToMemoryInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCopyMemoryToMicromapInfoEXT { + VkStructureType sType; + const void* pNext{}; + safe_VkDeviceOrHostAddressConstKHR src; + VkMicromapEXT dst; + VkCopyMicromapModeEXT mode; + + safe_VkCopyMemoryToMicromapInfoEXT(const VkCopyMemoryToMicromapInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCopyMemoryToMicromapInfoEXT(const safe_VkCopyMemoryToMicromapInfoEXT& copy_src); + safe_VkCopyMemoryToMicromapInfoEXT& operator=(const safe_VkCopyMemoryToMicromapInfoEXT& copy_src); + safe_VkCopyMemoryToMicromapInfoEXT(); + ~safe_VkCopyMemoryToMicromapInfoEXT(); + void initialize(const VkCopyMemoryToMicromapInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyMemoryToMicromapInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkCopyMemoryToMicromapInfoEXT* ptr() { return reinterpret_cast(this); } + VkCopyMemoryToMicromapInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCopyMicromapInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkMicromapEXT src; + VkMicromapEXT dst; + VkCopyMicromapModeEXT mode; + + safe_VkCopyMicromapInfoEXT(const VkCopyMicromapInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkCopyMicromapInfoEXT(const safe_VkCopyMicromapInfoEXT& copy_src); + safe_VkCopyMicromapInfoEXT& operator=(const safe_VkCopyMicromapInfoEXT& copy_src); + safe_VkCopyMicromapInfoEXT(); + ~safe_VkCopyMicromapInfoEXT(); + void initialize(const VkCopyMicromapInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyMicromapInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkCopyMicromapInfoEXT* ptr() { return reinterpret_cast(this); } + VkCopyMicromapInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkMicromapBuildSizesInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkDeviceSize micromapSize; + VkDeviceSize buildScratchSize; + VkBool32 discardable; + + safe_VkMicromapBuildSizesInfoEXT(const VkMicromapBuildSizesInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkMicromapBuildSizesInfoEXT(const safe_VkMicromapBuildSizesInfoEXT& copy_src); + safe_VkMicromapBuildSizesInfoEXT& operator=(const safe_VkMicromapBuildSizesInfoEXT& copy_src); + safe_VkMicromapBuildSizesInfoEXT(); + ~safe_VkMicromapBuildSizesInfoEXT(); + void initialize(const VkMicromapBuildSizesInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMicromapBuildSizesInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkMicromapBuildSizesInfoEXT* ptr() { return reinterpret_cast(this); } + VkMicromapBuildSizesInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkAccelerationStructureTrianglesOpacityMicromapEXT { + VkStructureType sType; + void* pNext{}; + VkIndexType indexType; + safe_VkDeviceOrHostAddressConstKHR indexBuffer; + VkDeviceSize indexStride; + uint32_t baseTriangle; + uint32_t usageCountsCount; + const VkMicromapUsageEXT* pUsageCounts{}; + const VkMicromapUsageEXT* const* ppUsageCounts{}; + VkMicromapEXT micromap; + + safe_VkAccelerationStructureTrianglesOpacityMicromapEXT(const VkAccelerationStructureTrianglesOpacityMicromapEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAccelerationStructureTrianglesOpacityMicromapEXT( + const safe_VkAccelerationStructureTrianglesOpacityMicromapEXT& copy_src); + safe_VkAccelerationStructureTrianglesOpacityMicromapEXT& operator=( + const safe_VkAccelerationStructureTrianglesOpacityMicromapEXT& copy_src); + safe_VkAccelerationStructureTrianglesOpacityMicromapEXT(); + ~safe_VkAccelerationStructureTrianglesOpacityMicromapEXT(); + void initialize(const VkAccelerationStructureTrianglesOpacityMicromapEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureTrianglesOpacityMicromapEXT* copy_src, PNextCopyState* copy_state = {}); + VkAccelerationStructureTrianglesOpacityMicromapEXT* ptr() { + return reinterpret_cast(this); + } + VkAccelerationStructureTrianglesOpacityMicromapEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +#ifdef VK_ENABLE_BETA_EXTENSIONS +struct safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 displacementMicromap; + + safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV(const VkPhysicalDeviceDisplacementMicromapFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV(const safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV& copy_src); + safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV& operator=( + const safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV& copy_src); + safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV(); + ~safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV(); + void initialize(const VkPhysicalDeviceDisplacementMicromapFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDisplacementMicromapFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDisplacementMicromapFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV { + VkStructureType sType; + void* pNext{}; + uint32_t maxDisplacementMicromapSubdivisionLevel; + + safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV(const VkPhysicalDeviceDisplacementMicromapPropertiesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV(const safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV& copy_src); + safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV& operator=( + const safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV& copy_src); + safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV(); + ~safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV(); + void initialize(const VkPhysicalDeviceDisplacementMicromapPropertiesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDisplacementMicromapPropertiesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDisplacementMicromapPropertiesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAccelerationStructureTrianglesDisplacementMicromapNV { + VkStructureType sType; + void* pNext{}; + VkFormat displacementBiasAndScaleFormat; + VkFormat displacementVectorFormat; + safe_VkDeviceOrHostAddressConstKHR displacementBiasAndScaleBuffer; + VkDeviceSize displacementBiasAndScaleStride; + safe_VkDeviceOrHostAddressConstKHR displacementVectorBuffer; + VkDeviceSize displacementVectorStride; + safe_VkDeviceOrHostAddressConstKHR displacedMicromapPrimitiveFlags; + VkDeviceSize displacedMicromapPrimitiveFlagsStride; + VkIndexType indexType; + safe_VkDeviceOrHostAddressConstKHR indexBuffer; + VkDeviceSize indexStride; + uint32_t baseTriangle; + uint32_t usageCountsCount; + const VkMicromapUsageEXT* pUsageCounts{}; + const VkMicromapUsageEXT* const* ppUsageCounts{}; + VkMicromapEXT micromap; + + safe_VkAccelerationStructureTrianglesDisplacementMicromapNV( + const VkAccelerationStructureTrianglesDisplacementMicromapNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkAccelerationStructureTrianglesDisplacementMicromapNV( + const safe_VkAccelerationStructureTrianglesDisplacementMicromapNV& copy_src); + safe_VkAccelerationStructureTrianglesDisplacementMicromapNV& operator=( + const safe_VkAccelerationStructureTrianglesDisplacementMicromapNV& copy_src); + safe_VkAccelerationStructureTrianglesDisplacementMicromapNV(); + ~safe_VkAccelerationStructureTrianglesDisplacementMicromapNV(); + void initialize(const VkAccelerationStructureTrianglesDisplacementMicromapNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureTrianglesDisplacementMicromapNV* copy_src, PNextCopyState* copy_state = {}); + VkAccelerationStructureTrianglesDisplacementMicromapNV* ptr() { + return reinterpret_cast(this); + } + VkAccelerationStructureTrianglesDisplacementMicromapNV const* ptr() const { + return reinterpret_cast(this); + } +}; +#endif // VK_ENABLE_BETA_EXTENSIONS +struct safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI { + VkStructureType sType; + void* pNext{}; + VkBool32 clustercullingShader; + VkBool32 multiviewClusterCullingShader; + + safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI( + const safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI& copy_src); + safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI& operator=( + const safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI& copy_src); + safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(); + ~safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(); + void initialize(const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI { + VkStructureType sType; + void* pNext{}; + uint32_t maxWorkGroupCount[3]; + uint32_t maxWorkGroupSize[3]; + uint32_t maxOutputClusterCount; + VkDeviceSize indirectBufferOffsetAlignment; + + safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI( + const safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI& copy_src); + safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI& operator=( + const safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI& copy_src); + safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(); + ~safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(); + void initialize(const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI { + VkStructureType sType; + void* pNext{}; + VkBool32 clusterShadingRate; + + safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI( + const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI( + const safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& copy_src); + safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& operator=( + const safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& copy_src); + safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI(); + ~safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI(); + void initialize(const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 borderColorSwizzle; + VkBool32 borderColorSwizzleFromImage; + + safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(const safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& copy_src); + safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& operator=( + const safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& copy_src); + safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(); + ~safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(); + void initialize(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSamplerBorderColorComponentMappingCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkComponentMapping components; + VkBool32 srgb; + + safe_VkSamplerBorderColorComponentMappingCreateInfoEXT(const VkSamplerBorderColorComponentMappingCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSamplerBorderColorComponentMappingCreateInfoEXT(const safe_VkSamplerBorderColorComponentMappingCreateInfoEXT& copy_src); + safe_VkSamplerBorderColorComponentMappingCreateInfoEXT& operator=( + const safe_VkSamplerBorderColorComponentMappingCreateInfoEXT& copy_src); + safe_VkSamplerBorderColorComponentMappingCreateInfoEXT(); + ~safe_VkSamplerBorderColorComponentMappingCreateInfoEXT(); + void initialize(const VkSamplerBorderColorComponentMappingCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSamplerBorderColorComponentMappingCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkSamplerBorderColorComponentMappingCreateInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkSamplerBorderColorComponentMappingCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 pageableDeviceLocalMemory; + + safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT( + const safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& copy_src); + safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& operator=( + const safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& copy_src); + safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(); + ~safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(); + void initialize(const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderCorePropertiesARM { + VkStructureType sType; + void* pNext{}; + uint32_t pixelRate; + uint32_t texelRate; + uint32_t fmaRate; + + safe_VkPhysicalDeviceShaderCorePropertiesARM(const VkPhysicalDeviceShaderCorePropertiesARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderCorePropertiesARM(const safe_VkPhysicalDeviceShaderCorePropertiesARM& copy_src); + safe_VkPhysicalDeviceShaderCorePropertiesARM& operator=(const safe_VkPhysicalDeviceShaderCorePropertiesARM& copy_src); + safe_VkPhysicalDeviceShaderCorePropertiesARM(); + ~safe_VkPhysicalDeviceShaderCorePropertiesARM(); + void initialize(const VkPhysicalDeviceShaderCorePropertiesARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderCorePropertiesARM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderCorePropertiesARM* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceShaderCorePropertiesARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDeviceQueueShaderCoreControlCreateInfoARM { + VkStructureType sType; + void* pNext{}; + uint32_t shaderCoreCount; + + safe_VkDeviceQueueShaderCoreControlCreateInfoARM(const VkDeviceQueueShaderCoreControlCreateInfoARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDeviceQueueShaderCoreControlCreateInfoARM(const safe_VkDeviceQueueShaderCoreControlCreateInfoARM& copy_src); + safe_VkDeviceQueueShaderCoreControlCreateInfoARM& operator=(const safe_VkDeviceQueueShaderCoreControlCreateInfoARM& copy_src); + safe_VkDeviceQueueShaderCoreControlCreateInfoARM(); + ~safe_VkDeviceQueueShaderCoreControlCreateInfoARM(); + void initialize(const VkDeviceQueueShaderCoreControlCreateInfoARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDeviceQueueShaderCoreControlCreateInfoARM* copy_src, PNextCopyState* copy_state = {}); + VkDeviceQueueShaderCoreControlCreateInfoARM* ptr() { + return reinterpret_cast(this); + } + VkDeviceQueueShaderCoreControlCreateInfoARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceSchedulingControlsFeaturesARM { + VkStructureType sType; + void* pNext{}; + VkBool32 schedulingControls; + + safe_VkPhysicalDeviceSchedulingControlsFeaturesARM(const VkPhysicalDeviceSchedulingControlsFeaturesARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceSchedulingControlsFeaturesARM(const safe_VkPhysicalDeviceSchedulingControlsFeaturesARM& copy_src); + safe_VkPhysicalDeviceSchedulingControlsFeaturesARM& operator=( + const safe_VkPhysicalDeviceSchedulingControlsFeaturesARM& copy_src); + safe_VkPhysicalDeviceSchedulingControlsFeaturesARM(); + ~safe_VkPhysicalDeviceSchedulingControlsFeaturesARM(); + void initialize(const VkPhysicalDeviceSchedulingControlsFeaturesARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceSchedulingControlsFeaturesARM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceSchedulingControlsFeaturesARM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceSchedulingControlsFeaturesARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceSchedulingControlsPropertiesARM { + VkStructureType sType; + void* pNext{}; + VkPhysicalDeviceSchedulingControlsFlagsARM schedulingControlsFlags; + + safe_VkPhysicalDeviceSchedulingControlsPropertiesARM(const VkPhysicalDeviceSchedulingControlsPropertiesARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceSchedulingControlsPropertiesARM(const safe_VkPhysicalDeviceSchedulingControlsPropertiesARM& copy_src); + safe_VkPhysicalDeviceSchedulingControlsPropertiesARM& operator=( + const safe_VkPhysicalDeviceSchedulingControlsPropertiesARM& copy_src); + safe_VkPhysicalDeviceSchedulingControlsPropertiesARM(); + ~safe_VkPhysicalDeviceSchedulingControlsPropertiesARM(); + void initialize(const VkPhysicalDeviceSchedulingControlsPropertiesARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceSchedulingControlsPropertiesARM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceSchedulingControlsPropertiesARM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceSchedulingControlsPropertiesARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 imageSlicedViewOf3D; + + safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(const safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& copy_src); + safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& operator=( + const safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& copy_src); + safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(); + ~safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(); + void initialize(const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImageViewSlicedCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + uint32_t sliceOffset; + uint32_t sliceCount; + + safe_VkImageViewSlicedCreateInfoEXT(const VkImageViewSlicedCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImageViewSlicedCreateInfoEXT(const safe_VkImageViewSlicedCreateInfoEXT& copy_src); + safe_VkImageViewSlicedCreateInfoEXT& operator=(const safe_VkImageViewSlicedCreateInfoEXT& copy_src); + safe_VkImageViewSlicedCreateInfoEXT(); + ~safe_VkImageViewSlicedCreateInfoEXT(); + void initialize(const VkImageViewSlicedCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageViewSlicedCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkImageViewSlicedCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkImageViewSlicedCreateInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { + VkStructureType sType; + void* pNext{}; + VkBool32 descriptorSetHostMapping; + + safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE( + const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE( + const safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& copy_src); + safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& operator=( + const safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& copy_src); + safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(); + ~safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(); + void initialize(const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDescriptorSetBindingReferenceVALVE { + VkStructureType sType; + const void* pNext{}; + VkDescriptorSetLayout descriptorSetLayout; + uint32_t binding; + + safe_VkDescriptorSetBindingReferenceVALVE(const VkDescriptorSetBindingReferenceVALVE* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDescriptorSetBindingReferenceVALVE(const safe_VkDescriptorSetBindingReferenceVALVE& copy_src); + safe_VkDescriptorSetBindingReferenceVALVE& operator=(const safe_VkDescriptorSetBindingReferenceVALVE& copy_src); + safe_VkDescriptorSetBindingReferenceVALVE(); + ~safe_VkDescriptorSetBindingReferenceVALVE(); + void initialize(const VkDescriptorSetBindingReferenceVALVE* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDescriptorSetBindingReferenceVALVE* copy_src, PNextCopyState* copy_state = {}); + VkDescriptorSetBindingReferenceVALVE* ptr() { return reinterpret_cast(this); } + VkDescriptorSetBindingReferenceVALVE const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDescriptorSetLayoutHostMappingInfoVALVE { + VkStructureType sType; + void* pNext{}; + size_t descriptorOffset; + uint32_t descriptorSize; + + safe_VkDescriptorSetLayoutHostMappingInfoVALVE(const VkDescriptorSetLayoutHostMappingInfoVALVE* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkDescriptorSetLayoutHostMappingInfoVALVE(const safe_VkDescriptorSetLayoutHostMappingInfoVALVE& copy_src); + safe_VkDescriptorSetLayoutHostMappingInfoVALVE& operator=(const safe_VkDescriptorSetLayoutHostMappingInfoVALVE& copy_src); + safe_VkDescriptorSetLayoutHostMappingInfoVALVE(); + ~safe_VkDescriptorSetLayoutHostMappingInfoVALVE(); + void initialize(const VkDescriptorSetLayoutHostMappingInfoVALVE* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDescriptorSetLayoutHostMappingInfoVALVE* copy_src, PNextCopyState* copy_state = {}); + VkDescriptorSetLayoutHostMappingInfoVALVE* ptr() { return reinterpret_cast(this); } + VkDescriptorSetLayoutHostMappingInfoVALVE const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 depthClampZeroOne; + + safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT& copy_src); + safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT& operator=(const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT& copy_src); + safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(); + ~safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(); + void initialize(const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDepthClampZeroOneFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 nonSeamlessCubeMap; + + safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(const safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& copy_src); + safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& operator=( + const safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& copy_src); + safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(); + ~safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(); + void initialize(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceRenderPassStripedFeaturesARM { + VkStructureType sType; + void* pNext{}; + VkBool32 renderPassStriped; + + safe_VkPhysicalDeviceRenderPassStripedFeaturesARM(const VkPhysicalDeviceRenderPassStripedFeaturesARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceRenderPassStripedFeaturesARM(const safe_VkPhysicalDeviceRenderPassStripedFeaturesARM& copy_src); + safe_VkPhysicalDeviceRenderPassStripedFeaturesARM& operator=(const safe_VkPhysicalDeviceRenderPassStripedFeaturesARM& copy_src); + safe_VkPhysicalDeviceRenderPassStripedFeaturesARM(); + ~safe_VkPhysicalDeviceRenderPassStripedFeaturesARM(); + void initialize(const VkPhysicalDeviceRenderPassStripedFeaturesARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceRenderPassStripedFeaturesARM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceRenderPassStripedFeaturesARM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceRenderPassStripedFeaturesARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceRenderPassStripedPropertiesARM { + VkStructureType sType; + void* pNext{}; + VkExtent2D renderPassStripeGranularity; + uint32_t maxRenderPassStripes; + + safe_VkPhysicalDeviceRenderPassStripedPropertiesARM(const VkPhysicalDeviceRenderPassStripedPropertiesARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceRenderPassStripedPropertiesARM(const safe_VkPhysicalDeviceRenderPassStripedPropertiesARM& copy_src); + safe_VkPhysicalDeviceRenderPassStripedPropertiesARM& operator=( + const safe_VkPhysicalDeviceRenderPassStripedPropertiesARM& copy_src); + safe_VkPhysicalDeviceRenderPassStripedPropertiesARM(); + ~safe_VkPhysicalDeviceRenderPassStripedPropertiesARM(); + void initialize(const VkPhysicalDeviceRenderPassStripedPropertiesARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceRenderPassStripedPropertiesARM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceRenderPassStripedPropertiesARM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceRenderPassStripedPropertiesARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRenderPassStripeInfoARM { + VkStructureType sType; + const void* pNext{}; + VkRect2D stripeArea; + + safe_VkRenderPassStripeInfoARM(const VkRenderPassStripeInfoARM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkRenderPassStripeInfoARM(const safe_VkRenderPassStripeInfoARM& copy_src); + safe_VkRenderPassStripeInfoARM& operator=(const safe_VkRenderPassStripeInfoARM& copy_src); + safe_VkRenderPassStripeInfoARM(); + ~safe_VkRenderPassStripeInfoARM(); + void initialize(const VkRenderPassStripeInfoARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderPassStripeInfoARM* copy_src, PNextCopyState* copy_state = {}); + VkRenderPassStripeInfoARM* ptr() { return reinterpret_cast(this); } + VkRenderPassStripeInfoARM const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkRenderPassStripeBeginInfoARM { + VkStructureType sType; + const void* pNext{}; + uint32_t stripeInfoCount; + safe_VkRenderPassStripeInfoARM* pStripeInfos{}; + + safe_VkRenderPassStripeBeginInfoARM(const VkRenderPassStripeBeginInfoARM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkRenderPassStripeBeginInfoARM(const safe_VkRenderPassStripeBeginInfoARM& copy_src); + safe_VkRenderPassStripeBeginInfoARM& operator=(const safe_VkRenderPassStripeBeginInfoARM& copy_src); + safe_VkRenderPassStripeBeginInfoARM(); + ~safe_VkRenderPassStripeBeginInfoARM(); + void initialize(const VkRenderPassStripeBeginInfoARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderPassStripeBeginInfoARM* copy_src, PNextCopyState* copy_state = {}); + VkRenderPassStripeBeginInfoARM* ptr() { return reinterpret_cast(this); } + VkRenderPassStripeBeginInfoARM const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkRenderPassStripeSubmitInfoARM { + VkStructureType sType; + const void* pNext{}; + uint32_t stripeSemaphoreInfoCount; + safe_VkSemaphoreSubmitInfo* pStripeSemaphoreInfos{}; + + safe_VkRenderPassStripeSubmitInfoARM(const VkRenderPassStripeSubmitInfoARM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkRenderPassStripeSubmitInfoARM(const safe_VkRenderPassStripeSubmitInfoARM& copy_src); + safe_VkRenderPassStripeSubmitInfoARM& operator=(const safe_VkRenderPassStripeSubmitInfoARM& copy_src); + safe_VkRenderPassStripeSubmitInfoARM(); + ~safe_VkRenderPassStripeSubmitInfoARM(); + void initialize(const VkRenderPassStripeSubmitInfoARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderPassStripeSubmitInfoARM* copy_src, PNextCopyState* copy_state = {}); + VkRenderPassStripeSubmitInfoARM* ptr() { return reinterpret_cast(this); } + VkRenderPassStripeSubmitInfoARM const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { + VkStructureType sType; + void* pNext{}; + VkBool32 fragmentDensityMapOffset; + + safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM( + const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& operator=( + const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(); + ~safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(); + void initialize(const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { + VkStructureType sType; + void* pNext{}; + VkExtent2D fragmentDensityOffsetGranularity; + + safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM( + const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM( + const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& copy_src); + safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& operator=( + const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& copy_src); + safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(); + ~safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(); + void initialize(const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM { + VkStructureType sType; + const void* pNext{}; + uint32_t fragmentDensityOffsetCount; + const VkOffset2D* pFragmentDensityOffsets{}; + + safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM& copy_src); + safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM& operator=(const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM& copy_src); + safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(); + ~safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(); + void initialize(const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM* copy_src, PNextCopyState* copy_state = {}); + VkSubpassFragmentDensityMapOffsetEndInfoQCOM* ptr() { + return reinterpret_cast(this); + } + VkSubpassFragmentDensityMapOffsetEndInfoQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 indirectCopy; + + safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV& copy_src); + safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV& operator=(const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV& copy_src); + safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(); + ~safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(); + void initialize(const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceCopyMemoryIndirectFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV { + VkStructureType sType; + void* pNext{}; + VkQueueFlags supportedQueues; + + safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV& copy_src); + safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV& operator=( + const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV& copy_src); + safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(); + ~safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(); + void initialize(const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceCopyMemoryIndirectPropertiesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 memoryDecompression; + + safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV(const VkPhysicalDeviceMemoryDecompressionFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV(const safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV& copy_src); + safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV& operator=( + const safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV& copy_src); + safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV(); + ~safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV(); + void initialize(const VkPhysicalDeviceMemoryDecompressionFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMemoryDecompressionFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceMemoryDecompressionFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV { + VkStructureType sType; + void* pNext{}; + VkMemoryDecompressionMethodFlagsNV decompressionMethods; + uint64_t maxDecompressionIndirectCount; + + safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV(const VkPhysicalDeviceMemoryDecompressionPropertiesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV(const safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV& copy_src); + safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV& operator=( + const safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV& copy_src); + safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV(); + ~safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV(); + void initialize(const VkPhysicalDeviceMemoryDecompressionPropertiesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMemoryDecompressionPropertiesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceMemoryDecompressionPropertiesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 deviceGeneratedCompute; + VkBool32 deviceGeneratedComputePipelines; + VkBool32 deviceGeneratedComputeCaptureReplay; + + safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV( + const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& copy_src); + safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& operator=( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& copy_src); + safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV(); + ~safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV(); + void initialize(const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkComputePipelineIndirectBufferInfoNV { + VkStructureType sType; + const void* pNext{}; + VkDeviceAddress deviceAddress; + VkDeviceSize size; + VkDeviceAddress pipelineDeviceAddressCaptureReplay; + + safe_VkComputePipelineIndirectBufferInfoNV(const VkComputePipelineIndirectBufferInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkComputePipelineIndirectBufferInfoNV(const safe_VkComputePipelineIndirectBufferInfoNV& copy_src); + safe_VkComputePipelineIndirectBufferInfoNV& operator=(const safe_VkComputePipelineIndirectBufferInfoNV& copy_src); + safe_VkComputePipelineIndirectBufferInfoNV(); + ~safe_VkComputePipelineIndirectBufferInfoNV(); + void initialize(const VkComputePipelineIndirectBufferInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkComputePipelineIndirectBufferInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkComputePipelineIndirectBufferInfoNV* ptr() { return reinterpret_cast(this); } + VkComputePipelineIndirectBufferInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineIndirectDeviceAddressInfoNV { + VkStructureType sType; + const void* pNext{}; + VkPipelineBindPoint pipelineBindPoint; + VkPipeline pipeline; + + safe_VkPipelineIndirectDeviceAddressInfoNV(const VkPipelineIndirectDeviceAddressInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineIndirectDeviceAddressInfoNV(const safe_VkPipelineIndirectDeviceAddressInfoNV& copy_src); + safe_VkPipelineIndirectDeviceAddressInfoNV& operator=(const safe_VkPipelineIndirectDeviceAddressInfoNV& copy_src); + safe_VkPipelineIndirectDeviceAddressInfoNV(); + ~safe_VkPipelineIndirectDeviceAddressInfoNV(); + void initialize(const VkPipelineIndirectDeviceAddressInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineIndirectDeviceAddressInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkPipelineIndirectDeviceAddressInfoNV* ptr() { return reinterpret_cast(this); } + VkPipelineIndirectDeviceAddressInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 linearColorAttachment; + + safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(const safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV& copy_src); + safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV& operator=( + const safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV& copy_src); + safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(); + ~safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(); + void initialize(const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceLinearColorAttachmentFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceLinearColorAttachmentFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 imageCompressionControlSwapchain; + + safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT( + const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT( + const safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& copy_src); + safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& operator=( + const safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& copy_src); + safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(); + ~safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(); + void initialize(const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* copy_src, + PNextCopyState* copy_state = {}); + VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImageViewSampleWeightCreateInfoQCOM { + VkStructureType sType; + const void* pNext{}; + VkOffset2D filterCenter; + VkExtent2D filterSize; + uint32_t numPhases; + + safe_VkImageViewSampleWeightCreateInfoQCOM(const VkImageViewSampleWeightCreateInfoQCOM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkImageViewSampleWeightCreateInfoQCOM(const safe_VkImageViewSampleWeightCreateInfoQCOM& copy_src); + safe_VkImageViewSampleWeightCreateInfoQCOM& operator=(const safe_VkImageViewSampleWeightCreateInfoQCOM& copy_src); + safe_VkImageViewSampleWeightCreateInfoQCOM(); + ~safe_VkImageViewSampleWeightCreateInfoQCOM(); + void initialize(const VkImageViewSampleWeightCreateInfoQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImageViewSampleWeightCreateInfoQCOM* copy_src, PNextCopyState* copy_state = {}); + VkImageViewSampleWeightCreateInfoQCOM* ptr() { return reinterpret_cast(this); } + VkImageViewSampleWeightCreateInfoQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceImageProcessingFeaturesQCOM { + VkStructureType sType; + void* pNext{}; + VkBool32 textureSampleWeighted; + VkBool32 textureBoxFilter; + VkBool32 textureBlockMatch; + + safe_VkPhysicalDeviceImageProcessingFeaturesQCOM(const VkPhysicalDeviceImageProcessingFeaturesQCOM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceImageProcessingFeaturesQCOM(const safe_VkPhysicalDeviceImageProcessingFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceImageProcessingFeaturesQCOM& operator=(const safe_VkPhysicalDeviceImageProcessingFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceImageProcessingFeaturesQCOM(); + ~safe_VkPhysicalDeviceImageProcessingFeaturesQCOM(); + void initialize(const VkPhysicalDeviceImageProcessingFeaturesQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceImageProcessingFeaturesQCOM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceImageProcessingFeaturesQCOM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceImageProcessingFeaturesQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceImageProcessingPropertiesQCOM { + VkStructureType sType; + void* pNext{}; + uint32_t maxWeightFilterPhases; + VkExtent2D maxWeightFilterDimension; + VkExtent2D maxBlockMatchRegion; + VkExtent2D maxBoxFilterBlockSize; + + safe_VkPhysicalDeviceImageProcessingPropertiesQCOM(const VkPhysicalDeviceImageProcessingPropertiesQCOM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceImageProcessingPropertiesQCOM(const safe_VkPhysicalDeviceImageProcessingPropertiesQCOM& copy_src); + safe_VkPhysicalDeviceImageProcessingPropertiesQCOM& operator=( + const safe_VkPhysicalDeviceImageProcessingPropertiesQCOM& copy_src); + safe_VkPhysicalDeviceImageProcessingPropertiesQCOM(); + ~safe_VkPhysicalDeviceImageProcessingPropertiesQCOM(); + void initialize(const VkPhysicalDeviceImageProcessingPropertiesQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceImageProcessingPropertiesQCOM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceImageProcessingPropertiesQCOM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceImageProcessingPropertiesQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 nestedCommandBuffer; + VkBool32 nestedCommandBufferRendering; + VkBool32 nestedCommandBufferSimultaneousUse; + + safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT(const VkPhysicalDeviceNestedCommandBufferFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT(const safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT& copy_src); + safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT& operator=( + const safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT& copy_src); + safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT(); + ~safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT(); + void initialize(const VkPhysicalDeviceNestedCommandBufferFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceNestedCommandBufferFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceNestedCommandBufferFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT { + VkStructureType sType; + void* pNext{}; + uint32_t maxCommandBufferNestingLevel; + + safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT(const VkPhysicalDeviceNestedCommandBufferPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT(const safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT& copy_src); + safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT& operator=( + const safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT& copy_src); + safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT(); + ~safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT(); + void initialize(const VkPhysicalDeviceNestedCommandBufferPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceNestedCommandBufferPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceNestedCommandBufferPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkExternalMemoryAcquireUnmodifiedEXT { + VkStructureType sType; + const void* pNext{}; + VkBool32 acquireUnmodifiedMemory; + + safe_VkExternalMemoryAcquireUnmodifiedEXT(const VkExternalMemoryAcquireUnmodifiedEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkExternalMemoryAcquireUnmodifiedEXT(const safe_VkExternalMemoryAcquireUnmodifiedEXT& copy_src); + safe_VkExternalMemoryAcquireUnmodifiedEXT& operator=(const safe_VkExternalMemoryAcquireUnmodifiedEXT& copy_src); + safe_VkExternalMemoryAcquireUnmodifiedEXT(); + ~safe_VkExternalMemoryAcquireUnmodifiedEXT(); + void initialize(const VkExternalMemoryAcquireUnmodifiedEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExternalMemoryAcquireUnmodifiedEXT* copy_src, PNextCopyState* copy_state = {}); + VkExternalMemoryAcquireUnmodifiedEXT* ptr() { return reinterpret_cast(this); } + VkExternalMemoryAcquireUnmodifiedEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 extendedDynamicState3TessellationDomainOrigin; + VkBool32 extendedDynamicState3DepthClampEnable; + VkBool32 extendedDynamicState3PolygonMode; + VkBool32 extendedDynamicState3RasterizationSamples; + VkBool32 extendedDynamicState3SampleMask; + VkBool32 extendedDynamicState3AlphaToCoverageEnable; + VkBool32 extendedDynamicState3AlphaToOneEnable; + VkBool32 extendedDynamicState3LogicOpEnable; + VkBool32 extendedDynamicState3ColorBlendEnable; + VkBool32 extendedDynamicState3ColorBlendEquation; + VkBool32 extendedDynamicState3ColorWriteMask; + VkBool32 extendedDynamicState3RasterizationStream; + VkBool32 extendedDynamicState3ConservativeRasterizationMode; + VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize; + VkBool32 extendedDynamicState3DepthClipEnable; + VkBool32 extendedDynamicState3SampleLocationsEnable; + VkBool32 extendedDynamicState3ColorBlendAdvanced; + VkBool32 extendedDynamicState3ProvokingVertexMode; + VkBool32 extendedDynamicState3LineRasterizationMode; + VkBool32 extendedDynamicState3LineStippleEnable; + VkBool32 extendedDynamicState3DepthClipNegativeOneToOne; + VkBool32 extendedDynamicState3ViewportWScalingEnable; + VkBool32 extendedDynamicState3ViewportSwizzle; + VkBool32 extendedDynamicState3CoverageToColorEnable; + VkBool32 extendedDynamicState3CoverageToColorLocation; + VkBool32 extendedDynamicState3CoverageModulationMode; + VkBool32 extendedDynamicState3CoverageModulationTableEnable; + VkBool32 extendedDynamicState3CoverageModulationTable; + VkBool32 extendedDynamicState3CoverageReductionMode; + VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable; + VkBool32 extendedDynamicState3ShadingRateImageEnable; + + safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(const safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT& copy_src); + safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT& operator=( + const safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT& copy_src); + safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(); + ~safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(); + void initialize(const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceExtendedDynamicState3FeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 dynamicPrimitiveTopologyUnrestricted; + + safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT( + const safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT& copy_src); + safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT& operator=( + const safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT& copy_src); + safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(); + ~safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(); + void initialize(const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceExtendedDynamicState3PropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 subpassMergeFeedback; + + safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(const safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& copy_src); + safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& operator=( + const safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& copy_src); + safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(); + ~safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(); + void initialize(const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRenderPassCreationControlEXT { + VkStructureType sType; + const void* pNext{}; + VkBool32 disallowMerging; + + safe_VkRenderPassCreationControlEXT(const VkRenderPassCreationControlEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkRenderPassCreationControlEXT(const safe_VkRenderPassCreationControlEXT& copy_src); + safe_VkRenderPassCreationControlEXT& operator=(const safe_VkRenderPassCreationControlEXT& copy_src); + safe_VkRenderPassCreationControlEXT(); + ~safe_VkRenderPassCreationControlEXT(); + void initialize(const VkRenderPassCreationControlEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderPassCreationControlEXT* copy_src, PNextCopyState* copy_state = {}); + VkRenderPassCreationControlEXT* ptr() { return reinterpret_cast(this); } + VkRenderPassCreationControlEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkRenderPassCreationFeedbackCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkRenderPassCreationFeedbackInfoEXT* pRenderPassFeedback{}; + + safe_VkRenderPassCreationFeedbackCreateInfoEXT(const VkRenderPassCreationFeedbackCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkRenderPassCreationFeedbackCreateInfoEXT(const safe_VkRenderPassCreationFeedbackCreateInfoEXT& copy_src); + safe_VkRenderPassCreationFeedbackCreateInfoEXT& operator=(const safe_VkRenderPassCreationFeedbackCreateInfoEXT& copy_src); + safe_VkRenderPassCreationFeedbackCreateInfoEXT(); + ~safe_VkRenderPassCreationFeedbackCreateInfoEXT(); + void initialize(const VkRenderPassCreationFeedbackCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderPassCreationFeedbackCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkRenderPassCreationFeedbackCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkRenderPassCreationFeedbackCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRenderPassSubpassFeedbackCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkRenderPassSubpassFeedbackInfoEXT* pSubpassFeedback{}; + + safe_VkRenderPassSubpassFeedbackCreateInfoEXT(const VkRenderPassSubpassFeedbackCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkRenderPassSubpassFeedbackCreateInfoEXT(const safe_VkRenderPassSubpassFeedbackCreateInfoEXT& copy_src); + safe_VkRenderPassSubpassFeedbackCreateInfoEXT& operator=(const safe_VkRenderPassSubpassFeedbackCreateInfoEXT& copy_src); + safe_VkRenderPassSubpassFeedbackCreateInfoEXT(); + ~safe_VkRenderPassSubpassFeedbackCreateInfoEXT(); + void initialize(const VkRenderPassSubpassFeedbackCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRenderPassSubpassFeedbackCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkRenderPassSubpassFeedbackCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkRenderPassSubpassFeedbackCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkDirectDriverLoadingInfoLUNARG { + VkStructureType sType; + void* pNext{}; + VkDirectDriverLoadingFlagsLUNARG flags; + PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr; + + safe_VkDirectDriverLoadingInfoLUNARG(const VkDirectDriverLoadingInfoLUNARG* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDirectDriverLoadingInfoLUNARG(const safe_VkDirectDriverLoadingInfoLUNARG& copy_src); + safe_VkDirectDriverLoadingInfoLUNARG& operator=(const safe_VkDirectDriverLoadingInfoLUNARG& copy_src); + safe_VkDirectDriverLoadingInfoLUNARG(); + ~safe_VkDirectDriverLoadingInfoLUNARG(); + void initialize(const VkDirectDriverLoadingInfoLUNARG* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDirectDriverLoadingInfoLUNARG* copy_src, PNextCopyState* copy_state = {}); + VkDirectDriverLoadingInfoLUNARG* ptr() { return reinterpret_cast(this); } + VkDirectDriverLoadingInfoLUNARG const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkDirectDriverLoadingListLUNARG { + VkStructureType sType; + const void* pNext{}; + VkDirectDriverLoadingModeLUNARG mode; + uint32_t driverCount; + safe_VkDirectDriverLoadingInfoLUNARG* pDrivers{}; + + safe_VkDirectDriverLoadingListLUNARG(const VkDirectDriverLoadingListLUNARG* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkDirectDriverLoadingListLUNARG(const safe_VkDirectDriverLoadingListLUNARG& copy_src); + safe_VkDirectDriverLoadingListLUNARG& operator=(const safe_VkDirectDriverLoadingListLUNARG& copy_src); + safe_VkDirectDriverLoadingListLUNARG(); + ~safe_VkDirectDriverLoadingListLUNARG(); + void initialize(const VkDirectDriverLoadingListLUNARG* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkDirectDriverLoadingListLUNARG* copy_src, PNextCopyState* copy_state = {}); + VkDirectDriverLoadingListLUNARG* ptr() { return reinterpret_cast(this); } + VkDirectDriverLoadingListLUNARG const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderModuleIdentifier; + + safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(const safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& copy_src); + safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& operator=( + const safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& copy_src); + safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(); + ~safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(); + void initialize(const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT { + VkStructureType sType; + void* pNext{}; + uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE]; + + safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT( + const safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& copy_src); + safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& operator=( + const safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& copy_src); + safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(); + ~safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(); + void initialize(const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + uint32_t identifierSize; + const uint8_t* pIdentifier{}; + + safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT( + const safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT& copy_src); + safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT& operator=( + const safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT& copy_src); + safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(); + ~safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(); + void initialize(const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkPipelineShaderStageModuleIdentifierCreateInfoEXT* ptr() { + return reinterpret_cast(this); + } + VkPipelineShaderStageModuleIdentifierCreateInfoEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkShaderModuleIdentifierEXT { + VkStructureType sType; + void* pNext{}; + uint32_t identifierSize; + uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]; + + safe_VkShaderModuleIdentifierEXT(const VkShaderModuleIdentifierEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkShaderModuleIdentifierEXT(const safe_VkShaderModuleIdentifierEXT& copy_src); + safe_VkShaderModuleIdentifierEXT& operator=(const safe_VkShaderModuleIdentifierEXT& copy_src); + safe_VkShaderModuleIdentifierEXT(); + ~safe_VkShaderModuleIdentifierEXT(); + void initialize(const VkShaderModuleIdentifierEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkShaderModuleIdentifierEXT* copy_src, PNextCopyState* copy_state = {}); + VkShaderModuleIdentifierEXT* ptr() { return reinterpret_cast(this); } + VkShaderModuleIdentifierEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceOpticalFlowFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 opticalFlow; + + safe_VkPhysicalDeviceOpticalFlowFeaturesNV(const VkPhysicalDeviceOpticalFlowFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceOpticalFlowFeaturesNV(const safe_VkPhysicalDeviceOpticalFlowFeaturesNV& copy_src); + safe_VkPhysicalDeviceOpticalFlowFeaturesNV& operator=(const safe_VkPhysicalDeviceOpticalFlowFeaturesNV& copy_src); + safe_VkPhysicalDeviceOpticalFlowFeaturesNV(); + ~safe_VkPhysicalDeviceOpticalFlowFeaturesNV(); + void initialize(const VkPhysicalDeviceOpticalFlowFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceOpticalFlowFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceOpticalFlowFeaturesNV* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceOpticalFlowFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceOpticalFlowPropertiesNV { + VkStructureType sType; + void* pNext{}; + VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes; + VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes; + VkBool32 hintSupported; + VkBool32 costSupported; + VkBool32 bidirectionalFlowSupported; + VkBool32 globalFlowSupported; + uint32_t minWidth; + uint32_t minHeight; + uint32_t maxWidth; + uint32_t maxHeight; + uint32_t maxNumRegionsOfInterest; + + safe_VkPhysicalDeviceOpticalFlowPropertiesNV(const VkPhysicalDeviceOpticalFlowPropertiesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceOpticalFlowPropertiesNV(const safe_VkPhysicalDeviceOpticalFlowPropertiesNV& copy_src); + safe_VkPhysicalDeviceOpticalFlowPropertiesNV& operator=(const safe_VkPhysicalDeviceOpticalFlowPropertiesNV& copy_src); + safe_VkPhysicalDeviceOpticalFlowPropertiesNV(); + ~safe_VkPhysicalDeviceOpticalFlowPropertiesNV(); + void initialize(const VkPhysicalDeviceOpticalFlowPropertiesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceOpticalFlowPropertiesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceOpticalFlowPropertiesNV* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceOpticalFlowPropertiesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkOpticalFlowImageFormatInfoNV { + VkStructureType sType; + const void* pNext{}; + VkOpticalFlowUsageFlagsNV usage; + + safe_VkOpticalFlowImageFormatInfoNV(const VkOpticalFlowImageFormatInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkOpticalFlowImageFormatInfoNV(const safe_VkOpticalFlowImageFormatInfoNV& copy_src); + safe_VkOpticalFlowImageFormatInfoNV& operator=(const safe_VkOpticalFlowImageFormatInfoNV& copy_src); + safe_VkOpticalFlowImageFormatInfoNV(); + ~safe_VkOpticalFlowImageFormatInfoNV(); + void initialize(const VkOpticalFlowImageFormatInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkOpticalFlowImageFormatInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkOpticalFlowImageFormatInfoNV* ptr() { return reinterpret_cast(this); } + VkOpticalFlowImageFormatInfoNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkOpticalFlowImageFormatPropertiesNV { + VkStructureType sType; + const void* pNext{}; + VkFormat format; + + safe_VkOpticalFlowImageFormatPropertiesNV(const VkOpticalFlowImageFormatPropertiesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkOpticalFlowImageFormatPropertiesNV(const safe_VkOpticalFlowImageFormatPropertiesNV& copy_src); + safe_VkOpticalFlowImageFormatPropertiesNV& operator=(const safe_VkOpticalFlowImageFormatPropertiesNV& copy_src); + safe_VkOpticalFlowImageFormatPropertiesNV(); + ~safe_VkOpticalFlowImageFormatPropertiesNV(); + void initialize(const VkOpticalFlowImageFormatPropertiesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkOpticalFlowImageFormatPropertiesNV* copy_src, PNextCopyState* copy_state = {}); + VkOpticalFlowImageFormatPropertiesNV* ptr() { return reinterpret_cast(this); } + VkOpticalFlowImageFormatPropertiesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkOpticalFlowSessionCreateInfoNV { + VkStructureType sType; + void* pNext{}; + uint32_t width; + uint32_t height; + VkFormat imageFormat; + VkFormat flowVectorFormat; + VkFormat costFormat; + VkOpticalFlowGridSizeFlagsNV outputGridSize; + VkOpticalFlowGridSizeFlagsNV hintGridSize; + VkOpticalFlowPerformanceLevelNV performanceLevel; + VkOpticalFlowSessionCreateFlagsNV flags; + + safe_VkOpticalFlowSessionCreateInfoNV(const VkOpticalFlowSessionCreateInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkOpticalFlowSessionCreateInfoNV(const safe_VkOpticalFlowSessionCreateInfoNV& copy_src); + safe_VkOpticalFlowSessionCreateInfoNV& operator=(const safe_VkOpticalFlowSessionCreateInfoNV& copy_src); + safe_VkOpticalFlowSessionCreateInfoNV(); + ~safe_VkOpticalFlowSessionCreateInfoNV(); + void initialize(const VkOpticalFlowSessionCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkOpticalFlowSessionCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkOpticalFlowSessionCreateInfoNV* ptr() { return reinterpret_cast(this); } + VkOpticalFlowSessionCreateInfoNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkOpticalFlowSessionCreatePrivateDataInfoNV { + VkStructureType sType; + void* pNext{}; + uint32_t id; + uint32_t size; + const void* pPrivateData{}; + + safe_VkOpticalFlowSessionCreatePrivateDataInfoNV(const VkOpticalFlowSessionCreatePrivateDataInfoNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkOpticalFlowSessionCreatePrivateDataInfoNV(const safe_VkOpticalFlowSessionCreatePrivateDataInfoNV& copy_src); + safe_VkOpticalFlowSessionCreatePrivateDataInfoNV& operator=(const safe_VkOpticalFlowSessionCreatePrivateDataInfoNV& copy_src); + safe_VkOpticalFlowSessionCreatePrivateDataInfoNV(); + ~safe_VkOpticalFlowSessionCreatePrivateDataInfoNV(); + void initialize(const VkOpticalFlowSessionCreatePrivateDataInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkOpticalFlowSessionCreatePrivateDataInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkOpticalFlowSessionCreatePrivateDataInfoNV* ptr() { + return reinterpret_cast(this); + } + VkOpticalFlowSessionCreatePrivateDataInfoNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkOpticalFlowExecuteInfoNV { + VkStructureType sType; + void* pNext{}; + VkOpticalFlowExecuteFlagsNV flags; + uint32_t regionCount; + const VkRect2D* pRegions{}; + + safe_VkOpticalFlowExecuteInfoNV(const VkOpticalFlowExecuteInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkOpticalFlowExecuteInfoNV(const safe_VkOpticalFlowExecuteInfoNV& copy_src); + safe_VkOpticalFlowExecuteInfoNV& operator=(const safe_VkOpticalFlowExecuteInfoNV& copy_src); + safe_VkOpticalFlowExecuteInfoNV(); + ~safe_VkOpticalFlowExecuteInfoNV(); + void initialize(const VkOpticalFlowExecuteInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkOpticalFlowExecuteInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkOpticalFlowExecuteInfoNV* ptr() { return reinterpret_cast(this); } + VkOpticalFlowExecuteInfoNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 legacyDithering; + + safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT(const VkPhysicalDeviceLegacyDitheringFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT(const safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT& copy_src); + safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT& operator=(const safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT& copy_src); + safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT(); + ~safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT(); + void initialize(const VkPhysicalDeviceLegacyDitheringFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceLegacyDitheringFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceLegacyDitheringFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 pipelineProtectedAccess; + + safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT( + const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& copy_src); + safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& operator=( + const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& copy_src); + safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(); + ~safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(); + void initialize(const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDevicePipelineProtectedAccessFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +#ifdef VK_USE_PLATFORM_ANDROID_KHR +struct safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID { + VkStructureType sType; + void* pNext{}; + VkBool32 externalFormatResolve; + + safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID(const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID( + const safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID& copy_src); + safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID& operator=( + const safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID& copy_src); + safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID(); + ~safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID(); + void initialize(const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceExternalFormatResolveFeaturesANDROID const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID { + VkStructureType sType; + void* pNext{}; + VkBool32 nullColorAttachmentWithExternalFormatResolve; + VkChromaLocation externalFormatResolveChromaOffsetX; + VkChromaLocation externalFormatResolveChromaOffsetY; + + safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID( + const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID( + const safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID& copy_src); + safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID& operator=( + const safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID& copy_src); + safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID(); + ~safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID(); + void initialize(const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceExternalFormatResolvePropertiesANDROID const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID { + VkStructureType sType; + void* pNext{}; + VkFormat colorAttachmentFormat; + + safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID( + const VkAndroidHardwareBufferFormatResolvePropertiesANDROID* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID( + const safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID& copy_src); + safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID& operator=( + const safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID& copy_src); + safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID(); + ~safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID(); + void initialize(const VkAndroidHardwareBufferFormatResolvePropertiesANDROID* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID* copy_src, PNextCopyState* copy_state = {}); + VkAndroidHardwareBufferFormatResolvePropertiesANDROID* ptr() { + return reinterpret_cast(this); + } + VkAndroidHardwareBufferFormatResolvePropertiesANDROID const* ptr() const { + return reinterpret_cast(this); + } +}; +#endif // VK_USE_PLATFORM_ANDROID_KHR +struct safe_VkPhysicalDeviceShaderObjectFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderObject; + + safe_VkPhysicalDeviceShaderObjectFeaturesEXT(const VkPhysicalDeviceShaderObjectFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderObjectFeaturesEXT(const safe_VkPhysicalDeviceShaderObjectFeaturesEXT& copy_src); + safe_VkPhysicalDeviceShaderObjectFeaturesEXT& operator=(const safe_VkPhysicalDeviceShaderObjectFeaturesEXT& copy_src); + safe_VkPhysicalDeviceShaderObjectFeaturesEXT(); + ~safe_VkPhysicalDeviceShaderObjectFeaturesEXT(); + void initialize(const VkPhysicalDeviceShaderObjectFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderObjectFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderObjectFeaturesEXT* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceShaderObjectFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderObjectPropertiesEXT { + VkStructureType sType; + void* pNext{}; + uint8_t shaderBinaryUUID[VK_UUID_SIZE]; + uint32_t shaderBinaryVersion; + + safe_VkPhysicalDeviceShaderObjectPropertiesEXT(const VkPhysicalDeviceShaderObjectPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderObjectPropertiesEXT(const safe_VkPhysicalDeviceShaderObjectPropertiesEXT& copy_src); + safe_VkPhysicalDeviceShaderObjectPropertiesEXT& operator=(const safe_VkPhysicalDeviceShaderObjectPropertiesEXT& copy_src); + safe_VkPhysicalDeviceShaderObjectPropertiesEXT(); + ~safe_VkPhysicalDeviceShaderObjectPropertiesEXT(); + void initialize(const VkPhysicalDeviceShaderObjectPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderObjectPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderObjectPropertiesEXT* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceShaderObjectPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkShaderCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + VkShaderCreateFlagsEXT flags; + VkShaderStageFlagBits stage; + VkShaderStageFlags nextStage; + VkShaderCodeTypeEXT codeType; + size_t codeSize; + const void* pCode{}; + const char* pName{}; + uint32_t setLayoutCount; + VkDescriptorSetLayout* pSetLayouts{}; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges{}; + safe_VkSpecializationInfo* pSpecializationInfo{}; + + safe_VkShaderCreateInfoEXT(const VkShaderCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkShaderCreateInfoEXT(const safe_VkShaderCreateInfoEXT& copy_src); + safe_VkShaderCreateInfoEXT& operator=(const safe_VkShaderCreateInfoEXT& copy_src); + safe_VkShaderCreateInfoEXT(); + ~safe_VkShaderCreateInfoEXT(); + void initialize(const VkShaderCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkShaderCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkShaderCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkShaderCreateInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM { + VkStructureType sType; + void* pNext{}; + VkBool32 tileProperties; + + safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM(const VkPhysicalDeviceTilePropertiesFeaturesQCOM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM(const safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM& operator=(const safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM(); + ~safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM(); + void initialize(const VkPhysicalDeviceTilePropertiesFeaturesQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceTilePropertiesFeaturesQCOM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceTilePropertiesFeaturesQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkTilePropertiesQCOM { + VkStructureType sType; + void* pNext{}; + VkExtent3D tileSize; + VkExtent2D apronSize; + VkOffset2D origin; + + safe_VkTilePropertiesQCOM(const VkTilePropertiesQCOM* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkTilePropertiesQCOM(const safe_VkTilePropertiesQCOM& copy_src); + safe_VkTilePropertiesQCOM& operator=(const safe_VkTilePropertiesQCOM& copy_src); + safe_VkTilePropertiesQCOM(); + ~safe_VkTilePropertiesQCOM(); + void initialize(const VkTilePropertiesQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkTilePropertiesQCOM* copy_src, PNextCopyState* copy_state = {}); + VkTilePropertiesQCOM* ptr() { return reinterpret_cast(this); } + VkTilePropertiesQCOM const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC { + VkStructureType sType; + void* pNext{}; + VkBool32 amigoProfiling; + + safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC(const VkPhysicalDeviceAmigoProfilingFeaturesSEC* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC(const safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC& copy_src); + safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC& operator=(const safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC& copy_src); + safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC(); + ~safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC(); + void initialize(const VkPhysicalDeviceAmigoProfilingFeaturesSEC* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceAmigoProfilingFeaturesSEC* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceAmigoProfilingFeaturesSEC const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAmigoProfilingSubmitInfoSEC { + VkStructureType sType; + const void* pNext{}; + uint64_t firstDrawTimestamp; + uint64_t swapBufferTimestamp; + + safe_VkAmigoProfilingSubmitInfoSEC(const VkAmigoProfilingSubmitInfoSEC* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkAmigoProfilingSubmitInfoSEC(const safe_VkAmigoProfilingSubmitInfoSEC& copy_src); + safe_VkAmigoProfilingSubmitInfoSEC& operator=(const safe_VkAmigoProfilingSubmitInfoSEC& copy_src); + safe_VkAmigoProfilingSubmitInfoSEC(); + ~safe_VkAmigoProfilingSubmitInfoSEC(); + void initialize(const VkAmigoProfilingSubmitInfoSEC* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAmigoProfilingSubmitInfoSEC* copy_src, PNextCopyState* copy_state = {}); + VkAmigoProfilingSubmitInfoSEC* ptr() { return reinterpret_cast(this); } + VkAmigoProfilingSubmitInfoSEC const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM { + VkStructureType sType; + void* pNext{}; + VkBool32 multiviewPerViewViewports; + + safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM( + const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM( + const safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& operator=( + const safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(); + ~safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(); + void initialize(const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV { + VkStructureType sType; + void* pNext{}; + VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint; + + safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV( + const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV( + const safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV& copy_src); + safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV& operator=( + const safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV& copy_src); + safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(); + ~safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(); + void initialize(const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 rayTracingInvocationReorder; + + safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV( + const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV( + const safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV& copy_src); + safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV& operator=( + const safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV& copy_src); + safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(); + ~safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(); + void initialize(const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 extendedSparseAddressSpace; + + safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV( + const safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& copy_src); + safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& operator=( + const safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& copy_src); + safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(); + ~safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(); + void initialize(const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV { + VkStructureType sType; + void* pNext{}; + VkDeviceSize extendedSparseAddressSpaceSize; + VkImageUsageFlags extendedSparseImageUsageFlags; + VkBufferUsageFlags extendedSparseBufferUsageFlags; + + safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV( + const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV( + const safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV& copy_src); + safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV& operator=( + const safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV& copy_src); + safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV(); + ~safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV(); + void initialize(const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkLayerSettingEXT { + const char* pLayerName{}; + const char* pSettingName{}; + VkLayerSettingTypeEXT type; + uint32_t valueCount; + const void* pValues{}; + + safe_VkLayerSettingEXT(const VkLayerSettingEXT* in_struct, PNextCopyState* copy_state = {}); + safe_VkLayerSettingEXT(const safe_VkLayerSettingEXT& copy_src); + safe_VkLayerSettingEXT& operator=(const safe_VkLayerSettingEXT& copy_src); + safe_VkLayerSettingEXT(); + ~safe_VkLayerSettingEXT(); + void initialize(const VkLayerSettingEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkLayerSettingEXT* copy_src, PNextCopyState* copy_state = {}); + VkLayerSettingEXT* ptr() { return reinterpret_cast(this); } + VkLayerSettingEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkLayerSettingsCreateInfoEXT { + VkStructureType sType; + const void* pNext{}; + uint32_t settingCount; + safe_VkLayerSettingEXT* pSettings{}; + + safe_VkLayerSettingsCreateInfoEXT(const VkLayerSettingsCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkLayerSettingsCreateInfoEXT(const safe_VkLayerSettingsCreateInfoEXT& copy_src); + safe_VkLayerSettingsCreateInfoEXT& operator=(const safe_VkLayerSettingsCreateInfoEXT& copy_src); + safe_VkLayerSettingsCreateInfoEXT(); + ~safe_VkLayerSettingsCreateInfoEXT(); + void initialize(const VkLayerSettingsCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkLayerSettingsCreateInfoEXT* copy_src, PNextCopyState* copy_state = {}); + VkLayerSettingsCreateInfoEXT* ptr() { return reinterpret_cast(this); } + VkLayerSettingsCreateInfoEXT const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderCoreBuiltins; + + safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(const safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM& copy_src); + safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM& operator=( + const safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM& copy_src); + safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(); + ~safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(); + void initialize(const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM { + VkStructureType sType; + void* pNext{}; + uint64_t shaderCoreMask; + uint32_t shaderCoreCount; + uint32_t shaderWarpsPerCore; + + safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(const safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM& copy_src); + safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM& operator=( + const safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM& copy_src); + safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(); + ~safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(); + void initialize(const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 pipelineLibraryGroupHandles; + + safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT( + const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT( + const safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& copy_src); + safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& operator=( + const safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& copy_src); + safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(); + ~safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(); + void initialize(const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 dynamicRenderingUnusedAttachments; + + safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT( + const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT( + const safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& copy_src); + safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& operator=( + const safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& copy_src); + safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(); + ~safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(); + void initialize(const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* copy_src, + PNextCopyState* copy_state = {}); + VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkLatencySleepModeInfoNV { + VkStructureType sType; + const void* pNext{}; + VkBool32 lowLatencyMode; + VkBool32 lowLatencyBoost; + uint32_t minimumIntervalUs; + + safe_VkLatencySleepModeInfoNV(const VkLatencySleepModeInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkLatencySleepModeInfoNV(const safe_VkLatencySleepModeInfoNV& copy_src); + safe_VkLatencySleepModeInfoNV& operator=(const safe_VkLatencySleepModeInfoNV& copy_src); + safe_VkLatencySleepModeInfoNV(); + ~safe_VkLatencySleepModeInfoNV(); + void initialize(const VkLatencySleepModeInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkLatencySleepModeInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkLatencySleepModeInfoNV* ptr() { return reinterpret_cast(this); } + VkLatencySleepModeInfoNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkLatencySleepInfoNV { + VkStructureType sType; + const void* pNext{}; + VkSemaphore signalSemaphore; + uint64_t value; + + safe_VkLatencySleepInfoNV(const VkLatencySleepInfoNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkLatencySleepInfoNV(const safe_VkLatencySleepInfoNV& copy_src); + safe_VkLatencySleepInfoNV& operator=(const safe_VkLatencySleepInfoNV& copy_src); + safe_VkLatencySleepInfoNV(); + ~safe_VkLatencySleepInfoNV(); + void initialize(const VkLatencySleepInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkLatencySleepInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkLatencySleepInfoNV* ptr() { return reinterpret_cast(this); } + VkLatencySleepInfoNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSetLatencyMarkerInfoNV { + VkStructureType sType; + const void* pNext{}; + uint64_t presentID; + VkLatencyMarkerNV marker; + + safe_VkSetLatencyMarkerInfoNV(const VkSetLatencyMarkerInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSetLatencyMarkerInfoNV(const safe_VkSetLatencyMarkerInfoNV& copy_src); + safe_VkSetLatencyMarkerInfoNV& operator=(const safe_VkSetLatencyMarkerInfoNV& copy_src); + safe_VkSetLatencyMarkerInfoNV(); + ~safe_VkSetLatencyMarkerInfoNV(); + void initialize(const VkSetLatencyMarkerInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSetLatencyMarkerInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkSetLatencyMarkerInfoNV* ptr() { return reinterpret_cast(this); } + VkSetLatencyMarkerInfoNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkLatencyTimingsFrameReportNV { + VkStructureType sType; + const void* pNext{}; + uint64_t presentID; + uint64_t inputSampleTimeUs; + uint64_t simStartTimeUs; + uint64_t simEndTimeUs; + uint64_t renderSubmitStartTimeUs; + uint64_t renderSubmitEndTimeUs; + uint64_t presentStartTimeUs; + uint64_t presentEndTimeUs; + uint64_t driverStartTimeUs; + uint64_t driverEndTimeUs; + uint64_t osRenderQueueStartTimeUs; + uint64_t osRenderQueueEndTimeUs; + uint64_t gpuRenderStartTimeUs; + uint64_t gpuRenderEndTimeUs; + + safe_VkLatencyTimingsFrameReportNV(const VkLatencyTimingsFrameReportNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkLatencyTimingsFrameReportNV(const safe_VkLatencyTimingsFrameReportNV& copy_src); + safe_VkLatencyTimingsFrameReportNV& operator=(const safe_VkLatencyTimingsFrameReportNV& copy_src); + safe_VkLatencyTimingsFrameReportNV(); + ~safe_VkLatencyTimingsFrameReportNV(); + void initialize(const VkLatencyTimingsFrameReportNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkLatencyTimingsFrameReportNV* copy_src, PNextCopyState* copy_state = {}); + VkLatencyTimingsFrameReportNV* ptr() { return reinterpret_cast(this); } + VkLatencyTimingsFrameReportNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkGetLatencyMarkerInfoNV { + VkStructureType sType; + const void* pNext{}; + uint32_t timingCount; + safe_VkLatencyTimingsFrameReportNV* pTimings{}; + + safe_VkGetLatencyMarkerInfoNV(const VkGetLatencyMarkerInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkGetLatencyMarkerInfoNV(const safe_VkGetLatencyMarkerInfoNV& copy_src); + safe_VkGetLatencyMarkerInfoNV& operator=(const safe_VkGetLatencyMarkerInfoNV& copy_src); + safe_VkGetLatencyMarkerInfoNV(); + ~safe_VkGetLatencyMarkerInfoNV(); + void initialize(const VkGetLatencyMarkerInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkGetLatencyMarkerInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkGetLatencyMarkerInfoNV* ptr() { return reinterpret_cast(this); } + VkGetLatencyMarkerInfoNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkLatencySubmissionPresentIdNV { + VkStructureType sType; + const void* pNext{}; + uint64_t presentID; + + safe_VkLatencySubmissionPresentIdNV(const VkLatencySubmissionPresentIdNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkLatencySubmissionPresentIdNV(const safe_VkLatencySubmissionPresentIdNV& copy_src); + safe_VkLatencySubmissionPresentIdNV& operator=(const safe_VkLatencySubmissionPresentIdNV& copy_src); + safe_VkLatencySubmissionPresentIdNV(); + ~safe_VkLatencySubmissionPresentIdNV(); + void initialize(const VkLatencySubmissionPresentIdNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkLatencySubmissionPresentIdNV* copy_src, PNextCopyState* copy_state = {}); + VkLatencySubmissionPresentIdNV* ptr() { return reinterpret_cast(this); } + VkLatencySubmissionPresentIdNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkSwapchainLatencyCreateInfoNV { + VkStructureType sType; + const void* pNext{}; + VkBool32 latencyModeEnable; + + safe_VkSwapchainLatencyCreateInfoNV(const VkSwapchainLatencyCreateInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSwapchainLatencyCreateInfoNV(const safe_VkSwapchainLatencyCreateInfoNV& copy_src); + safe_VkSwapchainLatencyCreateInfoNV& operator=(const safe_VkSwapchainLatencyCreateInfoNV& copy_src); + safe_VkSwapchainLatencyCreateInfoNV(); + ~safe_VkSwapchainLatencyCreateInfoNV(); + void initialize(const VkSwapchainLatencyCreateInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSwapchainLatencyCreateInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkSwapchainLatencyCreateInfoNV* ptr() { return reinterpret_cast(this); } + VkSwapchainLatencyCreateInfoNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkOutOfBandQueueTypeInfoNV { + VkStructureType sType; + const void* pNext{}; + VkOutOfBandQueueTypeNV queueType; + + safe_VkOutOfBandQueueTypeInfoNV(const VkOutOfBandQueueTypeInfoNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkOutOfBandQueueTypeInfoNV(const safe_VkOutOfBandQueueTypeInfoNV& copy_src); + safe_VkOutOfBandQueueTypeInfoNV& operator=(const safe_VkOutOfBandQueueTypeInfoNV& copy_src); + safe_VkOutOfBandQueueTypeInfoNV(); + ~safe_VkOutOfBandQueueTypeInfoNV(); + void initialize(const VkOutOfBandQueueTypeInfoNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkOutOfBandQueueTypeInfoNV* copy_src, PNextCopyState* copy_state = {}); + VkOutOfBandQueueTypeInfoNV* ptr() { return reinterpret_cast(this); } + VkOutOfBandQueueTypeInfoNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkLatencySurfaceCapabilitiesNV { + VkStructureType sType; + const void* pNext{}; + uint32_t presentModeCount; + VkPresentModeKHR* pPresentModes{}; + + safe_VkLatencySurfaceCapabilitiesNV(const VkLatencySurfaceCapabilitiesNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkLatencySurfaceCapabilitiesNV(const safe_VkLatencySurfaceCapabilitiesNV& copy_src); + safe_VkLatencySurfaceCapabilitiesNV& operator=(const safe_VkLatencySurfaceCapabilitiesNV& copy_src); + safe_VkLatencySurfaceCapabilitiesNV(); + ~safe_VkLatencySurfaceCapabilitiesNV(); + void initialize(const VkLatencySurfaceCapabilitiesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkLatencySurfaceCapabilitiesNV* copy_src, PNextCopyState* copy_state = {}); + VkLatencySurfaceCapabilitiesNV* ptr() { return reinterpret_cast(this); } + VkLatencySurfaceCapabilitiesNV const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM { + VkStructureType sType; + void* pNext{}; + VkBool32 multiviewPerViewRenderAreas; + + safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM( + const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM( + const safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& operator=( + const safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(); + ~safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(); + void initialize(const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM { + VkStructureType sType; + const void* pNext{}; + uint32_t perViewRenderAreaCount; + const VkRect2D* pPerViewRenderAreas{}; + + safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM( + const safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& copy_src); + safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& operator=( + const safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& copy_src); + safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(); + ~safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(); + void initialize(const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* copy_src, PNextCopyState* copy_state = {}); + VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* ptr() { + return reinterpret_cast(this); + } + VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const* ptr() const { + 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{}; + VkBool32 textureBlockMatch2; + + safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM(const VkPhysicalDeviceImageProcessing2FeaturesQCOM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM(const safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM& copy_src); + safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM& operator=(const safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM& copy_src); + safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM(); + ~safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM(); + void initialize(const VkPhysicalDeviceImageProcessing2FeaturesQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceImageProcessing2FeaturesQCOM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceImageProcessing2FeaturesQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM { + VkStructureType sType; + void* pNext{}; + VkExtent2D maxBlockMatchWindow; + + safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM(const VkPhysicalDeviceImageProcessing2PropertiesQCOM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM(const safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM& copy_src); + safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM& operator=( + const safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM& copy_src); + safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM(); + ~safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM(); + void initialize(const VkPhysicalDeviceImageProcessing2PropertiesQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceImageProcessing2PropertiesQCOM* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceImageProcessing2PropertiesQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSamplerBlockMatchWindowCreateInfoQCOM { + VkStructureType sType; + const void* pNext{}; + VkExtent2D windowExtent; + VkBlockMatchWindowCompareModeQCOM windowCompareMode; + + safe_VkSamplerBlockMatchWindowCreateInfoQCOM(const VkSamplerBlockMatchWindowCreateInfoQCOM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSamplerBlockMatchWindowCreateInfoQCOM(const safe_VkSamplerBlockMatchWindowCreateInfoQCOM& copy_src); + safe_VkSamplerBlockMatchWindowCreateInfoQCOM& operator=(const safe_VkSamplerBlockMatchWindowCreateInfoQCOM& copy_src); + safe_VkSamplerBlockMatchWindowCreateInfoQCOM(); + ~safe_VkSamplerBlockMatchWindowCreateInfoQCOM(); + void initialize(const VkSamplerBlockMatchWindowCreateInfoQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSamplerBlockMatchWindowCreateInfoQCOM* copy_src, PNextCopyState* copy_state = {}); + VkSamplerBlockMatchWindowCreateInfoQCOM* ptr() { return reinterpret_cast(this); } + VkSamplerBlockMatchWindowCreateInfoQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM { + VkStructureType sType; + void* pNext{}; + VkBool32 selectableCubicWeights; + + safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM(const VkPhysicalDeviceCubicWeightsFeaturesQCOM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM(const safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM& operator=(const safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM(); + ~safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM(); + void initialize(const VkPhysicalDeviceCubicWeightsFeaturesQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceCubicWeightsFeaturesQCOM* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceCubicWeightsFeaturesQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSamplerCubicWeightsCreateInfoQCOM { + VkStructureType sType; + const void* pNext{}; + VkCubicFilterWeightsQCOM cubicWeights; + + safe_VkSamplerCubicWeightsCreateInfoQCOM(const VkSamplerCubicWeightsCreateInfoQCOM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkSamplerCubicWeightsCreateInfoQCOM(const safe_VkSamplerCubicWeightsCreateInfoQCOM& copy_src); + safe_VkSamplerCubicWeightsCreateInfoQCOM& operator=(const safe_VkSamplerCubicWeightsCreateInfoQCOM& copy_src); + safe_VkSamplerCubicWeightsCreateInfoQCOM(); + ~safe_VkSamplerCubicWeightsCreateInfoQCOM(); + void initialize(const VkSamplerCubicWeightsCreateInfoQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSamplerCubicWeightsCreateInfoQCOM* copy_src, PNextCopyState* copy_state = {}); + VkSamplerCubicWeightsCreateInfoQCOM* ptr() { return reinterpret_cast(this); } + VkSamplerCubicWeightsCreateInfoQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkBlitImageCubicWeightsInfoQCOM { + VkStructureType sType; + const void* pNext{}; + VkCubicFilterWeightsQCOM cubicWeights; + + safe_VkBlitImageCubicWeightsInfoQCOM(const VkBlitImageCubicWeightsInfoQCOM* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkBlitImageCubicWeightsInfoQCOM(const safe_VkBlitImageCubicWeightsInfoQCOM& copy_src); + safe_VkBlitImageCubicWeightsInfoQCOM& operator=(const safe_VkBlitImageCubicWeightsInfoQCOM& copy_src); + safe_VkBlitImageCubicWeightsInfoQCOM(); + ~safe_VkBlitImageCubicWeightsInfoQCOM(); + void initialize(const VkBlitImageCubicWeightsInfoQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkBlitImageCubicWeightsInfoQCOM* copy_src, PNextCopyState* copy_state = {}); + VkBlitImageCubicWeightsInfoQCOM* ptr() { return reinterpret_cast(this); } + VkBlitImageCubicWeightsInfoQCOM const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM { + VkStructureType sType; + void* pNext{}; + VkBool32 ycbcrDegamma; + + safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM(const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM(const safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM& operator=(const safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM(); + ~safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM(); + void initialize(const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceYcbcrDegammaFeaturesQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM { + VkStructureType sType; + void* pNext{}; + VkBool32 enableYDegamma; + VkBool32 enableCbCrDegamma; + + safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM( + const safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& copy_src); + safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& operator=( + const safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& copy_src); + safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(); + ~safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(); + void initialize(const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* copy_src, PNextCopyState* copy_state = {}); + VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* ptr() { + return reinterpret_cast(this); + } + VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceCubicClampFeaturesQCOM { + VkStructureType sType; + void* pNext{}; + VkBool32 cubicRangeClamp; + + safe_VkPhysicalDeviceCubicClampFeaturesQCOM(const VkPhysicalDeviceCubicClampFeaturesQCOM* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceCubicClampFeaturesQCOM(const safe_VkPhysicalDeviceCubicClampFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceCubicClampFeaturesQCOM& operator=(const safe_VkPhysicalDeviceCubicClampFeaturesQCOM& copy_src); + safe_VkPhysicalDeviceCubicClampFeaturesQCOM(); + ~safe_VkPhysicalDeviceCubicClampFeaturesQCOM(); + void initialize(const VkPhysicalDeviceCubicClampFeaturesQCOM* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceCubicClampFeaturesQCOM* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceCubicClampFeaturesQCOM* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceCubicClampFeaturesQCOM const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 attachmentFeedbackLoopDynamicState; + + safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT( + const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT( + const safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& copy_src); + safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& operator=( + const safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& copy_src); + safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(); + ~safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(); + void initialize(const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* copy_src, + PNextCopyState* copy_state = {}); + VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +#ifdef VK_USE_PLATFORM_SCREEN_QNX +struct safe_VkScreenBufferPropertiesQNX { + VkStructureType sType; + void* pNext{}; + VkDeviceSize allocationSize; + uint32_t memoryTypeBits; + + safe_VkScreenBufferPropertiesQNX(const VkScreenBufferPropertiesQNX* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkScreenBufferPropertiesQNX(const safe_VkScreenBufferPropertiesQNX& copy_src); + safe_VkScreenBufferPropertiesQNX& operator=(const safe_VkScreenBufferPropertiesQNX& copy_src); + safe_VkScreenBufferPropertiesQNX(); + ~safe_VkScreenBufferPropertiesQNX(); + void initialize(const VkScreenBufferPropertiesQNX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkScreenBufferPropertiesQNX* copy_src, PNextCopyState* copy_state = {}); + VkScreenBufferPropertiesQNX* ptr() { return reinterpret_cast(this); } + VkScreenBufferPropertiesQNX const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkScreenBufferFormatPropertiesQNX { + VkStructureType sType; + void* pNext{}; + VkFormat format; + uint64_t externalFormat; + uint64_t screenUsage; + VkFormatFeatureFlags formatFeatures; + VkComponentMapping samplerYcbcrConversionComponents; + VkSamplerYcbcrModelConversion suggestedYcbcrModel; + VkSamplerYcbcrRange suggestedYcbcrRange; + VkChromaLocation suggestedXChromaOffset; + VkChromaLocation suggestedYChromaOffset; + + safe_VkScreenBufferFormatPropertiesQNX(const VkScreenBufferFormatPropertiesQNX* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkScreenBufferFormatPropertiesQNX(const safe_VkScreenBufferFormatPropertiesQNX& copy_src); + safe_VkScreenBufferFormatPropertiesQNX& operator=(const safe_VkScreenBufferFormatPropertiesQNX& copy_src); + safe_VkScreenBufferFormatPropertiesQNX(); + ~safe_VkScreenBufferFormatPropertiesQNX(); + void initialize(const VkScreenBufferFormatPropertiesQNX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkScreenBufferFormatPropertiesQNX* copy_src, PNextCopyState* copy_state = {}); + VkScreenBufferFormatPropertiesQNX* ptr() { return reinterpret_cast(this); } + VkScreenBufferFormatPropertiesQNX const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkImportScreenBufferInfoQNX { + VkStructureType sType; + const void* pNext{}; + struct _screen_buffer* buffer{}; + + safe_VkImportScreenBufferInfoQNX(const VkImportScreenBufferInfoQNX* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkImportScreenBufferInfoQNX(const safe_VkImportScreenBufferInfoQNX& copy_src); + safe_VkImportScreenBufferInfoQNX& operator=(const safe_VkImportScreenBufferInfoQNX& copy_src); + safe_VkImportScreenBufferInfoQNX(); + ~safe_VkImportScreenBufferInfoQNX(); + void initialize(const VkImportScreenBufferInfoQNX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkImportScreenBufferInfoQNX* copy_src, PNextCopyState* copy_state = {}); + VkImportScreenBufferInfoQNX* ptr() { return reinterpret_cast(this); } + VkImportScreenBufferInfoQNX const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkExternalFormatQNX { + VkStructureType sType; + void* pNext{}; + uint64_t externalFormat; + + safe_VkExternalFormatQNX(const VkExternalFormatQNX* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkExternalFormatQNX(const safe_VkExternalFormatQNX& copy_src); + safe_VkExternalFormatQNX& operator=(const safe_VkExternalFormatQNX& copy_src); + safe_VkExternalFormatQNX(); + ~safe_VkExternalFormatQNX(); + void initialize(const VkExternalFormatQNX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkExternalFormatQNX* copy_src, PNextCopyState* copy_state = {}); + VkExternalFormatQNX* ptr() { return reinterpret_cast(this); } + VkExternalFormatQNX const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX { + VkStructureType sType; + void* pNext{}; + VkBool32 screenBufferImport; + + safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX( + const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX( + const safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& copy_src); + safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& operator=( + const safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& copy_src); + safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX(); + ~safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX(); + void initialize(const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const* ptr() const { + return reinterpret_cast(this); + } +}; +#endif // VK_USE_PLATFORM_SCREEN_QNX +struct safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT { + VkStructureType sType; + void* pNext{}; + VkLayeredDriverUnderlyingApiMSFT underlyingAPI; + + safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT(const VkPhysicalDeviceLayeredDriverPropertiesMSFT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT(const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT& copy_src); + safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT& operator=(const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT& copy_src); + safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT(); + ~safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT(); + void initialize(const VkPhysicalDeviceLayeredDriverPropertiesMSFT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceLayeredDriverPropertiesMSFT* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceLayeredDriverPropertiesMSFT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 descriptorPoolOverallocation; + + safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV( + const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV( + const safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV& copy_src); + safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV& operator=( + const safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV& copy_src); + safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(); + ~safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(); + void initialize(const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceRawAccessChainsFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderRawAccessChains; + + safe_VkPhysicalDeviceRawAccessChainsFeaturesNV(const VkPhysicalDeviceRawAccessChainsFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceRawAccessChainsFeaturesNV(const safe_VkPhysicalDeviceRawAccessChainsFeaturesNV& copy_src); + safe_VkPhysicalDeviceRawAccessChainsFeaturesNV& operator=(const safe_VkPhysicalDeviceRawAccessChainsFeaturesNV& copy_src); + safe_VkPhysicalDeviceRawAccessChainsFeaturesNV(); + ~safe_VkPhysicalDeviceRawAccessChainsFeaturesNV(); + void initialize(const VkPhysicalDeviceRawAccessChainsFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceRawAccessChainsFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceRawAccessChainsFeaturesNV* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceRawAccessChainsFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderFloat16VectorAtomics; + + safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV( + const safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& copy_src); + safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& operator=( + const safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& copy_src); + safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(); + ~safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(); + void initialize(const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceRayTracingValidationFeaturesNV { + VkStructureType sType; + void* pNext{}; + VkBool32 rayTracingValidation; + + safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(const VkPhysicalDeviceRayTracingValidationFeaturesNV* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(const safe_VkPhysicalDeviceRayTracingValidationFeaturesNV& copy_src); + safe_VkPhysicalDeviceRayTracingValidationFeaturesNV& operator=( + const safe_VkPhysicalDeviceRayTracingValidationFeaturesNV& copy_src); + safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(); + ~safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(); + void initialize(const VkPhysicalDeviceRayTracingValidationFeaturesNV* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceRayTracingValidationFeaturesNV* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceRayTracingValidationFeaturesNV* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceRayTracingValidationFeaturesNV const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAccelerationStructureGeometryTrianglesDataKHR { + VkStructureType sType; + const void* pNext{}; + VkFormat vertexFormat; + safe_VkDeviceOrHostAddressConstKHR vertexData; + VkDeviceSize vertexStride; + uint32_t maxVertex; + VkIndexType indexType; + safe_VkDeviceOrHostAddressConstKHR indexData; + safe_VkDeviceOrHostAddressConstKHR transformData; + + safe_VkAccelerationStructureGeometryTrianglesDataKHR(const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAccelerationStructureGeometryTrianglesDataKHR(const safe_VkAccelerationStructureGeometryTrianglesDataKHR& copy_src); + safe_VkAccelerationStructureGeometryTrianglesDataKHR& operator=( + const safe_VkAccelerationStructureGeometryTrianglesDataKHR& copy_src); + safe_VkAccelerationStructureGeometryTrianglesDataKHR(); + ~safe_VkAccelerationStructureGeometryTrianglesDataKHR(); + void initialize(const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureGeometryTrianglesDataKHR* copy_src, PNextCopyState* copy_state = {}); + VkAccelerationStructureGeometryTrianglesDataKHR* ptr() { + return reinterpret_cast(this); + } + VkAccelerationStructureGeometryTrianglesDataKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAccelerationStructureGeometryAabbsDataKHR { + VkStructureType sType; + const void* pNext{}; + safe_VkDeviceOrHostAddressConstKHR data; + VkDeviceSize stride; + + safe_VkAccelerationStructureGeometryAabbsDataKHR(const VkAccelerationStructureGeometryAabbsDataKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAccelerationStructureGeometryAabbsDataKHR(const safe_VkAccelerationStructureGeometryAabbsDataKHR& copy_src); + safe_VkAccelerationStructureGeometryAabbsDataKHR& operator=(const safe_VkAccelerationStructureGeometryAabbsDataKHR& copy_src); + safe_VkAccelerationStructureGeometryAabbsDataKHR(); + ~safe_VkAccelerationStructureGeometryAabbsDataKHR(); + void initialize(const VkAccelerationStructureGeometryAabbsDataKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureGeometryAabbsDataKHR* copy_src, PNextCopyState* copy_state = {}); + VkAccelerationStructureGeometryAabbsDataKHR* ptr() { + return reinterpret_cast(this); + } + VkAccelerationStructureGeometryAabbsDataKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAccelerationStructureGeometryInstancesDataKHR { + VkStructureType sType; + const void* pNext{}; + VkBool32 arrayOfPointers; + safe_VkDeviceOrHostAddressConstKHR data; + + safe_VkAccelerationStructureGeometryInstancesDataKHR(const VkAccelerationStructureGeometryInstancesDataKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAccelerationStructureGeometryInstancesDataKHR(const safe_VkAccelerationStructureGeometryInstancesDataKHR& copy_src); + safe_VkAccelerationStructureGeometryInstancesDataKHR& operator=( + const safe_VkAccelerationStructureGeometryInstancesDataKHR& copy_src); + safe_VkAccelerationStructureGeometryInstancesDataKHR(); + ~safe_VkAccelerationStructureGeometryInstancesDataKHR(); + void initialize(const VkAccelerationStructureGeometryInstancesDataKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureGeometryInstancesDataKHR* copy_src, PNextCopyState* copy_state = {}); + VkAccelerationStructureGeometryInstancesDataKHR* ptr() { + return reinterpret_cast(this); + } + VkAccelerationStructureGeometryInstancesDataKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAccelerationStructureGeometryKHR { + VkStructureType sType; + const void* pNext{}; + VkGeometryTypeKHR geometryType; + VkAccelerationStructureGeometryDataKHR geometry; + VkGeometryFlagsKHR flags; + + safe_VkAccelerationStructureGeometryKHR(const VkAccelerationStructureGeometryKHR* in_struct, const bool is_host, + const VkAccelerationStructureBuildRangeInfoKHR* build_range_info, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAccelerationStructureGeometryKHR(const safe_VkAccelerationStructureGeometryKHR& copy_src); + safe_VkAccelerationStructureGeometryKHR& operator=(const safe_VkAccelerationStructureGeometryKHR& copy_src); + safe_VkAccelerationStructureGeometryKHR(); + ~safe_VkAccelerationStructureGeometryKHR(); + void initialize(const VkAccelerationStructureGeometryKHR* in_struct, const bool is_host, + const VkAccelerationStructureBuildRangeInfoKHR* build_range_info, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureGeometryKHR* copy_src, PNextCopyState* copy_state = {}); + VkAccelerationStructureGeometryKHR* ptr() { return reinterpret_cast(this); } + VkAccelerationStructureGeometryKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAccelerationStructureBuildGeometryInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkAccelerationStructureTypeKHR type; + VkBuildAccelerationStructureFlagsKHR flags; + VkBuildAccelerationStructureModeKHR mode; + VkAccelerationStructureKHR srcAccelerationStructure; + VkAccelerationStructureKHR dstAccelerationStructure; + uint32_t geometryCount; + safe_VkAccelerationStructureGeometryKHR* pGeometries{}; + safe_VkAccelerationStructureGeometryKHR** ppGeometries{}; + safe_VkDeviceOrHostAddressKHR scratchData; + + safe_VkAccelerationStructureBuildGeometryInfoKHR(const VkAccelerationStructureBuildGeometryInfoKHR* in_struct, + const bool is_host, + const VkAccelerationStructureBuildRangeInfoKHR* build_range_infos, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAccelerationStructureBuildGeometryInfoKHR(const safe_VkAccelerationStructureBuildGeometryInfoKHR& copy_src); + safe_VkAccelerationStructureBuildGeometryInfoKHR& operator=(const safe_VkAccelerationStructureBuildGeometryInfoKHR& copy_src); + safe_VkAccelerationStructureBuildGeometryInfoKHR(); + ~safe_VkAccelerationStructureBuildGeometryInfoKHR(); + void initialize(const VkAccelerationStructureBuildGeometryInfoKHR* in_struct, const bool is_host, + const VkAccelerationStructureBuildRangeInfoKHR* build_range_infos, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureBuildGeometryInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkAccelerationStructureBuildGeometryInfoKHR* ptr() { + return reinterpret_cast(this); + } + VkAccelerationStructureBuildGeometryInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAccelerationStructureCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkAccelerationStructureCreateFlagsKHR createFlags; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; + VkAccelerationStructureTypeKHR type; + VkDeviceAddress deviceAddress; + + safe_VkAccelerationStructureCreateInfoKHR(const VkAccelerationStructureCreateInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAccelerationStructureCreateInfoKHR(const safe_VkAccelerationStructureCreateInfoKHR& copy_src); + safe_VkAccelerationStructureCreateInfoKHR& operator=(const safe_VkAccelerationStructureCreateInfoKHR& copy_src); + safe_VkAccelerationStructureCreateInfoKHR(); + ~safe_VkAccelerationStructureCreateInfoKHR(); + void initialize(const VkAccelerationStructureCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkAccelerationStructureCreateInfoKHR* ptr() { return reinterpret_cast(this); } + VkAccelerationStructureCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkWriteDescriptorSetAccelerationStructureKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t accelerationStructureCount; + VkAccelerationStructureKHR* pAccelerationStructures{}; + + safe_VkWriteDescriptorSetAccelerationStructureKHR(const VkWriteDescriptorSetAccelerationStructureKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkWriteDescriptorSetAccelerationStructureKHR(const safe_VkWriteDescriptorSetAccelerationStructureKHR& copy_src); + safe_VkWriteDescriptorSetAccelerationStructureKHR& operator=(const safe_VkWriteDescriptorSetAccelerationStructureKHR& copy_src); + safe_VkWriteDescriptorSetAccelerationStructureKHR(); + ~safe_VkWriteDescriptorSetAccelerationStructureKHR(); + void initialize(const VkWriteDescriptorSetAccelerationStructureKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkWriteDescriptorSetAccelerationStructureKHR* copy_src, PNextCopyState* copy_state = {}); + VkWriteDescriptorSetAccelerationStructureKHR* ptr() { + return reinterpret_cast(this); + } + VkWriteDescriptorSetAccelerationStructureKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 accelerationStructure; + VkBool32 accelerationStructureCaptureReplay; + VkBool32 accelerationStructureIndirectBuild; + VkBool32 accelerationStructureHostCommands; + VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind; + + safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR(const VkPhysicalDeviceAccelerationStructureFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR(const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR& copy_src); + safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR& operator=( + const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR& copy_src); + safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR(); + ~safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR(); + void initialize(const VkPhysicalDeviceAccelerationStructureFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceAccelerationStructureFeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceAccelerationStructureFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR { + VkStructureType sType; + void* pNext{}; + uint64_t maxGeometryCount; + uint64_t maxInstanceCount; + uint64_t maxPrimitiveCount; + uint32_t maxPerStageDescriptorAccelerationStructures; + uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures; + uint32_t maxDescriptorSetAccelerationStructures; + uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures; + uint32_t minAccelerationStructureScratchOffsetAlignment; + + safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(const VkPhysicalDeviceAccelerationStructurePropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR( + const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR& copy_src); + safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR& operator=( + const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR& copy_src); + safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(); + ~safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(); + void initialize(const VkPhysicalDeviceAccelerationStructurePropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceAccelerationStructurePropertiesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceAccelerationStructurePropertiesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAccelerationStructureDeviceAddressInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkAccelerationStructureKHR accelerationStructure; + + safe_VkAccelerationStructureDeviceAddressInfoKHR(const VkAccelerationStructureDeviceAddressInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAccelerationStructureDeviceAddressInfoKHR(const safe_VkAccelerationStructureDeviceAddressInfoKHR& copy_src); + safe_VkAccelerationStructureDeviceAddressInfoKHR& operator=(const safe_VkAccelerationStructureDeviceAddressInfoKHR& copy_src); + safe_VkAccelerationStructureDeviceAddressInfoKHR(); + ~safe_VkAccelerationStructureDeviceAddressInfoKHR(); + void initialize(const VkAccelerationStructureDeviceAddressInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureDeviceAddressInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkAccelerationStructureDeviceAddressInfoKHR* ptr() { + return reinterpret_cast(this); + } + VkAccelerationStructureDeviceAddressInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAccelerationStructureVersionInfoKHR { + VkStructureType sType; + const void* pNext{}; + const uint8_t* pVersionData{}; + + safe_VkAccelerationStructureVersionInfoKHR(const VkAccelerationStructureVersionInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAccelerationStructureVersionInfoKHR(const safe_VkAccelerationStructureVersionInfoKHR& copy_src); + safe_VkAccelerationStructureVersionInfoKHR& operator=(const safe_VkAccelerationStructureVersionInfoKHR& copy_src); + safe_VkAccelerationStructureVersionInfoKHR(); + ~safe_VkAccelerationStructureVersionInfoKHR(); + void initialize(const VkAccelerationStructureVersionInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureVersionInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkAccelerationStructureVersionInfoKHR* ptr() { return reinterpret_cast(this); } + VkAccelerationStructureVersionInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkCopyAccelerationStructureToMemoryInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkAccelerationStructureKHR src; + safe_VkDeviceOrHostAddressKHR dst; + VkCopyAccelerationStructureModeKHR mode; + + safe_VkCopyAccelerationStructureToMemoryInfoKHR(const VkCopyAccelerationStructureToMemoryInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkCopyAccelerationStructureToMemoryInfoKHR(const safe_VkCopyAccelerationStructureToMemoryInfoKHR& copy_src); + safe_VkCopyAccelerationStructureToMemoryInfoKHR& operator=(const safe_VkCopyAccelerationStructureToMemoryInfoKHR& copy_src); + safe_VkCopyAccelerationStructureToMemoryInfoKHR(); + ~safe_VkCopyAccelerationStructureToMemoryInfoKHR(); + void initialize(const VkCopyAccelerationStructureToMemoryInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyAccelerationStructureToMemoryInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkCopyAccelerationStructureToMemoryInfoKHR* ptr() { + return reinterpret_cast(this); + } + VkCopyAccelerationStructureToMemoryInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkCopyMemoryToAccelerationStructureInfoKHR { + VkStructureType sType; + const void* pNext{}; + safe_VkDeviceOrHostAddressConstKHR src; + VkAccelerationStructureKHR dst; + VkCopyAccelerationStructureModeKHR mode; + + safe_VkCopyMemoryToAccelerationStructureInfoKHR(const VkCopyMemoryToAccelerationStructureInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkCopyMemoryToAccelerationStructureInfoKHR(const safe_VkCopyMemoryToAccelerationStructureInfoKHR& copy_src); + safe_VkCopyMemoryToAccelerationStructureInfoKHR& operator=(const safe_VkCopyMemoryToAccelerationStructureInfoKHR& copy_src); + safe_VkCopyMemoryToAccelerationStructureInfoKHR(); + ~safe_VkCopyMemoryToAccelerationStructureInfoKHR(); + void initialize(const VkCopyMemoryToAccelerationStructureInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyMemoryToAccelerationStructureInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkCopyMemoryToAccelerationStructureInfoKHR* ptr() { + return reinterpret_cast(this); + } + VkCopyMemoryToAccelerationStructureInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkCopyAccelerationStructureInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkAccelerationStructureKHR src; + VkAccelerationStructureKHR dst; + VkCopyAccelerationStructureModeKHR mode; + + safe_VkCopyAccelerationStructureInfoKHR(const VkCopyAccelerationStructureInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCopyAccelerationStructureInfoKHR(const safe_VkCopyAccelerationStructureInfoKHR& copy_src); + safe_VkCopyAccelerationStructureInfoKHR& operator=(const safe_VkCopyAccelerationStructureInfoKHR& copy_src); + safe_VkCopyAccelerationStructureInfoKHR(); + ~safe_VkCopyAccelerationStructureInfoKHR(); + void initialize(const VkCopyAccelerationStructureInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyAccelerationStructureInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkCopyAccelerationStructureInfoKHR* ptr() { return reinterpret_cast(this); } + VkCopyAccelerationStructureInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAccelerationStructureBuildSizesInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkDeviceSize accelerationStructureSize; + VkDeviceSize updateScratchSize; + VkDeviceSize buildScratchSize; + + safe_VkAccelerationStructureBuildSizesInfoKHR(const VkAccelerationStructureBuildSizesInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkAccelerationStructureBuildSizesInfoKHR(const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src); + safe_VkAccelerationStructureBuildSizesInfoKHR& operator=(const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src); + safe_VkAccelerationStructureBuildSizesInfoKHR(); + ~safe_VkAccelerationStructureBuildSizesInfoKHR(); + void initialize(const VkAccelerationStructureBuildSizesInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureBuildSizesInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkAccelerationStructureBuildSizesInfoKHR* ptr() { return reinterpret_cast(this); } + VkAccelerationStructureBuildSizesInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRayTracingShaderGroupCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkRayTracingShaderGroupTypeKHR type; + uint32_t generalShader; + uint32_t closestHitShader; + uint32_t anyHitShader; + uint32_t intersectionShader; + const void* pShaderGroupCaptureReplayHandle{}; + + safe_VkRayTracingShaderGroupCreateInfoKHR(const VkRayTracingShaderGroupCreateInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkRayTracingShaderGroupCreateInfoKHR(const safe_VkRayTracingShaderGroupCreateInfoKHR& copy_src); + safe_VkRayTracingShaderGroupCreateInfoKHR& operator=(const safe_VkRayTracingShaderGroupCreateInfoKHR& copy_src); + safe_VkRayTracingShaderGroupCreateInfoKHR(); + ~safe_VkRayTracingShaderGroupCreateInfoKHR(); + void initialize(const VkRayTracingShaderGroupCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRayTracingShaderGroupCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkRayTracingShaderGroupCreateInfoKHR* ptr() { return reinterpret_cast(this); } + VkRayTracingShaderGroupCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRayTracingPipelineInterfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + uint32_t maxPipelineRayPayloadSize; + uint32_t maxPipelineRayHitAttributeSize; + + safe_VkRayTracingPipelineInterfaceCreateInfoKHR(const VkRayTracingPipelineInterfaceCreateInfoKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkRayTracingPipelineInterfaceCreateInfoKHR(const safe_VkRayTracingPipelineInterfaceCreateInfoKHR& copy_src); + safe_VkRayTracingPipelineInterfaceCreateInfoKHR& operator=(const safe_VkRayTracingPipelineInterfaceCreateInfoKHR& copy_src); + safe_VkRayTracingPipelineInterfaceCreateInfoKHR(); + ~safe_VkRayTracingPipelineInterfaceCreateInfoKHR(); + void initialize(const VkRayTracingPipelineInterfaceCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRayTracingPipelineInterfaceCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkRayTracingPipelineInterfaceCreateInfoKHR* ptr() { + return reinterpret_cast(this); + } + VkRayTracingPipelineInterfaceCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkRayTracingPipelineCreateInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkPipelineCreateFlags flags; + uint32_t stageCount; + safe_VkPipelineShaderStageCreateInfo* pStages{}; + uint32_t groupCount; + safe_VkRayTracingShaderGroupCreateInfoKHR* pGroups{}; + uint32_t maxPipelineRayRecursionDepth; + safe_VkPipelineLibraryCreateInfoKHR* pLibraryInfo{}; + safe_VkRayTracingPipelineInterfaceCreateInfoKHR* pLibraryInterface{}; + safe_VkPipelineDynamicStateCreateInfo* pDynamicState{}; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; + + safe_VkRayTracingPipelineCreateInfoKHR(const VkRayTracingPipelineCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkRayTracingPipelineCreateInfoKHR(const safe_VkRayTracingPipelineCreateInfoKHR& copy_src); + safe_VkRayTracingPipelineCreateInfoKHR& operator=(const safe_VkRayTracingPipelineCreateInfoKHR& copy_src); + safe_VkRayTracingPipelineCreateInfoKHR(); + ~safe_VkRayTracingPipelineCreateInfoKHR(); + void initialize(const VkRayTracingPipelineCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkRayTracingPipelineCreateInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkRayTracingPipelineCreateInfoKHR* ptr() { return reinterpret_cast(this); } + VkRayTracingPipelineCreateInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 rayTracingPipeline; + VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay; + VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed; + VkBool32 rayTracingPipelineTraceRaysIndirect; + VkBool32 rayTraversalPrimitiveCulling; + + safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR& copy_src); + safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR& operator=( + const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR& copy_src); + safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(); + ~safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(); + void initialize(const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceRayTracingPipelineFeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceRayTracingPipelineFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR { + VkStructureType sType; + void* pNext{}; + uint32_t shaderGroupHandleSize; + uint32_t maxRayRecursionDepth; + uint32_t maxShaderGroupStride; + uint32_t shaderGroupBaseAlignment; + uint32_t shaderGroupHandleCaptureReplaySize; + uint32_t maxRayDispatchInvocationCount; + uint32_t shaderGroupHandleAlignment; + uint32_t maxRayHitAttributeSize; + + safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR& copy_src); + safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR& operator=( + const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR& copy_src); + safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(); + ~safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(); + void initialize(const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceRayTracingPipelinePropertiesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceRayTracingPipelinePropertiesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceRayQueryFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 rayQuery; + + safe_VkPhysicalDeviceRayQueryFeaturesKHR(const VkPhysicalDeviceRayQueryFeaturesKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceRayQueryFeaturesKHR(const safe_VkPhysicalDeviceRayQueryFeaturesKHR& copy_src); + safe_VkPhysicalDeviceRayQueryFeaturesKHR& operator=(const safe_VkPhysicalDeviceRayQueryFeaturesKHR& copy_src); + safe_VkPhysicalDeviceRayQueryFeaturesKHR(); + ~safe_VkPhysicalDeviceRayQueryFeaturesKHR(); + void initialize(const VkPhysicalDeviceRayQueryFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceRayQueryFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceRayQueryFeaturesKHR* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceRayQueryFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMeshShaderFeaturesEXT { + VkStructureType sType; + void* pNext{}; + VkBool32 taskShader; + VkBool32 meshShader; + VkBool32 multiviewMeshShader; + VkBool32 primitiveFragmentShadingRateMeshShader; + VkBool32 meshShaderQueries; + + safe_VkPhysicalDeviceMeshShaderFeaturesEXT(const VkPhysicalDeviceMeshShaderFeaturesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMeshShaderFeaturesEXT(const safe_VkPhysicalDeviceMeshShaderFeaturesEXT& copy_src); + safe_VkPhysicalDeviceMeshShaderFeaturesEXT& operator=(const safe_VkPhysicalDeviceMeshShaderFeaturesEXT& copy_src); + safe_VkPhysicalDeviceMeshShaderFeaturesEXT(); + ~safe_VkPhysicalDeviceMeshShaderFeaturesEXT(); + void initialize(const VkPhysicalDeviceMeshShaderFeaturesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMeshShaderFeaturesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMeshShaderFeaturesEXT* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMeshShaderFeaturesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceMeshShaderPropertiesEXT { + VkStructureType sType; + void* pNext{}; + uint32_t maxTaskWorkGroupTotalCount; + uint32_t maxTaskWorkGroupCount[3]; + uint32_t maxTaskWorkGroupInvocations; + uint32_t maxTaskWorkGroupSize[3]; + uint32_t maxTaskPayloadSize; + uint32_t maxTaskSharedMemorySize; + uint32_t maxTaskPayloadAndSharedMemorySize; + uint32_t maxMeshWorkGroupTotalCount; + uint32_t maxMeshWorkGroupCount[3]; + uint32_t maxMeshWorkGroupInvocations; + uint32_t maxMeshWorkGroupSize[3]; + uint32_t maxMeshSharedMemorySize; + uint32_t maxMeshPayloadAndSharedMemorySize; + uint32_t maxMeshOutputMemorySize; + uint32_t maxMeshPayloadAndOutputMemorySize; + uint32_t maxMeshOutputComponents; + uint32_t maxMeshOutputVertices; + uint32_t maxMeshOutputPrimitives; + uint32_t maxMeshOutputLayers; + uint32_t maxMeshMultiviewViewCount; + uint32_t meshOutputPerVertexGranularity; + uint32_t meshOutputPerPrimitiveGranularity; + uint32_t maxPreferredTaskWorkGroupInvocations; + uint32_t maxPreferredMeshWorkGroupInvocations; + VkBool32 prefersLocalInvocationVertexOutput; + VkBool32 prefersLocalInvocationPrimitiveOutput; + VkBool32 prefersCompactVertexOutput; + VkBool32 prefersCompactPrimitiveOutput; + + safe_VkPhysicalDeviceMeshShaderPropertiesEXT(const VkPhysicalDeviceMeshShaderPropertiesEXT* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceMeshShaderPropertiesEXT(const safe_VkPhysicalDeviceMeshShaderPropertiesEXT& copy_src); + safe_VkPhysicalDeviceMeshShaderPropertiesEXT& operator=(const safe_VkPhysicalDeviceMeshShaderPropertiesEXT& copy_src); + safe_VkPhysicalDeviceMeshShaderPropertiesEXT(); + ~safe_VkPhysicalDeviceMeshShaderPropertiesEXT(); + void initialize(const VkPhysicalDeviceMeshShaderPropertiesEXT* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceMeshShaderPropertiesEXT* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceMeshShaderPropertiesEXT* ptr() { return reinterpret_cast(this); } + VkPhysicalDeviceMeshShaderPropertiesEXT const* ptr() const { + return reinterpret_cast(this); + } +}; + +// Safe struct that spans NV and KHR VkRayTracingPipelineCreateInfo structures. +// It is a VkRayTracingPipelineCreateInfoKHR and supports construction from +// a VkRayTracingPipelineCreateInfoNV. +class safe_VkRayTracingPipelineCreateInfoCommon : public safe_VkRayTracingPipelineCreateInfoKHR { + public: + safe_VkRayTracingPipelineCreateInfoCommon() : safe_VkRayTracingPipelineCreateInfoKHR() {} + safe_VkRayTracingPipelineCreateInfoCommon(const VkRayTracingPipelineCreateInfoNV* pCreateInfo) + : safe_VkRayTracingPipelineCreateInfoKHR() { + initialize(pCreateInfo); + } + safe_VkRayTracingPipelineCreateInfoCommon(const VkRayTracingPipelineCreateInfoKHR* pCreateInfo) + : safe_VkRayTracingPipelineCreateInfoKHR(pCreateInfo) {} + + void initialize(const VkRayTracingPipelineCreateInfoNV* pCreateInfo); + void initialize(const VkRayTracingPipelineCreateInfoKHR* pCreateInfo); + uint32_t maxRecursionDepth = 0; // NV specific +}; + +} // namespace vku + +// NOLINTEND diff --git a/include/vulkan/utility/vk_safe_struct_utils.hpp b/include/vulkan/utility/vk_safe_struct_utils.hpp new file mode 100644 index 0000000..9606df4 --- /dev/null +++ b/include/vulkan/utility/vk_safe_struct_utils.hpp @@ -0,0 +1,128 @@ +/*************************************************************************** + * + * Copyright (c) 2015-2024 The Khronos Group Inc. + * Copyright (c) 2015-2024 Valve Corporation + * Copyright (c) 2015-2024 LunarG, Inc. + * Copyright (c) 2015-2024 Google Inc. + * + * SPDX-License-Identifier: Apache-2.0 + * + ****************************************************************************/ + +#pragma once +#include +#include +#include +#include +#include +#include + +namespace vku { + +// Mapping of unknown stype codes to structure lengths. This should be set up by the application +// before vkCreateInstance() and not modified afterwards. +extern std::vector> custom_stype_info; + +// State that elements in a pNext chain may need to be aware of +struct PNextCopyState { + // Custom initialization function. Returns true if the structure passed to init was initialized, false otherwise + std::function init; +}; + +void* SafePnextCopy(const void* pNext, PNextCopyState* copy_state = {}); +void FreePnextChain(const void* pNext); +char* SafeStringCopy(const char* in_string); + +template +bool AddToPnext(Base& base, const T& data) { + assert(base.ptr()); // All safe struct have a ptr() method. Prevent use with non-safe structs. + auto** prev = reinterpret_cast(const_cast(&base.pNext)); + auto* current = *prev; + while (current) { + if (data.sType == current->sType) { + return false; + } + prev = reinterpret_cast(¤t->pNext); + current = *prev; + } + *prev = reinterpret_cast(SafePnextCopy(&data)); + return true; +} + +template +bool RemoveFromPnext(Base& base, VkStructureType t) { + assert(base.ptr()); // All safe struct have a ptr() method. Prevent use with non-safe structs. + auto** prev = reinterpret_cast(const_cast(&base.pNext)); + auto* current = *prev; + while (current) { + if (t == current->sType) { + *prev = current->pNext; + current->pNext = nullptr; + FreePnextChain(current); + return true; + } + prev = reinterpret_cast(¤t->pNext); + current = *prev; + } + return false; +} + +template +uint32_t FindExtension(CreateInfo& ci, const char* extension_name) { + assert(ci.ptr()); // All safe struct have a ptr() method. Prevent use with non-safe structs. + for (uint32_t i = 0; i < ci.enabledExtensionCount; i++) { + if (strcmp(ci.ppEnabledExtensionNames[i], extension_name) == 0) { + return i; + } + } + return ci.enabledExtensionCount; +} + +template +bool AddExtension(CreateInfo& ci, const char* extension_name) { + assert(ci.ptr()); // All safe struct have a ptr() method. Prevent use with non-safe structs. + uint32_t pos = FindExtension(ci, extension_name); + if (pos < ci.enabledExtensionCount) { + // already present + return false; + } + char** exts = new char*[ci.enabledExtensionCount + 1]; + memcpy(exts, ci.ppEnabledExtensionNames, sizeof(char*) * ci.enabledExtensionCount); + exts[ci.enabledExtensionCount] = SafeStringCopy(extension_name); + delete[] ci.ppEnabledExtensionNames; + ci.ppEnabledExtensionNames = exts; + ci.enabledExtensionCount++; + return true; +} + +template +bool RemoveExtension(CreateInfo& ci, const char* extension_name) { + assert(ci.ptr()); // All safe struct have a ptr() method. Prevent use with non-safe structs. + uint32_t pos = FindExtension(ci, extension_name); + if (pos >= ci.enabledExtensionCount) { + // not present + return false; + } + if (ci.enabledExtensionCount == 1) { + delete[] ci.ppEnabledExtensionNames[0]; + delete[] ci.ppEnabledExtensionNames; + ci.ppEnabledExtensionNames = nullptr; + ci.enabledExtensionCount = 0; + return true; + } + uint32_t out_pos = 0; + char** exts = new char*[ci.enabledExtensionCount - 1]; + for (uint32_t i = 0; i < ci.enabledExtensionCount; i++) { + if (i == pos) { + delete[] ci.ppEnabledExtensionNames[i]; + } else { + exts[out_pos++] = const_cast(ci.ppEnabledExtensionNames[i]); + } + } + delete[] ci.ppEnabledExtensionNames; + ci.ppEnabledExtensionNames = exts; + ci.enabledExtensionCount--; + return true; +} + +} // namespace vku diff --git a/scripts/common_ci.py b/scripts/common_ci.py new file mode 100644 index 0000000..32a8ec7 --- /dev/null +++ b/scripts/common_ci.py @@ -0,0 +1,54 @@ +#!/usr/bin/python3 -i +# +# Copyright (c) 2015-2024 The Khronos Group Inc. +# Copyright (c) 2015-2024 Valve Corporation +# Copyright (c) 2015-2024 LunarG, Inc. +# +# SPDX-License-Identifier: Apache-2.0 + +import os +import sys +import subprocess +import platform + +# Use Ninja for all platforms for performance/simplicity +os.environ['CMAKE_GENERATOR'] = "Ninja" + +# helper to define paths relative to the repo root +def RepoRelative(path): + return os.path.abspath(os.path.join(os.path.dirname(__file__), '..', path)) + +# Points to the directory containing the top level CMakeLists.txt +PROJECT_SRC_DIR = os.path.abspath(os.path.join(os.path.split(os.path.abspath(__file__))[0], '..')) +if not os.path.isfile(f'{PROJECT_SRC_DIR}/CMakeLists.txt'): + print(f'PROJECT_SRC_DIR invalid! {PROJECT_SRC_DIR}') + sys.exit(1) + +# Returns true if we are running in GitHub actions +# https://docs.github.com/en/actions/learn-github-actions/variables#default-environment-variables +def IsGHA(): + if 'GITHUB_ACTION' in os.environ: + return True + return False + +# Runs a command in a directory and returns its return code. +# Directory is project root by default, or a relative path from project root +def RunShellCmd(command, start_dir = PROJECT_SRC_DIR, env=None, verbose=False): + # Flush stdout here. Helps when debugging on CI. + sys.stdout.flush() + + if start_dir != PROJECT_SRC_DIR: + start_dir = RepoRelative(start_dir) + cmd_list = command.split(" ") + + # Helps a lot when debugging CI issues + if IsGHA(): + verbose = True + + if verbose: + print(f'CICMD({cmd_list}, env={env})') + subprocess.check_call(cmd_list, cwd=start_dir, env=env) + +# +# Check if the system is Windows +def IsWindows(): return 'windows' == platform.system().lower() diff --git a/scripts/generate_source.py b/scripts/generate_source.py index 3abecea..8be15a0 100755 --- a/scripts/generate_source.py +++ b/scripts/generate_source.py @@ -8,10 +8,16 @@ import argparse import os import sys +import shutil +import common_ci from xml.etree import ElementTree def RunGenerators(api: str, registry: str, targetFilter: str) -> None: + has_clang_format = shutil.which('clang-format') is not None + if not has_clang_format: + print("WARNING: Unable to find clang-format!") + # These live in the Vulkan-Docs repo, but are pulled in via the # Vulkan-Headers/registry folder # At runtime we inject python path to find these helper scripts @@ -26,6 +32,7 @@ def RunGenerators(api: str, registry: str, targetFilter: str) -> None: from generators.enum_string_helper_generator import EnumStringHelperOutputGenerator from generators.format_utils_generator import FormatUtilsOutputGenerator from generators.struct_helper_generator import StructHelperOutputGenerator + from generators.safe_struct_generator import SafeStructOutputGenerator # These set fields that are needed by both OutputGenerator and BaseGenerator, # but are uniform and don't need to be set at a per-generated file level @@ -54,6 +61,37 @@ def RunGenerators(api: str, registry: str, targetFilter: str) -> None: 'genCombined': True, 'directory' : f'include/{api}/utility', }, + 'vk_safe_struct.hpp' : { + 'generator' : SafeStructOutputGenerator, + 'genCombined': True, + 'directory' : f'include/{api}/utility', + }, + 'vk_safe_struct_utils.cpp' : { + 'generator' : SafeStructOutputGenerator, + 'genCombined': True, + 'directory' : f'src/{api}', + }, + 'vk_safe_struct_core.cpp' : { + 'generator' : SafeStructOutputGenerator, + 'genCombined': True, + 'regenerate' : True, + 'directory' : f'src/{api}', + }, + 'vk_safe_struct_khr.cpp' : { + 'generator' : SafeStructOutputGenerator, + 'genCombined': True, + 'directory' : f'src/{api}', + }, + 'vk_safe_struct_ext.cpp' : { + 'generator' : SafeStructOutputGenerator, + 'genCombined': True, + 'directory' : f'src/{api}', + }, + 'vk_safe_struct_vendor.cpp' : { + 'generator' : SafeStructOutputGenerator, + 'genCombined': True, + 'directory' : f'src/{api}', + }, } if (targetFilter and targetFilter not in generators.keys()): @@ -102,6 +140,9 @@ def RunGenerators(api: str, registry: str, targetFilter: str) -> None: # Finally, use the output generator to create the requested target reg.apiGen() + # Run clang-format on the file + if has_clang_format: + common_ci.RunShellCmd(f'clang-format -i {os.path.join(outDirectory, target)}') def main(argv): parser = argparse.ArgumentParser(description='Generate source code for this repository') diff --git a/scripts/generators/base_generator.py b/scripts/generators/base_generator.py index 2d8635e..639acfe 100644 --- a/scripts/generators/base_generator.py +++ b/scripts/generators/base_generator.py @@ -1,12 +1,14 @@ #!/usr/bin/python3 -i # -# Copyright 2023-2024 The Khronos Group Inc. -# Copyright 2023-2024 Valve Corporation -# Copyright 2023-2024 LunarG, Inc. -# Copyright 2023-2024 RasterGrid Kft. +# Copyright (c) 2023-2024 Valve Corporation +# Copyright (c) 2023-2024 LunarG, Inc. +# Copyright (c) 2023-2024 RasterGrid Kft. # # SPDX-License-Identifier: Apache-2.0 +import pickle +import os +import tempfile from generators.vulkan_object import (VulkanObject, Extension, Version, Handle, Param, Queues, CommandScope, Command, EnumField, Enum, Flag, Bitmask, Member, Struct, @@ -70,6 +72,11 @@ def SetMergedApiNames(names: str) -> None: global mergedApiNames mergedApiNames = names +cachingEnabled = False +def EnableCaching() -> None: + global cachingEnabled + cachingEnabled = True + # This class is a container for any source code, data, or other behavior that is necessary to # customize the generator script for a specific target API variant (e.g. Vulkan SC). As such, # all of these API-specific interfaces and their use in the generator script are part of the @@ -111,7 +118,7 @@ def __init__(self, self.apicall = 'VKAPI_ATTR ' self.apientry = 'VKAPI_CALL ' self.apientryp = 'VKAPI_PTR *' - self.alignFuncParam = 48 + self.alignFuncParam = 48 # # This object handles all the parsing from reg.py generator scripts in the Vulkan-Headers @@ -219,7 +226,6 @@ def applyExtensionDependency(self): enum.fieldExtensions.extend([extension] if extension not in enum.fieldExtensions else []) enumField.extensions.extend([extension] if extension not in enumField.extensions else []) extension.enumFields[group].extend([enumField] if enumField not in extension.enumFields[group] else []) - if group in self.vk.bitmasks: if group not in extension.flags: extension.flags[group] = [] # Dict needs init @@ -229,11 +235,10 @@ def applyExtensionDependency(self): for flags in [x for x in bitmask.flags if x.name in flagList]: # Make sure list is unique - bitmask.extensions.extend([extension] if extension not in bitmask.extensions else []) + bitmask.flagExtensions.extend([extension] if extension not in bitmask.flagExtensions else []) flags.extensions.extend([extension] if extension not in flags.extensions else []) extension.flags[group].extend([flags] if flags not in extension.flags[group] else []) - # Need to do 'enum'/'bitmask' after 'enumconstant' has applied everything so we can add implicit extensions # # Sometimes two extensions enable an Enum, but the newer extension version has extra flags allowed @@ -267,17 +272,18 @@ def applyExtensionDependency(self): for required in dict: for group in dict[required]: for bitmaskName in dict[required][group]: - isAlias = bitmaskName in self.enumAliasMap + bitmaskName = bitmaskName.replace('Flags', 'FlagBits') # Works since Flags isn't repeated in name + isAlias = bitmaskName in self.bitmaskAliasMap bitmaskName = self.bitmaskAliasMap[bitmaskName] if isAlias else bitmaskName if bitmaskName in self.vk.bitmasks: bitmask = self.vk.bitmasks[bitmaskName] bitmask.extensions.extend([extension] if extension not in bitmask.extensions else []) - extension.bitmask.extend([bitmask] if bitmask not in extension.bitmasks else []) + extension.bitmasks.extend([bitmask] if bitmask not in extension.bitmasks else []) # Update flags with implicit base extension if isAlias: continue - bitmask.flagExtensions.extend([extension] if extension not in enum.flagExtensions else []) - for flag in [x for x in enum.flags if (not x.extensions or (x.extensions and all(e in enum.extensions for e in x.extensions)))]: + bitmask.flagExtensions.extend([extension] if extension not in bitmask.flagExtensions else []) + for flag in [x for x in bitmask.flags if (not x.extensions or (x.extensions and all(e in bitmask.extensions for e in x.extensions)))]: flag.extensions.extend([extension] if extension not in flag.extensions else []) if bitmaskName not in extension.flags: extension.flags[bitmaskName] = [] # Dict needs init @@ -304,9 +310,17 @@ def endFile(self): for struct in [x for x in self.vk.structs.values() if not x.returnedOnly]: for enum in [self.vk.enums[x.type] for x in struct.members if x.type in self.vk.enums]: enum.returnedOnly = False + for bitmask in [self.vk.bitmasks[x.type] for x in struct.members if x.type in self.vk.bitmasks]: + bitmask.returnedOnly = False + for bitmask in [self.vk.bitmasks[x.type.replace('Flags', 'FlagBits')] for x in struct.members if x.type.replace('Flags', 'FlagBits') in self.vk.bitmasks]: + bitmask.returnedOnly = False for command in self.vk.commands.values(): for enum in [self.vk.enums[x.type] for x in command.params if x.type in self.vk.enums]: enum.returnedOnly = False + for bitmask in [self.vk.bitmasks[x.type] for x in command.params if x.type in self.vk.bitmasks]: + bitmask.returnedOnly = False + for bitmask in [self.vk.bitmasks[x.type.replace('Flags', 'FlagBits')] for x in command.params if x.type.replace('Flags', 'FlagBits') in self.vk.bitmasks]: + bitmask.returnedOnly = False # Turn handle parents into pointers to classess for handle in [x for x in self.vk.handles.values() if x.parent is not None]: @@ -327,9 +341,26 @@ def endFile(self): # All inherited generators should run from here self.generate() + if cachingEnabled: + cachePath = os.path.join(tempfile.gettempdir(), f'vkobject_{os.getpid()}') + if not os.path.isfile(cachePath): + cacheFile = open(cachePath, 'wb') + pickle.dump(self.vk, cacheFile) + cacheFile.close() + # This should not have to do anything but call into OutputGenerator OutputGenerator.endFile(self) + # + # Bypass the entire processing and load in the VkObject data + # Still need to handle the beingFile/endFile for reg.py + def generateFromCache(self, cacheVkObjectData, genOpts): + OutputGenerator.beginFile(self, genOpts) + self.filename = genOpts.filename + self.vk = cacheVkObjectData + self.generate() + OutputGenerator.endFile(self) + # # Processing point at beginning of each extension definition def beginFeature(self, interface, emit): @@ -337,7 +368,6 @@ def beginFeature(self, interface, emit): platform = interface.get('platform') self.featureExtraProtec = self.vk.platforms[platform] if platform in self.vk.platforms else None protect = self.vk.platforms[platform] if platform in self.vk.platforms else None - name = interface.get('name') if interface.tag == 'extension': @@ -463,7 +493,7 @@ def genGroup(self, groupinfo, groupName, alias): # fields also have their own protect groupProtect = self.currentExtension.protect if hasattr(self.currentExtension, 'protect') and self.currentExtension.protect is not None else None enumElem = groupinfo.elem - bitwidth = 32 if enumElem.get('bitwidth') is None else enumElem.get('bitwidth') + bitwidth = 32 if enumElem.get('bitwidth') is None else int(enumElem.get('bitwidth')) fields = [] if enumElem.get('type') == "enum": if alias is not None: @@ -514,7 +544,7 @@ def genGroup(self, groupinfo, groupName, alias): fields.append(Flag(flagName, protect, flagValue, flagMultiBit, flagZero, [])) flagName = groupName.replace('FlagBits', 'Flags') - self.vk.bitmasks[groupName] = Bitmask(groupName, flagName, groupProtect, bitwidth, fields, [], []) + self.vk.bitmasks[groupName] = Bitmask(groupName, flagName, groupProtect, bitwidth, True, fields, [], []) def genType(self, typeInfo, typeName, alias): OutputGenerator.genType(self, typeInfo, typeName, alias) diff --git a/scripts/generators/dispatch_table_generator.py b/scripts/generators/dispatch_table_generator.py index 3edaacf..ebab6ea 100644 --- a/scripts/generators/dispatch_table_generator.py +++ b/scripts/generators/dispatch_table_generator.py @@ -44,9 +44,9 @@ def generate(self): ''') guard_helper = PlatformGuardHelper() for command in [x for x in self.vk.commands.values() if x.instance]: - out.extend(guard_helper.addGuard(command.protect)) + out.extend(guard_helper.add_guard(command.protect)) out.append(f' PFN_{command.name} {command.name[2:]};\n') - out.extend(guard_helper.addGuard(None)) + out.extend(guard_helper.add_guard(None)) out.append('} VkuInstanceDispatchTable;\n') out.append(''' @@ -54,9 +54,9 @@ def generate(self): typedef struct VkuDeviceDispatchTable_ { ''') for command in [x for x in self.vk.commands.values() if x.device]: - out.extend(guard_helper.addGuard(command.protect)) + out.extend(guard_helper.add_guard(command.protect)) out.append(f' PFN_{command.name} {command.name[2:]};\n') - out.extend(guard_helper.addGuard(None)) + out.extend(guard_helper.add_guard(None)) out.append('} VkuDeviceDispatchTable;\n') out.append(''' @@ -67,9 +67,9 @@ def generate(self): ''') for command in [x for x in self.vk.commands.values() if x.device and x.name != 'vkGetDeviceProcAddr']: - out.extend(guard_helper.addGuard(command.protect)) + out.extend(guard_helper.add_guard(command.protect)) out.append(f' table->{command.name[2:]} = (PFN_{command.name})gdpa(device, "{command.name}");\n') - out.extend(guard_helper.addGuard(None)) + out.extend(guard_helper.add_guard(None)) out.append('}\n') out.append(''' @@ -89,9 +89,9 @@ def generate(self): 'vkEnumerateInstanceVersion', 'vkGetInstanceProcAddr', ]]: - out.extend(guard_helper.addGuard(command.protect)) + out.extend(guard_helper.add_guard(command.protect)) out.append(f' table->{command.name[2:]} = (PFN_{command.name})gipa(instance, "{command.name}");\n') - out.extend(guard_helper.addGuard(None)) + out.extend(guard_helper.add_guard(None)) out.append('}\n') out.append('// clang-format on') diff --git a/scripts/generators/enum_string_helper_generator.py b/scripts/generators/enum_string_helper_generator.py index 5c45b55..33a0a2a 100644 --- a/scripts/generators/enum_string_helper_generator.py +++ b/scripts/generators/enum_string_helper_generator.py @@ -39,20 +39,20 @@ def generate(self): # If there are no fields (empty enum) ignore for enum in [x for x in self.vk.enums.values() if len(x.fields) > 0]: groupType = enum.name if enum.bitWidth == 32 else 'uint64_t' - out.extend(guard_helper.addGuard(enum.protect)) + out.extend(guard_helper.add_guard(enum.protect)) out.append(f'static inline const char* string_{enum.name}({groupType} input_value) {{\n') out.append(' switch (input_value) {\n') enum_field_guard_helper = PlatformGuardHelper() for field in enum.fields: - out.extend(enum_field_guard_helper.addGuard(field.protect)) + out.extend(enum_field_guard_helper.add_guard(field.protect)) out.append(f' case {field.name}:\n') out.append(f' return "{field.name}";\n') - out.extend(enum_field_guard_helper.addGuard(None)) + out.extend(enum_field_guard_helper.add_guard(None)) out.append(' default:\n') out.append(f' return "Unhandled {enum.name}";\n') out.append(' }\n') out.append('}\n') - out.extend(guard_helper.addGuard(None)) + out.extend(guard_helper.add_guard(None)) out.append('\n') # For bitmask, first create a string for FlagBits, then a Flags version that calls into it @@ -65,26 +65,26 @@ def generate(self): if groupType == 'uint64_t': use_switch_statement = False - out.extend(guard_helper.addGuard(bitmask.protect)) + out.extend(guard_helper.add_guard(bitmask.protect)) out.append(f'static inline const char* string_{bitmask.name}({groupType} input_value) {{\n') bitmask_field_guard_helper = PlatformGuardHelper() if use_switch_statement: out.append(' switch (input_value) {\n') for flag in [x for x in bitmask.flags if not x.multiBit]: - out.extend(bitmask_field_guard_helper.addGuard(flag.protect)) + out.extend(bitmask_field_guard_helper.add_guard(flag.protect)) out.append(f' case {flag.name}:\n') out.append(f' return "{flag.name}";\n') - out.extend(bitmask_field_guard_helper.addGuard(None)) + out.extend(bitmask_field_guard_helper.add_guard(None)) out.append(' default:\n') out.append(f' return "Unhandled {bitmask.name}";\n') out.append(' }\n') else: # We need to use if statements for flag in [x for x in bitmask.flags if not x.multiBit]: - out.extend(bitmask_field_guard_helper.addGuard(flag.protect)) + out.extend(bitmask_field_guard_helper.add_guard(flag.protect)) out.append(f' if (input_value == {flag.name}) return "{flag.name}";\n') - out.extend(bitmask_field_guard_helper.addGuard(None)) + out.extend(bitmask_field_guard_helper.add_guard(None)) out.append(f' return "Unhandled {bitmask.name}";\n') out.append('}\n') @@ -110,6 +110,6 @@ def generate(self): return ret; }}\n''') out.append('#endif // __cplusplus\n') - out.extend(guard_helper.addGuard(None)) + out.extend(guard_helper.add_guard(None)) out.append('// clang-format on') self.write("".join(out)) diff --git a/scripts/generators/generator_utils.py b/scripts/generators/generator_utils.py index 387812e..e3e499d 100644 --- a/scripts/generators/generator_utils.py +++ b/scripts/generators/generator_utils.py @@ -1,25 +1,148 @@ #!/usr/bin/python3 -i # -# Copyright 2023 The Khronos Group Inc. -# Copyright 2023 Valve Corporation -# Copyright 2023 LunarG, Inc. -# Copyright 2023 RasterGrid Kft. +# Copyright (c) 2023-2024 Valve Corporation +# Copyright (c) 2023-2024 LunarG, Inc. # # SPDX-License-Identifier: Apache-2.0 +import os +import sys +import json + +# Build a set of all vuid text strings found in validusage.json +def buildListVUID(valid_usage_file: str) -> set: + + # Walk the JSON-derived dict and find all "vuid" key values + def ExtractVUIDs(vuid_dict): + if hasattr(vuid_dict, 'items'): + for key, value in vuid_dict.items(): + if key == "vuid": + yield value + elif isinstance(value, dict): + for vuid in ExtractVUIDs(value): + yield vuid + elif isinstance (value, list): + for listValue in value: + for vuid in ExtractVUIDs(listValue): + yield vuid + + valid_vuids = set() + if not os.path.isfile(valid_usage_file): + print(f'Error: Could not find, or error loading {valid_usage_file}') + sys.exit(1) + json_file = open(valid_usage_file, 'r', encoding='utf-8') + vuid_dict = json.load(json_file) + json_file.close() + if len(vuid_dict) == 0: + print(f'Error: Failed to load {valid_usage_file}') + sys.exit(1) + for json_vuid_string in ExtractVUIDs(vuid_dict): + valid_vuids.add(json_vuid_string) + + # List of VUs that should exists, but have a spec bug + for vuid in [ + # https://gitlab.khronos.org/vulkan/vulkan/-/issues/3582 + "VUID-VkCopyImageToImageInfoEXT-commonparent", + "VUID-vkUpdateDescriptorSetWithTemplate-descriptorSet-parent", + "VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-parent", + "VUID-vkDestroyVideoSessionParametersKHR-videoSessionParameters-parent", + "VUID-vkGetDescriptorSetHostMappingVALVE-descriptorSet-parent", + ]: + valid_vuids.add(vuid) + + return valid_vuids + +# Will do a sanity check the VUID exists +def getVUID(valid_vuids: set, vuid: str, quotes: bool = True) -> str: + if vuid not in valid_vuids: + print(f'Warning: Could not find {vuid} in validusage.json') + vuid = vuid.replace('VUID-', 'UNASSIGNED-') + return vuid if not quotes else f'"{vuid}"' + class PlatformGuardHelper(): """Used to elide platform guards together, so redundant #endif then #ifdefs are removed - Note - be sure to call addGuard(None) when done to add a trailing #endif if needed + Note - be sure to call add_guard(None) when done to add a trailing #endif if needed """ def __init__(self): - self.currentGuard = None + self.current_guard = None - def addGuard(self, guard): + def add_guard(self, guard, extra_newline = False): out = [] - if self.currentGuard != guard: - if self.currentGuard != None: - out.append(f'#endif // {self.currentGuard}\n') - if guard != None: - out.append(f'#ifdef {guard}\n') - self.currentGuard = guard + if self.current_guard != guard and self.current_guard is not None: + out.append(f'#endif // {self.current_guard}\n') + if extra_newline: + out.append('\n') + if self.current_guard != guard and guard is not None: + out.append(f'#ifdef {guard}\n') + self.current_guard = guard return out + +# The SPIR-V grammar json doesn't have an easy way to detect these, so have listed by hand +# If we are missing one, its not critical, the goal of this list is to reduce the generated output size +def IsNonVulkanSprivCapability(capability): + return capability in [ + 'Kernel', + 'Vector16', + 'Float16Buffer', + 'ImageBasic', + 'ImageReadWrite', + 'ImageMipmap', + 'DeviceEnqueue', + 'SubgroupDispatch', + 'Pipes', + 'LiteralSampler', + 'NamedBarrier', + 'PipeStorage', + 'SubgroupShuffleINTEL', + 'SubgroupShuffleINTEL', + 'SubgroupBufferBlockIOINTEL', + 'SubgroupImageBlockIOINTEL', + 'SubgroupImageMediaBlockIOINTEL', + 'RoundToInfinityINTEL', + 'FloatingPointModeINTEL', + 'IndirectReferencesINTEL', + 'AsmINTEL', + 'VectorComputeINTEL', + 'VectorAnyINTEL', + 'SubgroupAvcMotionEstimationINTEL', + 'SubgroupAvcMotionEstimationIntraINTEL', + 'SubgroupAvcMotionEstimationChromaINTEL', + 'VariableLengthArrayINTEL', + 'FunctionFloatControlINTEL', + 'FPGAMemoryAttributesINTEL', + 'FPFastMathModeINTEL', + 'ArbitraryPrecisionIntegersINTEL', + 'ArbitraryPrecisionFloatingPointINTEL', + 'UnstructuredLoopControlsINTEL', + 'FPGALoopControlsINTEL', + 'KernelAttributesINTEL', + 'FPGAKernelAttributesINTEL', + 'FPGAMemoryAccessesINTEL', + 'FPGAClusterAttributesINTEL', + 'LoopFuseINTEL', + 'FPGADSPControlINTEL', + 'MemoryAccessAliasingINTEL', + 'FPGAInvocationPipeliningAttributesINTEL', + 'FPGABufferLocationINTEL', + 'ArbitraryPrecisionFixedPointINTEL', + 'USMStorageClassesINTEL', + 'RuntimeAlignedAttributeINTEL', + 'IOPipesINTEL', + 'BlockingPipesINTEL', + 'FPGARegINTEL', + 'LongCompositesINTEL', + 'OptNoneINTEL', + 'DebugInfoModuleINTEL', + 'BFloat16ConversionINTEL', + 'SplitBarrierINTEL', + 'FPGAClusterAttributesV2INTEL', + 'FPGAKernelAttributesv2INTEL', + 'FPMaxErrorINTEL', + 'FPGALatencyControlINTEL', + 'FPGAArgumentInterfacesINTEL', + 'GlobalVariableHostAccessINTEL', + 'GlobalVariableFPGADecorationsINTEL', + 'MaskedGatherScatterINTEL', + 'CacheControlsINTEL', + 'RegisterLimitsINTEL' + ] diff --git a/scripts/generators/safe_struct_generator.py b/scripts/generators/safe_struct_generator.py new file mode 100644 index 0000000..b9e0de4 --- /dev/null +++ b/scripts/generators/safe_struct_generator.py @@ -0,0 +1,797 @@ +#!/usr/bin/python3 -i +# +# Copyright (c) 2015-2024 The Khronos Group Inc. +# Copyright (c) 2015-2024 Valve Corporation +# Copyright (c) 2015-2024 LunarG, Inc. +# Copyright (c) 2015-2024 Google Inc. +# Copyright (c) 2023-2024 RasterGrid Kft. +# +# SPDX-License-Identifier: Apache-2.0 + +import os +import re +from generators.vulkan_object import Struct, Member +from generators.base_generator import BaseGenerator +from generators.generator_utils import PlatformGuardHelper + +class SafeStructOutputGenerator(BaseGenerator): + def __init__(self): + BaseGenerator.__init__(self) + + # Will skip completly, mainly used for things that have no one consuming the safe struct + self.no_autogen = [ + # These WSI struct have nothing deep to copy, except the WSI releated field which we can't make a copy + 'VkXlibSurfaceCreateInfoKHR', + 'VkXcbSurfaceCreateInfoKHR', + 'VkWaylandSurfaceCreateInfoKHR', + 'VkAndroidSurfaceCreateInfoKHR', + 'VkWin32SurfaceCreateInfoKHR', + 'VkIOSSurfaceCreateInfoMVK', + 'VkMacOSSurfaceCreateInfoMVK', + 'VkMetalSurfaceCreateInfoEXT' + ] + + # Will skip generating the source logic (to be implemented in vk_safe_struct_manual.cpp) + # The header will still be generated + self.manual_source = [ + # This needs to know if we're doing a host or device build, logic becomes complex and very specialized + 'VkAccelerationStructureBuildGeometryInfoKHR', + 'VkAccelerationStructureGeometryKHR', + # Have a pUsageCounts and ppUsageCounts that is not currently handled in the generated code + 'VkMicromapBuildInfoEXT', + 'VkAccelerationStructureTrianglesOpacityMicromapEXT', + 'VkAccelerationStructureTrianglesDisplacementMicromapNV', + # The VkDescriptorType field needs to handle every type which is something best done manually + 'VkDescriptorDataEXT', + # Special case because its pointers may be non-null but ignored + 'VkGraphicsPipelineCreateInfo', + # Special case because it has custom construct parameters + 'VkPipelineViewportStateCreateInfo', + ] + + # For abstract types just want to save the pointer away + # since we cannot make a copy. + self.abstract_types = [ + 'AHardwareBuffer', + ] + + # These 'data' union are decided by the 'type' in the same parent struct + self.union_of_pointers = [ + 'VkDescriptorDataEXT', + ] + self.union_of_pointer_callers = [ + 'VkDescriptorGetInfoEXT', + ] + + # Will update the the function interface + self.custom_construct_params = { + # vku::safe::GraphicsPipelineCreateInfo needs to know if subpass has color and\or depth\stencil attachments to use its pointers + 'VkGraphicsPipelineCreateInfo' : + ', const bool uses_color_attachment, const bool uses_depthstencil_attachment', + # vku::safe::PipelineViewportStateCreateInfo needs to know if viewport and scissor is dynamic to use its pointers + 'VkPipelineViewportStateCreateInfo' : + ', const bool is_dynamic_viewports, const bool is_dynamic_scissors', + # vku::safe::AccelerationStructureBuildGeometryInfoKHR needs to know if we're doing a host or device build + 'VkAccelerationStructureBuildGeometryInfoKHR' : + ', const bool is_host, const VkAccelerationStructureBuildRangeInfoKHR *build_range_infos', + # vku::safe::AccelerationStructureGeometryKHR needs to know if we're doing a host or device build + 'VkAccelerationStructureGeometryKHR' : + ', const bool is_host, const VkAccelerationStructureBuildRangeInfoKHR *build_range_info', + # vku::safe::DescriptorDataEXT needs to know what field of union is intialized + 'VkDescriptorDataEXT' : + ', const VkDescriptorType type', + } + + # Determine if a structure needs a safe_struct helper function + # That is, it has an sType or one of its members is a pointer + def needSafeStruct(self, struct: Struct) -> bool: + if struct.name in self.no_autogen: + return False + if 'VkBase' in struct.name: + return False # Ingore structs like VkBaseOutStructure + if struct.sType is not None: + return True + for member in struct.members: + if member.pointer: + return True + return False + + def containsObjectHandle(self, member: Member) -> bool: + if member.type in self.vk.handles: + return True + if member.type in self.vk.structs: + for subMember in self.vk.structs[member.type].members: + if self.containsObjectHandle(subMember): + return True + return False + + def typeContainsObjectHandle(self, handle_type: str, dispatchable: bool) -> bool: + if handle_type in self.vk.handles: + if dispatchable == self.vk.handles[handle_type].dispatchable: + return True + # if handle_type is a struct, search its members + if handle_type in self.vk.structs: + struct = self.vk.structs[handle_type] + for member in [x for x in struct.members if x.type in self.vk.handles]: + if dispatchable == self.vk.handles[member.type].dispatchable: + return True + return False + + def generate(self): + self.write(f'''// *** THIS FILE IS GENERATED - DO NOT EDIT *** + // See {os.path.basename(__file__)} for modifications + + /*************************************************************************** + * + * Copyright (c) 2015-2024 The Khronos Group Inc. + * Copyright (c) 2015-2024 Valve Corporation + * Copyright (c) 2015-2024 LunarG, Inc. + * Copyright (c) 2015-2024 Google Inc. + * + * SPDX-License-Identifier: Apache-2.0 + * + ****************************************************************************/\n''') + self.write('// NOLINTBEGIN') # Wrap for clang-tidy to ignore + + if self.filename == 'vk_safe_struct.hpp': + self.generateHeader() + elif self.filename == 'vk_safe_struct_utils.cpp': + self.generateUtil() + elif self.filename.startswith('vk_safe_struct_'): + self.generateSource() + else: + self.write(f'\nFile name {self.filename} has no code to generate\n') + + self.write('// NOLINTEND') # Wrap for clang-tidy to ignore + + def convertName(self, vk_name): + return "safe_" + vk_name + + def generateHeader(self): + out = [] + out.append(''' + #pragma once + #include + #include + + #include + + namespace vku { + \n''') + + guard_helper = PlatformGuardHelper() + for struct in [x for x in self.vk.structs.values() if self.needSafeStruct(x)]: + safe_name = self.convertName(struct.name) + out.extend(guard_helper.add_guard(struct.protect)) + out.append(f'{"union" if struct.union else "struct"} {safe_name} {{\n') + # Can only initialize first member of an Union + canInitialize = True + copy_pnext = ', bool copy_pnext = true' if struct.sType is not None else '' + for member in struct.members: + if member.type in self.vk.structs: + if self.needSafeStruct(self.vk.structs[member.type]): + safe_member_type = self.convertName(member.type) + if member.pointer: + pointer = '*' * member.cDeclaration.count('*') + brackets = '' if struct.union else '{}' + out.append(f'{safe_member_type}{pointer} {member.name}{brackets};\n') + else: + out.append(f'{safe_member_type} {member.name};\n') + continue + + explicitInitialize = member.pointer and 'PFN_' not in member.type and canInitialize + initialize = '{}' if explicitInitialize else '' + # Prevents union from initializing agian + canInitialize = not struct.union if explicitInitialize else canInitialize + + if member.length and self.containsObjectHandle(member) and not member.fixedSizeArray: + out.append(f' {member.type}* {member.name}{initialize};\n') + else: + out.append(f'{member.cDeclaration}{initialize};\n') + + if (struct.name == 'VkDescriptorDataEXT'): + out.append('char type_at_end[sizeof(VkDescriptorDataEXT)+sizeof(VkDescriptorGetInfoEXT::type)];') + + constructParam = self.custom_construct_params.get(struct.name, '') + out.append(f''' + {safe_name}(const {struct.name}* in_struct{constructParam}, PNextCopyState* copy_state = {{}}{copy_pnext}); + {safe_name}(const {safe_name}& copy_src); + {safe_name}& operator=(const {safe_name}& copy_src); + {safe_name}(); + ~{safe_name}(); + void initialize(const {struct.name}* in_struct{constructParam}, PNextCopyState* copy_state = {{}}); + void initialize(const {safe_name}* copy_src, PNextCopyState* copy_state = {{}}); + {struct.name} *ptr() {{ return reinterpret_cast<{struct.name} *>(this); }} + {struct.name} const *ptr() const {{ return reinterpret_cast<{struct.name} const *>(this); }} + ''') + + if struct.name == 'VkShaderModuleCreateInfo': + out.append(''' + // Primarily intended for use by GPUAV when replacing shader module code with instrumented code + template + void SetCode(const Container &code) { + delete[] pCode; + codeSize = static_cast(code.size() * sizeof(uint32_t)); + pCode = new uint32_t[code.size()]; + std::copy(&code.front(), &code.back() + 1, const_cast(pCode)); + } + ''') + out.append('};\n') + out.extend(guard_helper.add_guard(None)) + + out.append(''' + // Safe struct that spans NV and KHR VkRayTracingPipelineCreateInfo structures. + // It is a VkRayTracingPipelineCreateInfoKHR and supports construction from + // a VkRayTracingPipelineCreateInfoNV. + class safe_VkRayTracingPipelineCreateInfoCommon : public safe_VkRayTracingPipelineCreateInfoKHR { + public: + safe_VkRayTracingPipelineCreateInfoCommon() : safe_VkRayTracingPipelineCreateInfoKHR() {} + safe_VkRayTracingPipelineCreateInfoCommon(const VkRayTracingPipelineCreateInfoNV *pCreateInfo) + : safe_VkRayTracingPipelineCreateInfoKHR() { + initialize(pCreateInfo); + } + safe_VkRayTracingPipelineCreateInfoCommon(const VkRayTracingPipelineCreateInfoKHR *pCreateInfo) + : safe_VkRayTracingPipelineCreateInfoKHR(pCreateInfo) {} + + void initialize(const VkRayTracingPipelineCreateInfoNV *pCreateInfo); + void initialize(const VkRayTracingPipelineCreateInfoKHR *pCreateInfo); + uint32_t maxRecursionDepth = 0; // NV specific + }; + ''') + out.append(''' + } // namespace vku + ''') + self.write("".join(out)) + + def generateUtil(self): + out = [] + out.append(''' + #include + #include + + #include + #include + + extern std::vector> custom_stype_info; + + namespace vku { + char *SafeStringCopy(const char *in_string) { + if (nullptr == in_string) return nullptr; + size_t len = std::strlen(in_string); + char* dest = new char[len + 1]; + dest[len] = '\\0'; + std::memcpy(dest, in_string, len); + return dest; + } + + ''') + out.append(''' +// clang-format off +void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { + void *first_pNext{}; + VkBaseOutStructure *prev_pNext{}; + void *safe_pNext{}; + + while (pNext) { + const VkBaseOutStructure *header = reinterpret_cast(pNext); + + switch (header->sType) { + // Add special-case code to copy beloved secret loader structs + // Special-case Loader Instance Struct passed to/from layer in pNext chain + case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: { + VkLayerInstanceCreateInfo *struct_copy = new VkLayerInstanceCreateInfo; + // TODO: Uses original VkLayerInstanceLink* chain, which should be okay for our uses + memcpy(struct_copy, pNext, sizeof(VkLayerInstanceCreateInfo)); + safe_pNext = struct_copy; + break; + } + // Special-case Loader Device Struct passed to/from layer in pNext chain + case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: { + VkLayerDeviceCreateInfo *struct_copy = new VkLayerDeviceCreateInfo; + // TODO: Uses original VkLayerDeviceLink*, which should be okay for our uses + memcpy(struct_copy, pNext, sizeof(VkLayerDeviceCreateInfo)); + safe_pNext = struct_copy; + break; + } +''') + guard_helper = PlatformGuardHelper() + for struct in [x for x in self.vk.structs.values() if x.extends]: + safe_name = self.convertName(struct.name) + out.extend(guard_helper.add_guard(struct.protect)) + out.append(f' case {struct.sType}:\n') + out.append(f' safe_pNext = new {safe_name}(reinterpret_cast(pNext), copy_state, false);\n') + out.append(' break;\n') + out.extend(guard_helper.add_guard(None)) + + out.append(''' + default: // Encountered an unknown sType -- skip (do not copy) this entry in the chain + // If sType is in custom list, construct blind copy + for (auto item : custom_stype_info) { + if (item.first == static_cast(header->sType)) { + safe_pNext = malloc(item.second); + memcpy(safe_pNext, header, item.second); + } + } + break; + } + if (!first_pNext) { + first_pNext = safe_pNext; + } + pNext = header->pNext; + if (prev_pNext && safe_pNext) { + prev_pNext->pNext = (VkBaseOutStructure*)safe_pNext; + } + if (safe_pNext) { + prev_pNext = (VkBaseOutStructure*)safe_pNext; + } + safe_pNext = nullptr; + } + + return first_pNext; +} + +void FreePnextChain(const void *pNext) { + if (!pNext) return; + + auto header = reinterpret_cast(pNext); + + switch (header->sType) { + // Special-case Loader Instance Struct passed to/from layer in pNext chain + case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: + FreePnextChain(header->pNext); + delete reinterpret_cast(pNext); + break; + // Special-case Loader Device Struct passed to/from layer in pNext chain + case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: + FreePnextChain(header->pNext); + delete reinterpret_cast(pNext); + break; +''') + + for struct in [x for x in self.vk.structs.values() if x.extends]: + safe_name = self.convertName(struct.name) + out.extend(guard_helper.add_guard(struct.protect)) + out.append(f' case {struct.sType}:\n') + out.append(f' delete reinterpret_cast(header);\n') + out.append(' break;\n') + out.extend(guard_helper.add_guard(None)) + + out.append(''' + default: // Encountered an unknown sType + // If sType is in custom list, free custom struct memory and clean up + for (auto item : custom_stype_info) { + if (item.first == static_cast(header->sType)) { + if (header->pNext) { + FreePnextChain(header->pNext); + } + free(const_cast(pNext)); + pNext = nullptr; + break; + } + } + if (pNext) { + FreePnextChain(header->pNext); + } + break; + } +}''') + out.append('// clang-format on\n') + out.append(''' + } // namespace vku + ''') + self.write("".join(out)) + + def generateSource(self): + out = [] + out.append(''' + #include + #include + + #include + + namespace vku { + ''') + + custom_defeault_construct_txt = {} + + custom_construct_txt = { + # VkWriteDescriptorSet is special case because pointers may be non-null but ignored + 'VkWriteDescriptorSet' : ''' + switch (descriptorType) { + case VK_DESCRIPTOR_TYPE_SAMPLER: + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + case VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM: + case VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM: + if (descriptorCount && in_struct->pImageInfo) { + pImageInfo = new VkDescriptorImageInfo[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pImageInfo[i] = in_struct->pImageInfo[i]; + } + } + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + if (descriptorCount && in_struct->pBufferInfo) { + pBufferInfo = new VkDescriptorBufferInfo[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pBufferInfo[i] = in_struct->pBufferInfo[i]; + } + } + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + if (descriptorCount && in_struct->pTexelBufferView) { + pTexelBufferView = new VkBufferView[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pTexelBufferView[i] = in_struct->pTexelBufferView[i]; + } + } + break; + default: + break; + } + ''', + 'VkShaderModuleCreateInfo' : ''' + if (in_struct->pCode) { + pCode = reinterpret_cast(new uint8_t[codeSize]); + memcpy((void *)pCode, (void *)in_struct->pCode, codeSize); + } + ''', + # VkFrameBufferCreateInfo is special case because its pAttachments pointer may be non-null but ignored + 'VkFramebufferCreateInfo' : ''' + if (attachmentCount && in_struct->pAttachments && !(flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)) { + pAttachments = new VkImageView[attachmentCount]; + for (uint32_t i = 0; i < attachmentCount; ++i) { + pAttachments[i] = in_struct->pAttachments[i]; + } + } + ''', + # VkDescriptorSetLayoutBinding is special case because its pImmutableSamplers pointer may be non-null but ignored + 'VkDescriptorSetLayoutBinding' : ''' + const bool sampler_type = in_struct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || in_struct->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + if (descriptorCount && in_struct->pImmutableSamplers && sampler_type) { + pImmutableSamplers = new VkSampler[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pImmutableSamplers[i] = in_struct->pImmutableSamplers[i]; + } + } + ''', + 'VkPipelineRenderingCreateInfo': ''' + bool custom_init = copy_state && copy_state->init; + if (custom_init) { + custom_init = copy_state->init(reinterpret_cast(this), reinterpret_cast(in_struct)); + } + if (!custom_init) { + // The custom iniitalization was not used, so do the regular initialization + if (in_struct->pColorAttachmentFormats) { + pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount]; + 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 = { + 'VkFramebufferCreateInfo' : ''' + pNext = SafePnextCopy(copy_src.pNext); + if (attachmentCount && copy_src.pAttachments && !(flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)) { + pAttachments = new VkImageView[attachmentCount]; + for (uint32_t i = 0; i < attachmentCount; ++i) { + pAttachments[i] = copy_src.pAttachments[i]; + } + } + ''', + 'VkPipelineRenderingCreateInfo': ''' + if (copy_src.pColorAttachmentFormats) { + pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount]; + memcpy ((void *)pColorAttachmentFormats, (void *)copy_src.pColorAttachmentFormats, sizeof(VkFormat)*copy_src.colorAttachmentCount); + } + ''' + } + + custom_destruct_txt = { + 'VkShaderModuleCreateInfo' : ''' + if (pCode) + delete[] reinterpret_cast(pCode); + ''', + } + + member_init_transforms = { + 'queueFamilyIndexCount': lambda m: f'{m.name}(0)' + } + + def qfi_construct(item, member): + true_index_setter = lambda i: f'{i}queueFamilyIndexCount = in_struct->queueFamilyIndexCount;\n' + false_index_setter = lambda i: f'{i}queueFamilyIndexCount = 0;\n' + if item.name == 'VkSwapchainCreateInfoKHR': + return (f'(in_struct->imageSharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->{member.name}', true_index_setter, false_index_setter) + else: + return (f'(in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->{member.name}', true_index_setter, false_index_setter) + + # map of: + # : function(item, member) -> (condition, true statement, false statement) + member_construct_conditions = { + 'pQueueFamilyIndices': qfi_construct + } + + # Find what types of safe structs need to be generated based on output file name + splitRegex = r'.*'; + if self.filename.endswith('_khr.cpp'): + splitRegex = r'.*KHR$' + elif self.filename.endswith('_ext.cpp'): + splitRegex = r'.*EXT$' + elif self.filename.endswith('_vendor.cpp'): + splitRegex = r'^(?!.*(KHR|EXT)$).*[A-Z]$' # Matches all words finishing with an upper case letter, but not ending with KHRor EXT + else: # elif self.filename.endswith('_core.cpp'): + splitRegex = r'.*[a-z0-9]$' + + guard_helper = PlatformGuardHelper() + + for struct in [x for x in self.vk.structs.values() if self.needSafeStruct(x) and x.name not in self.manual_source and re.match(splitRegex, x.name)]: + out.extend(guard_helper.add_guard(struct.protect)) + + init_list = '' # list of members in struct constructor initializer + default_init_list = '' # Default constructor just inits ptrs to nullptr in initializer + init_func_txt = '' # Txt for initialize() function that takes struct ptr and inits members + construct_txt = '' # Body of constuctor as well as body of initialize() func following init_func_txt + destruct_txt = '' + + has_pnext = struct.sType is not None + copy_pnext = '' + copy_pnext_if = '' + copy_strings = '' + for member in struct.members: + m_type = member.type + m_type_safe = False + if member.name == 'pNext': + copy_pnext = 'pNext = SafePnextCopy(in_struct->pNext, copy_state);\n' + copy_pnext_if = ''' + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + }''' + if member.type in self.vk.structs and self.needSafeStruct(self.vk.structs[member.type]): + m_type = self.convertName(member.type) + m_type_safe = True; + + if member.pointer and not m_type_safe and 'PFN_' not in member.type and not self.typeContainsObjectHandle(member.type, False): + # Ptr types w/o a safe_struct, for non-null case need to allocate new ptr and copy data in + if m_type in ['void', 'char']: + if member.name != 'pNext': + if m_type == 'char': + # Create deep copies of strings + if member.length: + copy_strings += f''' + char **tmp_{member.name} = new char *[in_struct->{member.length}]; + for (uint32_t i = 0; i < {member.length}; ++i) {{ + tmp_{member.name}[i] = SafeStringCopy(in_struct->{member.name}[i]); + }} + {member.name} = tmp_{member.name};''' + + destruct_txt += f''' + if ({member.name}) {{ + for (uint32_t i = 0; i < {member.length}; ++i) {{ + delete [] {member.name}[i]; + }} + delete [] {member.name}; + }}''' + else: + copy_strings += f'{member.name} = SafeStringCopy(in_struct->{member.name});\n' + destruct_txt += f'if ({member.name}) delete [] {member.name};\n' + else: + # We need a deep copy of pData / dataSize combos + if member.name == 'pData': + init_list += f'\n {member.name}(nullptr),' + construct_txt += ''' + if (in_struct->pData != nullptr) { + auto temp = new std::byte[in_struct->dataSize]; + std::memcpy(temp, in_struct->pData, in_struct->dataSize); + pData = temp; + } + ''' + + destruct_txt += ''' + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete [] temp; + } + ''' + else: + init_list += f'\n{member.name}(in_struct->{member.name}),' + init_func_txt += f'{member.name} = in_struct->{member.name};\n' + default_init_list += f'\n{member.name}(nullptr),' + else: + default_init_list += f'\n{member.name}(nullptr),' + init_list += f'\n{member.name}(nullptr),' + if m_type in self.abstract_types: + construct_txt += f'{member.name} = in_struct->{member.name};\n' + else: + init_func_txt += f'{member.name} = nullptr;\n' + if not member.fixedSizeArray and (member.length is None or '/' in member.length): + construct_txt += f''' + if (in_struct->{member.name}) {{ + {member.name} = new {m_type}(*in_struct->{member.name}); + }} + ''' + destruct_txt += f'if ({member.name})\n' + destruct_txt += f' delete {member.name};\n' + else: + # Prepend struct members with struct name + decorated_length = member.length + for other_member in struct.members: + decorated_length = re.sub(r'\b({})\b'.format(other_member.name), r'in_struct->\1', decorated_length) + try: + concurrent_clause = member_construct_conditions[member.name](struct, member) + except: + concurrent_clause = (f'in_struct->{member.name}', lambda x: '') + construct_txt += f''' + if ({concurrent_clause[0]}) {{ + {member.name} = new {m_type}[{decorated_length}]; + memcpy ((void *){member.name}, (void *)in_struct->{member.name}, sizeof({m_type})*{decorated_length}); + {concurrent_clause[1](' ')}''' + if len(concurrent_clause) > 2: + construct_txt += '} else {\n' + construct_txt += concurrent_clause[2](' ') + construct_txt += '}\n' + destruct_txt += f'if ({member.name})\n' + destruct_txt += f' delete[] {member.name};\n' + elif member.fixedSizeArray or member.length is not None: + if member.fixedSizeArray: + construct_txt += f''' + for (uint32_t i = 0; i < {member.fixedSizeArray[0]}; ++i) {{ + {member.name}[i] = in_struct->{member.name}[i]; + }} + ''' + else: + # Init array ptr to NULL + default_init_list += f'\n{member.name}(nullptr),' + init_list += f'\n{member.name}(nullptr),' + init_func_txt += f'{member.name} = nullptr;\n' + array_element = f'in_struct->{member.name}[i]' + if member.type in self.vk.structs and self.needSafeStruct(self.vk.structs[member.type]): + array_element = f'{member.type}(&in_struct->safe_{member.name}[i])' + construct_txt += f'if ({member.length} && in_struct->{member.name}) {{\n' + construct_txt += f' {member.name} = new {m_type}[{member.length}];\n' + destruct_txt += f'if ({member.name})\n' + destruct_txt += f' delete[] {member.name};\n' + construct_txt += f'for (uint32_t i = 0; i < {member.length}; ++i) {{\n' + if m_type_safe: + construct_txt += f'{member.name}[i].initialize(&in_struct->{member.name}[i]);\n' + else: + construct_txt += f'{member.name}[i] = {array_element};\n' + construct_txt += '}\n' + construct_txt += '}\n' + elif member.pointer and 'PFN_' not in member.type: + default_init_list += f'\n{member.name}(nullptr),' + init_list += f'\n{member.name}(nullptr),' + init_func_txt += f'{member.name} = nullptr;\n' + construct_txt += f'if (in_struct->{member.name})\n' + construct_txt += f' {member.name} = new {m_type}(in_struct->{member.name});\n' + destruct_txt += f'if ({member.name})\n' + destruct_txt += f' delete {member.name};\n' + elif m_type_safe and member.type in self.union_of_pointers: + init_list += f'\n{member.name}(&in_struct->{member.name}, in_struct->type),' + init_func_txt += f'{member.name}.initialize(&in_struct->{member.name}, in_struct->type);\n' + elif m_type_safe: + init_list += f'\n{member.name}(&in_struct->{member.name}),' + init_func_txt += f'{member.name}.initialize(&in_struct->{member.name});\n' + else: + try: + init_list += f'\n{member_init_transforms[member.name](member)},' + except: + init_list += f'\n{member.name}(in_struct->{member.name}),' + init_func_txt += f'{member.name} = in_struct->{member.name};\n' + if not struct.union: + if member.name == 'sType' and struct.sType: + default_init_list += f'\n{member.name}({struct.sType}),' + else: + default_init_list += f'\n{member.name}(),' + if '' != init_list: + init_list = init_list[:-1] # hack off final comma + + if struct.name in custom_construct_txt: + construct_txt = custom_construct_txt[struct.name] + + construct_txt = copy_strings + construct_txt + + if struct.name in custom_destruct_txt: + destruct_txt = custom_destruct_txt[struct.name] + + copy_pnext_param = '' + if has_pnext: + copy_pnext_param = ', bool copy_pnext' + destruct_txt += ' FreePnextChain(pNext);\n' + + safe_name = self.convertName(struct.name) + if struct.union: + if struct.name in self.union_of_pointers: + default_init_list = ' type_at_end {0},' + out.append(f''' + {safe_name}::{safe_name}(const {struct.name}* in_struct{self.custom_construct_params.get(struct.name, '')}, [[maybe_unused]] PNextCopyState* copy_state{copy_pnext_param}) + {{ + {copy_pnext + construct_txt}}} + ''') + else: + # Unions don't allow multiple members in the initialization list, so just call initialize + out.append(f''' + {safe_name}::{safe_name}(const {struct.name}* in_struct{self.custom_construct_params.get(struct.name, '')}, PNextCopyState*) + {{ + initialize(in_struct); + }} + ''') + else: + out.append(f''' + {safe_name}::{safe_name}(const {struct.name}* in_struct{self.custom_construct_params.get(struct.name, '')}, [[maybe_unused]] PNextCopyState* copy_state{copy_pnext_param}) :{init_list} + {{ + {copy_pnext_if + construct_txt}}} + ''') + if '' != default_init_list: + default_init_list = f' :{default_init_list[:-1]}' + default_init_body = '\n' + custom_defeault_construct_txt[struct.name] if struct.name in custom_defeault_construct_txt else '' + out.append(f''' + {safe_name}::{safe_name}(){default_init_list} + {{{default_init_body}}} + ''') + # Create slight variation of init and construct txt for copy constructor that takes a copy_src object reference vs. struct ptr + construct_txt = copy_pnext + construct_txt + copy_construct_init = init_func_txt.replace('in_struct->', 'copy_src.') + copy_construct_init = copy_construct_init.replace(', copy_state', '') + if struct.name in self.union_of_pointer_callers: + copy_construct_init = copy_construct_init.replace(', copy_src.type', '') + # Pass object to copy constructors + copy_construct_txt = re.sub('(new \\w+)\\(in_struct->', '\\1(*copy_src.', construct_txt) + # Modify remaining struct refs for copy_src object + copy_construct_txt = copy_construct_txt.replace('in_struct->', 'copy_src.') + # Modify remaining struct refs for copy_src object + copy_construct_txt = copy_construct_txt .replace(', copy_state', '') + if struct.name in custom_copy_txt: + copy_construct_txt = custom_copy_txt[struct.name] + copy_assign_txt = ' if (©_src == this) return *this;\n\n' + destruct_txt + '\n' + copy_construct_init + copy_construct_txt + '\n return *this;' + # Copy constructor + out.append(f''' + {safe_name}::{safe_name}(const {safe_name}& copy_src) + {{ + {copy_construct_init}{copy_construct_txt}}} + ''') + # Copy assignment operator + out.append(f''' + {safe_name}& {safe_name}::operator=(const {safe_name}& copy_src)\n{{ + {copy_assign_txt} + }} + ''') + out.append(f''' + {safe_name}::~{safe_name}() + {{ + {destruct_txt}}} + ''') + out.append(f''' + void {safe_name}::initialize(const {struct.name}* in_struct{self.custom_construct_params.get(struct.name, '')}, [[maybe_unused]] PNextCopyState* copy_state) + {{ + {destruct_txt}{init_func_txt}{construct_txt}}} + ''') + # Copy initializer uses same txt as copy constructor but has a ptr and not a reference + init_copy = copy_construct_init.replace('copy_src.', 'copy_src->') + # Replace '©_src' with 'copy_src' unless it's followed by a dereference + init_copy = re.sub(r'©_src(?!->)', 'copy_src', init_copy) + init_construct = copy_construct_txt.replace('copy_src.', 'copy_src->') + # Replace '©_src' with 'copy_src' unless it's followed by a dereference + init_construct = re.sub(r'©_src(?!->)', 'copy_src', init_construct) + out.append(f''' + void {safe_name}::initialize(const {safe_name}* copy_src, [[maybe_unused]] PNextCopyState* copy_state) + {{ + {init_copy}{init_construct}}} + ''') + out.extend(guard_helper.add_guard(None)) + out.append(''' + } // namespace vku + ''') + + self.write("".join(out)) diff --git a/scripts/generators/struct_helper_generator.py b/scripts/generators/struct_helper_generator.py index 44bc563..b84a1ca 100644 --- a/scripts/generators/struct_helper_generator.py +++ b/scripts/generators/struct_helper_generator.py @@ -53,9 +53,9 @@ def generate(self): guard_helper = PlatformGuardHelper() for struct in [x for x in self.vk.structs.values() if x.sType]: - out.extend(guard_helper.addGuard(struct.protect)) + out.extend(guard_helper.add_guard(struct.protect)) out.append(f'template <> inline VkStructureType GetSType<{struct.name}>() {{ return {struct.sType}; }}\n') - out.extend(guard_helper.addGuard(None)) + out.extend(guard_helper.add_guard(None)) out.append(''' // Find an entry of the given type in the const pNext chain // returns nullptr if the entry is not found @@ -132,9 +132,9 @@ class InitStructHelper { #if VK_USE_64_BIT_PTR_DEFINES == 1 ''') for handle in self.vk.handles.values(): - out.extend(guard_helper.addGuard(handle.protect)) + out.extend(guard_helper.add_guard(handle.protect)) out.append(f'template<> inline VkObjectType GetObjectType<{handle.name}>() {{ return {handle.type}; }}\n') - out.extend(guard_helper.addGuard(None)) + out.extend(guard_helper.add_guard(None)) out.append(''' #endif // VK_USE_64_BIT_PTR_DEFINES == 1 } // namespace vku diff --git a/scripts/generators/vulkan_object.py b/scripts/generators/vulkan_object.py index b5741e6..642e817 100644 --- a/scripts/generators/vulkan_object.py +++ b/scripts/generators/vulkan_object.py @@ -1,8 +1,7 @@ #!/usr/bin/python3 -i # -# Copyright 2023 The Khronos Group Inc. -# Copyright 2023 Valve Corporation -# Copyright 2023 LunarG, Inc. +# Copyright (c) 2023-2024 Valve Corporation +# Copyright (c) 2023-2024 LunarG, Inc. # # SPDX-License-Identifier: Apache-2.0 @@ -33,7 +32,7 @@ class Extension: # Quotes allow us to forward declare the dataclass commands: list['Command'] = field(default_factory=list, init=False) enums: list['Enum'] = field(default_factory=list, init=False) - bitmask: list['Bitmask'] = field(default_factory=list, init=False) + bitmasks: list['Bitmask'] = field(default_factory=list, init=False) # Use the Enum name to see what fields are extended enumFields: dict[str, list['EnumField']] = field(default_factory=dict, init=False) # Use the Bitmaks name to see what flags are extended @@ -65,6 +64,9 @@ class Handle: dispatchable: bool + def __lt__(self, other): + return self.name < other.name + @dataclass class Param: """""" @@ -92,6 +94,9 @@ class Param: # - VkStructureType sType cDeclaration: str + def __lt__(self, other): + return self.name < other.name + class Queues(IntFlag): TRANSFER = auto() # VK_QUEUE_TRANSFER_BIT GRAPHICS = auto() # VK_QUEUE_GRAPHICS_BIT @@ -153,6 +158,9 @@ class Command: # (const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); cFunctionPointer: str + def __lt__(self, other): + return self.name < other.name + @dataclass class Member: """""" @@ -179,6 +187,9 @@ class Member: # - VkStructureType sType cDeclaration: str + def __lt__(self, other): + return self.name < other.name + @dataclass class Struct: """ or """ @@ -200,6 +211,9 @@ class Struct: extends: list[str] # Struct names that this struct extends extendedBy: list[str] # Struct names that can be extended by this struct + def __lt__(self, other): + return self.name < other.name + @dataclass class EnumField: """ of type enum""" @@ -210,6 +224,9 @@ class EnumField: # some fields are enabled from 2 extensions (ex) VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR) extensions: list[Extension] # None if part of 1.0 core + def __lt__(self, other): + return self.name < other.name + @dataclass class Enum: """ of type enum""" @@ -225,6 +242,9 @@ class Enum: # Unique list of all extension that are involved in 'fields' (superset of 'extensions') fieldExtensions: list[Extension] + def __lt__(self, other): + return self.name < other.name + @dataclass class Flag: """ of type bitmask""" @@ -236,7 +256,10 @@ class Flag: zero: bool # if true, the value is zero (ex) VK_PIPELINE_STAGE_NONE) # some fields are enabled from 2 extensions (ex) VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT) - extensions: list[str] # None if part of 1.0 core + extensions: list[Extension] # None if part of 1.0 core + + def __lt__(self, other): + return self.name < other.name @dataclass class Bitmask: @@ -246,12 +269,17 @@ class Bitmask: protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS bitWidth: int # 32 or 64 + returnedOnly: bool + flags: list[Flag] extensions: list[Extension] # None if part of 1.0 core # Unique list of all extension that are involved in 'flag' (superset of 'extensions') flagExtensions: list[Extension] + def __lt__(self, other): + return self.name < other.name + @dataclass class FormatComponent: """""" diff --git a/scripts/gn/stub.cpp b/scripts/gn/stub.cpp index b5e148c..a9c729d 100644 --- a/scripts/gn/stub.cpp +++ b/scripts/gn/stub.cpp @@ -1,6 +1,6 @@ -// Copyright 2023 The Khronos Group Inc. -// Copyright 2023 Valve Corporation -// Copyright 2023 LunarG, Inc. +// Copyright 2023-2024 The Khronos Group Inc. +// Copyright 2023-2024 Valve Corporation +// Copyright 2023-2024 LunarG, Inc. // // SPDX-License-Identifier: Apache-2.0 @@ -9,6 +9,9 @@ #include #include #include +#include #include #include +#include +#include #include diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index eb36009..744b4e4 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -28,6 +28,7 @@ elseif(MSVC) target_compile_options(VulkanCompilerConfiguration INTERFACE /W4 /we5038 # Enable warning about MIL ordering in constructors + /wd4324 # Disable warning about alignment padding ) # Enforce stricter ISO C++ @@ -90,4 +91,7 @@ if (VUL_WERROR) endif() endif() +option(VUL_MOCK_ANDROID "Enable building for Android on desktop for testing with MockICD setup") + add_subdirectory(layer) +add_subdirectory(vulkan) diff --git a/src/vulkan/CMakeLists.txt b/src/vulkan/CMakeLists.txt new file mode 100644 index 0000000..04e7f0a --- /dev/null +++ b/src/vulkan/CMakeLists.txt @@ -0,0 +1,30 @@ +# Copyright 2023 The Khronos Group Inc. +# Copyright 2023 Valve Corporation +# Copyright 2023 LunarG, Inc. +# +# SPDX-License-Identifier: Apache-2.0 +set(CMAKE_FOLDER "${CMAKE_FOLDER}/VulkanSafeStruct") + +add_library(VulkanSafeStruct STATIC) +add_library(Vulkan::SafeStruct ALIAS VulkanSafeStruct) + +target_sources(VulkanSafeStruct PRIVATE + vk_safe_struct_core.cpp + vk_safe_struct_ext.cpp + vk_safe_struct_khr.cpp + vk_safe_struct_utils.cpp + vk_safe_struct_vendor.cpp + vk_safe_struct_manual.cpp +) + +target_link_Libraries(VulkanSafeStruct + PUBLIC + Vulkan::Headers + Vulkan::UtilityHeaders + PRIVATE + Vulkan::CompilerConfiguration +) + +if(VUL_MOCK_ANDROID) + target_compile_definitions(VulkanSafeStruct PUBLIC VK_USE_PLATFORM_ANDROID_KHR VUL_MOCK_ANDROID) +endif() diff --git a/src/vulkan/vk_safe_struct_core.cpp b/src/vulkan/vk_safe_struct_core.cpp new file mode 100644 index 0000000..21e9108 --- /dev/null +++ b/src/vulkan/vk_safe_struct_core.cpp @@ -0,0 +1,18773 @@ +// *** THIS FILE IS GENERATED - DO NOT EDIT *** +// See safe_struct_generator.py for modifications + +/*************************************************************************** + * + * Copyright (c) 2015-2024 The Khronos Group Inc. + * Copyright (c) 2015-2024 Valve Corporation + * Copyright (c) 2015-2024 LunarG, Inc. + * Copyright (c) 2015-2024 Google Inc. + * + * SPDX-License-Identifier: Apache-2.0 + * + ****************************************************************************/ + +// NOLINTBEGIN + +#include +#include + +#include + +namespace vku { + +safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier(const VkBufferMemoryBarrier* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + srcAccessMask(in_struct->srcAccessMask), + dstAccessMask(in_struct->dstAccessMask), + srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex), + dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex), + buffer(in_struct->buffer), + offset(in_struct->offset), + size(in_struct->size) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier() + : sType(VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER), + pNext(nullptr), + srcAccessMask(), + dstAccessMask(), + srcQueueFamilyIndex(), + dstQueueFamilyIndex(), + buffer(), + offset(), + size() {} + +safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier(const safe_VkBufferMemoryBarrier& copy_src) { + sType = copy_src.sType; + srcAccessMask = copy_src.srcAccessMask; + dstAccessMask = copy_src.dstAccessMask; + srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex; + dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex; + buffer = copy_src.buffer; + offset = copy_src.offset; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBufferMemoryBarrier& safe_VkBufferMemoryBarrier::operator=(const safe_VkBufferMemoryBarrier& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + srcAccessMask = copy_src.srcAccessMask; + dstAccessMask = copy_src.dstAccessMask; + srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex; + dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex; + buffer = copy_src.buffer; + offset = copy_src.offset; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBufferMemoryBarrier::~safe_VkBufferMemoryBarrier() { FreePnextChain(pNext); } + +void safe_VkBufferMemoryBarrier::initialize(const VkBufferMemoryBarrier* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + srcAccessMask = in_struct->srcAccessMask; + dstAccessMask = in_struct->dstAccessMask; + srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex; + dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex; + buffer = in_struct->buffer; + offset = in_struct->offset; + size = in_struct->size; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBufferMemoryBarrier::initialize(const safe_VkBufferMemoryBarrier* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcAccessMask = copy_src->srcAccessMask; + dstAccessMask = copy_src->dstAccessMask; + srcQueueFamilyIndex = copy_src->srcQueueFamilyIndex; + dstQueueFamilyIndex = copy_src->dstQueueFamilyIndex; + buffer = copy_src->buffer; + offset = copy_src->offset; + size = copy_src->size; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier(const VkImageMemoryBarrier* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + srcAccessMask(in_struct->srcAccessMask), + dstAccessMask(in_struct->dstAccessMask), + oldLayout(in_struct->oldLayout), + newLayout(in_struct->newLayout), + srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex), + dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex), + image(in_struct->image), + subresourceRange(in_struct->subresourceRange) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier() + : sType(VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER), + pNext(nullptr), + srcAccessMask(), + dstAccessMask(), + oldLayout(), + newLayout(), + srcQueueFamilyIndex(), + dstQueueFamilyIndex(), + image(), + subresourceRange() {} + +safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier(const safe_VkImageMemoryBarrier& copy_src) { + sType = copy_src.sType; + srcAccessMask = copy_src.srcAccessMask; + dstAccessMask = copy_src.dstAccessMask; + oldLayout = copy_src.oldLayout; + newLayout = copy_src.newLayout; + srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex; + dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex; + image = copy_src.image; + subresourceRange = copy_src.subresourceRange; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageMemoryBarrier& safe_VkImageMemoryBarrier::operator=(const safe_VkImageMemoryBarrier& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + srcAccessMask = copy_src.srcAccessMask; + dstAccessMask = copy_src.dstAccessMask; + oldLayout = copy_src.oldLayout; + newLayout = copy_src.newLayout; + srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex; + dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex; + image = copy_src.image; + subresourceRange = copy_src.subresourceRange; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageMemoryBarrier::~safe_VkImageMemoryBarrier() { FreePnextChain(pNext); } + +void safe_VkImageMemoryBarrier::initialize(const VkImageMemoryBarrier* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + srcAccessMask = in_struct->srcAccessMask; + dstAccessMask = in_struct->dstAccessMask; + oldLayout = in_struct->oldLayout; + newLayout = in_struct->newLayout; + srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex; + dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex; + image = in_struct->image; + subresourceRange = in_struct->subresourceRange; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageMemoryBarrier::initialize(const safe_VkImageMemoryBarrier* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcAccessMask = copy_src->srcAccessMask; + dstAccessMask = copy_src->dstAccessMask; + oldLayout = copy_src->oldLayout; + newLayout = copy_src->newLayout; + srcQueueFamilyIndex = copy_src->srcQueueFamilyIndex; + dstQueueFamilyIndex = copy_src->dstQueueFamilyIndex; + image = copy_src->image; + subresourceRange = copy_src->subresourceRange; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMemoryBarrier::safe_VkMemoryBarrier(const VkMemoryBarrier* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), srcAccessMask(in_struct->srcAccessMask), dstAccessMask(in_struct->dstAccessMask) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMemoryBarrier::safe_VkMemoryBarrier() + : sType(VK_STRUCTURE_TYPE_MEMORY_BARRIER), pNext(nullptr), srcAccessMask(), dstAccessMask() {} + +safe_VkMemoryBarrier::safe_VkMemoryBarrier(const safe_VkMemoryBarrier& copy_src) { + sType = copy_src.sType; + srcAccessMask = copy_src.srcAccessMask; + dstAccessMask = copy_src.dstAccessMask; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryBarrier& safe_VkMemoryBarrier::operator=(const safe_VkMemoryBarrier& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + srcAccessMask = copy_src.srcAccessMask; + dstAccessMask = copy_src.dstAccessMask; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryBarrier::~safe_VkMemoryBarrier() { FreePnextChain(pNext); } + +void safe_VkMemoryBarrier::initialize(const VkMemoryBarrier* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + srcAccessMask = in_struct->srcAccessMask; + dstAccessMask = in_struct->dstAccessMask; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryBarrier::initialize(const safe_VkMemoryBarrier* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcAccessMask = copy_src->srcAccessMask; + dstAccessMask = copy_src->dstAccessMask; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAllocationCallbacks::safe_VkAllocationCallbacks(const VkAllocationCallbacks* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) + : pUserData(in_struct->pUserData), + pfnAllocation(in_struct->pfnAllocation), + pfnReallocation(in_struct->pfnReallocation), + pfnFree(in_struct->pfnFree), + pfnInternalAllocation(in_struct->pfnInternalAllocation), + pfnInternalFree(in_struct->pfnInternalFree) {} + +safe_VkAllocationCallbacks::safe_VkAllocationCallbacks() + : pUserData(nullptr), pfnAllocation(), pfnReallocation(), pfnFree(), pfnInternalAllocation(), pfnInternalFree() {} + +safe_VkAllocationCallbacks::safe_VkAllocationCallbacks(const safe_VkAllocationCallbacks& copy_src) { + pUserData = copy_src.pUserData; + pfnAllocation = copy_src.pfnAllocation; + pfnReallocation = copy_src.pfnReallocation; + pfnFree = copy_src.pfnFree; + pfnInternalAllocation = copy_src.pfnInternalAllocation; + pfnInternalFree = copy_src.pfnInternalFree; +} + +safe_VkAllocationCallbacks& safe_VkAllocationCallbacks::operator=(const safe_VkAllocationCallbacks& copy_src) { + if (©_src == this) return *this; + + pUserData = copy_src.pUserData; + pfnAllocation = copy_src.pfnAllocation; + pfnReallocation = copy_src.pfnReallocation; + pfnFree = copy_src.pfnFree; + pfnInternalAllocation = copy_src.pfnInternalAllocation; + pfnInternalFree = copy_src.pfnInternalFree; + + return *this; +} + +safe_VkAllocationCallbacks::~safe_VkAllocationCallbacks() {} + +void safe_VkAllocationCallbacks::initialize(const VkAllocationCallbacks* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + pUserData = in_struct->pUserData; + pfnAllocation = in_struct->pfnAllocation; + pfnReallocation = in_struct->pfnReallocation; + pfnFree = in_struct->pfnFree; + pfnInternalAllocation = in_struct->pfnInternalAllocation; + pfnInternalFree = in_struct->pfnInternalFree; +} + +void safe_VkAllocationCallbacks::initialize(const safe_VkAllocationCallbacks* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + pUserData = copy_src->pUserData; + pfnAllocation = copy_src->pfnAllocation; + pfnReallocation = copy_src->pfnReallocation; + pfnFree = copy_src->pfnFree; + pfnInternalAllocation = copy_src->pfnInternalAllocation; + pfnInternalFree = copy_src->pfnInternalFree; +} + +safe_VkApplicationInfo::safe_VkApplicationInfo(const VkApplicationInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + applicationVersion(in_struct->applicationVersion), + engineVersion(in_struct->engineVersion), + apiVersion(in_struct->apiVersion) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + pApplicationName = SafeStringCopy(in_struct->pApplicationName); + pEngineName = SafeStringCopy(in_struct->pEngineName); +} + +safe_VkApplicationInfo::safe_VkApplicationInfo() + : sType(VK_STRUCTURE_TYPE_APPLICATION_INFO), + pNext(nullptr), + pApplicationName(nullptr), + applicationVersion(), + pEngineName(nullptr), + engineVersion(), + apiVersion() {} + +safe_VkApplicationInfo::safe_VkApplicationInfo(const safe_VkApplicationInfo& copy_src) { + sType = copy_src.sType; + applicationVersion = copy_src.applicationVersion; + engineVersion = copy_src.engineVersion; + apiVersion = copy_src.apiVersion; + pNext = SafePnextCopy(copy_src.pNext); + pApplicationName = SafeStringCopy(copy_src.pApplicationName); + pEngineName = SafeStringCopy(copy_src.pEngineName); +} + +safe_VkApplicationInfo& safe_VkApplicationInfo::operator=(const safe_VkApplicationInfo& copy_src) { + if (©_src == this) return *this; + + if (pApplicationName) delete[] pApplicationName; + if (pEngineName) delete[] pEngineName; + FreePnextChain(pNext); + + sType = copy_src.sType; + applicationVersion = copy_src.applicationVersion; + engineVersion = copy_src.engineVersion; + apiVersion = copy_src.apiVersion; + pNext = SafePnextCopy(copy_src.pNext); + pApplicationName = SafeStringCopy(copy_src.pApplicationName); + pEngineName = SafeStringCopy(copy_src.pEngineName); + + return *this; +} + +safe_VkApplicationInfo::~safe_VkApplicationInfo() { + if (pApplicationName) delete[] pApplicationName; + if (pEngineName) delete[] pEngineName; + FreePnextChain(pNext); +} + +void safe_VkApplicationInfo::initialize(const VkApplicationInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pApplicationName) delete[] pApplicationName; + if (pEngineName) delete[] pEngineName; + FreePnextChain(pNext); + sType = in_struct->sType; + applicationVersion = in_struct->applicationVersion; + engineVersion = in_struct->engineVersion; + apiVersion = in_struct->apiVersion; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + pApplicationName = SafeStringCopy(in_struct->pApplicationName); + pEngineName = SafeStringCopy(in_struct->pEngineName); +} + +void safe_VkApplicationInfo::initialize(const safe_VkApplicationInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + applicationVersion = copy_src->applicationVersion; + engineVersion = copy_src->engineVersion; + apiVersion = copy_src->apiVersion; + pNext = SafePnextCopy(copy_src->pNext); + pApplicationName = SafeStringCopy(copy_src->pApplicationName); + pEngineName = SafeStringCopy(copy_src->pEngineName); +} + +safe_VkInstanceCreateInfo::safe_VkInstanceCreateInfo(const VkInstanceCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + pApplicationInfo(nullptr), + enabledLayerCount(in_struct->enabledLayerCount), + enabledExtensionCount(in_struct->enabledExtensionCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + char** tmp_ppEnabledLayerNames = new char*[in_struct->enabledLayerCount]; + for (uint32_t i = 0; i < enabledLayerCount; ++i) { + tmp_ppEnabledLayerNames[i] = SafeStringCopy(in_struct->ppEnabledLayerNames[i]); + } + ppEnabledLayerNames = tmp_ppEnabledLayerNames; + char** tmp_ppEnabledExtensionNames = new char*[in_struct->enabledExtensionCount]; + for (uint32_t i = 0; i < enabledExtensionCount; ++i) { + tmp_ppEnabledExtensionNames[i] = SafeStringCopy(in_struct->ppEnabledExtensionNames[i]); + } + ppEnabledExtensionNames = tmp_ppEnabledExtensionNames; + if (in_struct->pApplicationInfo) pApplicationInfo = new safe_VkApplicationInfo(in_struct->pApplicationInfo); +} + +safe_VkInstanceCreateInfo::safe_VkInstanceCreateInfo() + : sType(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO), + pNext(nullptr), + flags(), + pApplicationInfo(nullptr), + enabledLayerCount(), + ppEnabledLayerNames(nullptr), + enabledExtensionCount(), + ppEnabledExtensionNames(nullptr) {} + +safe_VkInstanceCreateInfo::safe_VkInstanceCreateInfo(const safe_VkInstanceCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pApplicationInfo = nullptr; + enabledLayerCount = copy_src.enabledLayerCount; + enabledExtensionCount = copy_src.enabledExtensionCount; + pNext = SafePnextCopy(copy_src.pNext); + + char** tmp_ppEnabledLayerNames = new char*[copy_src.enabledLayerCount]; + for (uint32_t i = 0; i < enabledLayerCount; ++i) { + tmp_ppEnabledLayerNames[i] = SafeStringCopy(copy_src.ppEnabledLayerNames[i]); + } + ppEnabledLayerNames = tmp_ppEnabledLayerNames; + char** tmp_ppEnabledExtensionNames = new char*[copy_src.enabledExtensionCount]; + for (uint32_t i = 0; i < enabledExtensionCount; ++i) { + tmp_ppEnabledExtensionNames[i] = SafeStringCopy(copy_src.ppEnabledExtensionNames[i]); + } + ppEnabledExtensionNames = tmp_ppEnabledExtensionNames; + if (copy_src.pApplicationInfo) pApplicationInfo = new safe_VkApplicationInfo(*copy_src.pApplicationInfo); +} + +safe_VkInstanceCreateInfo& safe_VkInstanceCreateInfo::operator=(const safe_VkInstanceCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pApplicationInfo) delete pApplicationInfo; + + if (ppEnabledLayerNames) { + for (uint32_t i = 0; i < enabledLayerCount; ++i) { + delete[] ppEnabledLayerNames[i]; + } + delete[] ppEnabledLayerNames; + } + if (ppEnabledExtensionNames) { + for (uint32_t i = 0; i < enabledExtensionCount; ++i) { + delete[] ppEnabledExtensionNames[i]; + } + delete[] ppEnabledExtensionNames; + } + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pApplicationInfo = nullptr; + enabledLayerCount = copy_src.enabledLayerCount; + enabledExtensionCount = copy_src.enabledExtensionCount; + pNext = SafePnextCopy(copy_src.pNext); + + char** tmp_ppEnabledLayerNames = new char*[copy_src.enabledLayerCount]; + for (uint32_t i = 0; i < enabledLayerCount; ++i) { + tmp_ppEnabledLayerNames[i] = SafeStringCopy(copy_src.ppEnabledLayerNames[i]); + } + ppEnabledLayerNames = tmp_ppEnabledLayerNames; + char** tmp_ppEnabledExtensionNames = new char*[copy_src.enabledExtensionCount]; + for (uint32_t i = 0; i < enabledExtensionCount; ++i) { + tmp_ppEnabledExtensionNames[i] = SafeStringCopy(copy_src.ppEnabledExtensionNames[i]); + } + ppEnabledExtensionNames = tmp_ppEnabledExtensionNames; + if (copy_src.pApplicationInfo) pApplicationInfo = new safe_VkApplicationInfo(*copy_src.pApplicationInfo); + + return *this; +} + +safe_VkInstanceCreateInfo::~safe_VkInstanceCreateInfo() { + if (pApplicationInfo) delete pApplicationInfo; + + if (ppEnabledLayerNames) { + for (uint32_t i = 0; i < enabledLayerCount; ++i) { + delete[] ppEnabledLayerNames[i]; + } + delete[] ppEnabledLayerNames; + } + if (ppEnabledExtensionNames) { + for (uint32_t i = 0; i < enabledExtensionCount; ++i) { + delete[] ppEnabledExtensionNames[i]; + } + delete[] ppEnabledExtensionNames; + } + FreePnextChain(pNext); +} + +void safe_VkInstanceCreateInfo::initialize(const VkInstanceCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pApplicationInfo) delete pApplicationInfo; + + if (ppEnabledLayerNames) { + for (uint32_t i = 0; i < enabledLayerCount; ++i) { + delete[] ppEnabledLayerNames[i]; + } + delete[] ppEnabledLayerNames; + } + if (ppEnabledExtensionNames) { + for (uint32_t i = 0; i < enabledExtensionCount; ++i) { + delete[] ppEnabledExtensionNames[i]; + } + delete[] ppEnabledExtensionNames; + } + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pApplicationInfo = nullptr; + enabledLayerCount = in_struct->enabledLayerCount; + enabledExtensionCount = in_struct->enabledExtensionCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + char** tmp_ppEnabledLayerNames = new char*[in_struct->enabledLayerCount]; + for (uint32_t i = 0; i < enabledLayerCount; ++i) { + tmp_ppEnabledLayerNames[i] = SafeStringCopy(in_struct->ppEnabledLayerNames[i]); + } + ppEnabledLayerNames = tmp_ppEnabledLayerNames; + char** tmp_ppEnabledExtensionNames = new char*[in_struct->enabledExtensionCount]; + for (uint32_t i = 0; i < enabledExtensionCount; ++i) { + tmp_ppEnabledExtensionNames[i] = SafeStringCopy(in_struct->ppEnabledExtensionNames[i]); + } + ppEnabledExtensionNames = tmp_ppEnabledExtensionNames; + if (in_struct->pApplicationInfo) pApplicationInfo = new safe_VkApplicationInfo(in_struct->pApplicationInfo); +} + +void safe_VkInstanceCreateInfo::initialize(const safe_VkInstanceCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pApplicationInfo = nullptr; + enabledLayerCount = copy_src->enabledLayerCount; + enabledExtensionCount = copy_src->enabledExtensionCount; + pNext = SafePnextCopy(copy_src->pNext); + + char** tmp_ppEnabledLayerNames = new char*[copy_src->enabledLayerCount]; + for (uint32_t i = 0; i < enabledLayerCount; ++i) { + tmp_ppEnabledLayerNames[i] = SafeStringCopy(copy_src->ppEnabledLayerNames[i]); + } + ppEnabledLayerNames = tmp_ppEnabledLayerNames; + char** tmp_ppEnabledExtensionNames = new char*[copy_src->enabledExtensionCount]; + for (uint32_t i = 0; i < enabledExtensionCount; ++i) { + tmp_ppEnabledExtensionNames[i] = SafeStringCopy(copy_src->ppEnabledExtensionNames[i]); + } + ppEnabledExtensionNames = tmp_ppEnabledExtensionNames; + if (copy_src->pApplicationInfo) pApplicationInfo = new safe_VkApplicationInfo(*copy_src->pApplicationInfo); +} + +safe_VkDeviceQueueCreateInfo::safe_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + queueFamilyIndex(in_struct->queueFamilyIndex), + queueCount(in_struct->queueCount), + pQueuePriorities(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pQueuePriorities) { + pQueuePriorities = new float[in_struct->queueCount]; + memcpy((void*)pQueuePriorities, (void*)in_struct->pQueuePriorities, sizeof(float) * in_struct->queueCount); + } +} + +safe_VkDeviceQueueCreateInfo::safe_VkDeviceQueueCreateInfo() + : sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO), + pNext(nullptr), + flags(), + queueFamilyIndex(), + queueCount(), + pQueuePriorities(nullptr) {} + +safe_VkDeviceQueueCreateInfo::safe_VkDeviceQueueCreateInfo(const safe_VkDeviceQueueCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + queueFamilyIndex = copy_src.queueFamilyIndex; + queueCount = copy_src.queueCount; + pQueuePriorities = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pQueuePriorities) { + pQueuePriorities = new float[copy_src.queueCount]; + memcpy((void*)pQueuePriorities, (void*)copy_src.pQueuePriorities, sizeof(float) * copy_src.queueCount); + } +} + +safe_VkDeviceQueueCreateInfo& safe_VkDeviceQueueCreateInfo::operator=(const safe_VkDeviceQueueCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pQueuePriorities) delete[] pQueuePriorities; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + queueFamilyIndex = copy_src.queueFamilyIndex; + queueCount = copy_src.queueCount; + pQueuePriorities = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pQueuePriorities) { + pQueuePriorities = new float[copy_src.queueCount]; + memcpy((void*)pQueuePriorities, (void*)copy_src.pQueuePriorities, sizeof(float) * copy_src.queueCount); + } + + return *this; +} + +safe_VkDeviceQueueCreateInfo::~safe_VkDeviceQueueCreateInfo() { + if (pQueuePriorities) delete[] pQueuePriorities; + FreePnextChain(pNext); +} + +void safe_VkDeviceQueueCreateInfo::initialize(const VkDeviceQueueCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pQueuePriorities) delete[] pQueuePriorities; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + queueFamilyIndex = in_struct->queueFamilyIndex; + queueCount = in_struct->queueCount; + pQueuePriorities = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pQueuePriorities) { + pQueuePriorities = new float[in_struct->queueCount]; + memcpy((void*)pQueuePriorities, (void*)in_struct->pQueuePriorities, sizeof(float) * in_struct->queueCount); + } +} + +void safe_VkDeviceQueueCreateInfo::initialize(const safe_VkDeviceQueueCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + queueFamilyIndex = copy_src->queueFamilyIndex; + queueCount = copy_src->queueCount; + pQueuePriorities = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pQueuePriorities) { + pQueuePriorities = new float[copy_src->queueCount]; + memcpy((void*)pQueuePriorities, (void*)copy_src->pQueuePriorities, sizeof(float) * copy_src->queueCount); + } +} + +safe_VkDeviceCreateInfo::safe_VkDeviceCreateInfo(const VkDeviceCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + queueCreateInfoCount(in_struct->queueCreateInfoCount), + pQueueCreateInfos(nullptr), + enabledLayerCount(in_struct->enabledLayerCount), + enabledExtensionCount(in_struct->enabledExtensionCount), + pEnabledFeatures(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + char** tmp_ppEnabledLayerNames = new char*[in_struct->enabledLayerCount]; + for (uint32_t i = 0; i < enabledLayerCount; ++i) { + tmp_ppEnabledLayerNames[i] = SafeStringCopy(in_struct->ppEnabledLayerNames[i]); + } + ppEnabledLayerNames = tmp_ppEnabledLayerNames; + char** tmp_ppEnabledExtensionNames = new char*[in_struct->enabledExtensionCount]; + for (uint32_t i = 0; i < enabledExtensionCount; ++i) { + tmp_ppEnabledExtensionNames[i] = SafeStringCopy(in_struct->ppEnabledExtensionNames[i]); + } + ppEnabledExtensionNames = tmp_ppEnabledExtensionNames; + if (queueCreateInfoCount && in_struct->pQueueCreateInfos) { + pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount]; + for (uint32_t i = 0; i < queueCreateInfoCount; ++i) { + pQueueCreateInfos[i].initialize(&in_struct->pQueueCreateInfos[i]); + } + } + + if (in_struct->pEnabledFeatures) { + pEnabledFeatures = new VkPhysicalDeviceFeatures(*in_struct->pEnabledFeatures); + } +} + +safe_VkDeviceCreateInfo::safe_VkDeviceCreateInfo() + : sType(VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO), + pNext(nullptr), + flags(), + queueCreateInfoCount(), + pQueueCreateInfos(nullptr), + enabledLayerCount(), + ppEnabledLayerNames(nullptr), + enabledExtensionCount(), + ppEnabledExtensionNames(nullptr), + pEnabledFeatures(nullptr) {} + +safe_VkDeviceCreateInfo::safe_VkDeviceCreateInfo(const safe_VkDeviceCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + queueCreateInfoCount = copy_src.queueCreateInfoCount; + pQueueCreateInfos = nullptr; + enabledLayerCount = copy_src.enabledLayerCount; + enabledExtensionCount = copy_src.enabledExtensionCount; + pEnabledFeatures = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + char** tmp_ppEnabledLayerNames = new char*[copy_src.enabledLayerCount]; + for (uint32_t i = 0; i < enabledLayerCount; ++i) { + tmp_ppEnabledLayerNames[i] = SafeStringCopy(copy_src.ppEnabledLayerNames[i]); + } + ppEnabledLayerNames = tmp_ppEnabledLayerNames; + char** tmp_ppEnabledExtensionNames = new char*[copy_src.enabledExtensionCount]; + for (uint32_t i = 0; i < enabledExtensionCount; ++i) { + tmp_ppEnabledExtensionNames[i] = SafeStringCopy(copy_src.ppEnabledExtensionNames[i]); + } + ppEnabledExtensionNames = tmp_ppEnabledExtensionNames; + if (queueCreateInfoCount && copy_src.pQueueCreateInfos) { + pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount]; + for (uint32_t i = 0; i < queueCreateInfoCount; ++i) { + pQueueCreateInfos[i].initialize(©_src.pQueueCreateInfos[i]); + } + } + + if (copy_src.pEnabledFeatures) { + pEnabledFeatures = new VkPhysicalDeviceFeatures(*copy_src.pEnabledFeatures); + } +} + +safe_VkDeviceCreateInfo& safe_VkDeviceCreateInfo::operator=(const safe_VkDeviceCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pQueueCreateInfos) delete[] pQueueCreateInfos; + + if (ppEnabledLayerNames) { + for (uint32_t i = 0; i < enabledLayerCount; ++i) { + delete[] ppEnabledLayerNames[i]; + } + delete[] ppEnabledLayerNames; + } + if (ppEnabledExtensionNames) { + for (uint32_t i = 0; i < enabledExtensionCount; ++i) { + delete[] ppEnabledExtensionNames[i]; + } + delete[] ppEnabledExtensionNames; + } + if (pEnabledFeatures) delete pEnabledFeatures; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + queueCreateInfoCount = copy_src.queueCreateInfoCount; + pQueueCreateInfos = nullptr; + enabledLayerCount = copy_src.enabledLayerCount; + enabledExtensionCount = copy_src.enabledExtensionCount; + pEnabledFeatures = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + char** tmp_ppEnabledLayerNames = new char*[copy_src.enabledLayerCount]; + for (uint32_t i = 0; i < enabledLayerCount; ++i) { + tmp_ppEnabledLayerNames[i] = SafeStringCopy(copy_src.ppEnabledLayerNames[i]); + } + ppEnabledLayerNames = tmp_ppEnabledLayerNames; + char** tmp_ppEnabledExtensionNames = new char*[copy_src.enabledExtensionCount]; + for (uint32_t i = 0; i < enabledExtensionCount; ++i) { + tmp_ppEnabledExtensionNames[i] = SafeStringCopy(copy_src.ppEnabledExtensionNames[i]); + } + ppEnabledExtensionNames = tmp_ppEnabledExtensionNames; + if (queueCreateInfoCount && copy_src.pQueueCreateInfos) { + pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount]; + for (uint32_t i = 0; i < queueCreateInfoCount; ++i) { + pQueueCreateInfos[i].initialize(©_src.pQueueCreateInfos[i]); + } + } + + if (copy_src.pEnabledFeatures) { + pEnabledFeatures = new VkPhysicalDeviceFeatures(*copy_src.pEnabledFeatures); + } + + return *this; +} + +safe_VkDeviceCreateInfo::~safe_VkDeviceCreateInfo() { + if (pQueueCreateInfos) delete[] pQueueCreateInfos; + + if (ppEnabledLayerNames) { + for (uint32_t i = 0; i < enabledLayerCount; ++i) { + delete[] ppEnabledLayerNames[i]; + } + delete[] ppEnabledLayerNames; + } + if (ppEnabledExtensionNames) { + for (uint32_t i = 0; i < enabledExtensionCount; ++i) { + delete[] ppEnabledExtensionNames[i]; + } + delete[] ppEnabledExtensionNames; + } + if (pEnabledFeatures) delete pEnabledFeatures; + FreePnextChain(pNext); +} + +void safe_VkDeviceCreateInfo::initialize(const VkDeviceCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pQueueCreateInfos) delete[] pQueueCreateInfos; + + if (ppEnabledLayerNames) { + for (uint32_t i = 0; i < enabledLayerCount; ++i) { + delete[] ppEnabledLayerNames[i]; + } + delete[] ppEnabledLayerNames; + } + if (ppEnabledExtensionNames) { + for (uint32_t i = 0; i < enabledExtensionCount; ++i) { + delete[] ppEnabledExtensionNames[i]; + } + delete[] ppEnabledExtensionNames; + } + if (pEnabledFeatures) delete pEnabledFeatures; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + queueCreateInfoCount = in_struct->queueCreateInfoCount; + pQueueCreateInfos = nullptr; + enabledLayerCount = in_struct->enabledLayerCount; + enabledExtensionCount = in_struct->enabledExtensionCount; + pEnabledFeatures = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + char** tmp_ppEnabledLayerNames = new char*[in_struct->enabledLayerCount]; + for (uint32_t i = 0; i < enabledLayerCount; ++i) { + tmp_ppEnabledLayerNames[i] = SafeStringCopy(in_struct->ppEnabledLayerNames[i]); + } + ppEnabledLayerNames = tmp_ppEnabledLayerNames; + char** tmp_ppEnabledExtensionNames = new char*[in_struct->enabledExtensionCount]; + for (uint32_t i = 0; i < enabledExtensionCount; ++i) { + tmp_ppEnabledExtensionNames[i] = SafeStringCopy(in_struct->ppEnabledExtensionNames[i]); + } + ppEnabledExtensionNames = tmp_ppEnabledExtensionNames; + if (queueCreateInfoCount && in_struct->pQueueCreateInfos) { + pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount]; + for (uint32_t i = 0; i < queueCreateInfoCount; ++i) { + pQueueCreateInfos[i].initialize(&in_struct->pQueueCreateInfos[i]); + } + } + + if (in_struct->pEnabledFeatures) { + pEnabledFeatures = new VkPhysicalDeviceFeatures(*in_struct->pEnabledFeatures); + } +} + +void safe_VkDeviceCreateInfo::initialize(const safe_VkDeviceCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + queueCreateInfoCount = copy_src->queueCreateInfoCount; + pQueueCreateInfos = nullptr; + enabledLayerCount = copy_src->enabledLayerCount; + enabledExtensionCount = copy_src->enabledExtensionCount; + pEnabledFeatures = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + char** tmp_ppEnabledLayerNames = new char*[copy_src->enabledLayerCount]; + for (uint32_t i = 0; i < enabledLayerCount; ++i) { + tmp_ppEnabledLayerNames[i] = SafeStringCopy(copy_src->ppEnabledLayerNames[i]); + } + ppEnabledLayerNames = tmp_ppEnabledLayerNames; + char** tmp_ppEnabledExtensionNames = new char*[copy_src->enabledExtensionCount]; + for (uint32_t i = 0; i < enabledExtensionCount; ++i) { + tmp_ppEnabledExtensionNames[i] = SafeStringCopy(copy_src->ppEnabledExtensionNames[i]); + } + ppEnabledExtensionNames = tmp_ppEnabledExtensionNames; + if (queueCreateInfoCount && copy_src->pQueueCreateInfos) { + pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount]; + for (uint32_t i = 0; i < queueCreateInfoCount; ++i) { + pQueueCreateInfos[i].initialize(©_src->pQueueCreateInfos[i]); + } + } + + if (copy_src->pEnabledFeatures) { + pEnabledFeatures = new VkPhysicalDeviceFeatures(*copy_src->pEnabledFeatures); + } +} + +safe_VkSubmitInfo::safe_VkSubmitInfo(const VkSubmitInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + waitSemaphoreCount(in_struct->waitSemaphoreCount), + pWaitSemaphores(nullptr), + pWaitDstStageMask(nullptr), + commandBufferCount(in_struct->commandBufferCount), + pCommandBuffers(nullptr), + signalSemaphoreCount(in_struct->signalSemaphoreCount), + pSignalSemaphores(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (waitSemaphoreCount && in_struct->pWaitSemaphores) { + pWaitSemaphores = new VkSemaphore[waitSemaphoreCount]; + for (uint32_t i = 0; i < waitSemaphoreCount; ++i) { + pWaitSemaphores[i] = in_struct->pWaitSemaphores[i]; + } + } + + if (in_struct->pWaitDstStageMask) { + pWaitDstStageMask = new VkPipelineStageFlags[in_struct->waitSemaphoreCount]; + memcpy((void*)pWaitDstStageMask, (void*)in_struct->pWaitDstStageMask, + sizeof(VkPipelineStageFlags) * in_struct->waitSemaphoreCount); + } + + if (in_struct->pCommandBuffers) { + pCommandBuffers = new VkCommandBuffer[in_struct->commandBufferCount]; + memcpy((void*)pCommandBuffers, (void*)in_struct->pCommandBuffers, sizeof(VkCommandBuffer) * in_struct->commandBufferCount); + } + if (signalSemaphoreCount && in_struct->pSignalSemaphores) { + pSignalSemaphores = new VkSemaphore[signalSemaphoreCount]; + for (uint32_t i = 0; i < signalSemaphoreCount; ++i) { + pSignalSemaphores[i] = in_struct->pSignalSemaphores[i]; + } + } +} + +safe_VkSubmitInfo::safe_VkSubmitInfo() + : sType(VK_STRUCTURE_TYPE_SUBMIT_INFO), + pNext(nullptr), + waitSemaphoreCount(), + pWaitSemaphores(nullptr), + pWaitDstStageMask(nullptr), + commandBufferCount(), + pCommandBuffers(nullptr), + signalSemaphoreCount(), + pSignalSemaphores(nullptr) {} + +safe_VkSubmitInfo::safe_VkSubmitInfo(const safe_VkSubmitInfo& copy_src) { + sType = copy_src.sType; + waitSemaphoreCount = copy_src.waitSemaphoreCount; + pWaitSemaphores = nullptr; + pWaitDstStageMask = nullptr; + commandBufferCount = copy_src.commandBufferCount; + pCommandBuffers = nullptr; + signalSemaphoreCount = copy_src.signalSemaphoreCount; + pSignalSemaphores = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (waitSemaphoreCount && copy_src.pWaitSemaphores) { + pWaitSemaphores = new VkSemaphore[waitSemaphoreCount]; + for (uint32_t i = 0; i < waitSemaphoreCount; ++i) { + pWaitSemaphores[i] = copy_src.pWaitSemaphores[i]; + } + } + + if (copy_src.pWaitDstStageMask) { + pWaitDstStageMask = new VkPipelineStageFlags[copy_src.waitSemaphoreCount]; + memcpy((void*)pWaitDstStageMask, (void*)copy_src.pWaitDstStageMask, + sizeof(VkPipelineStageFlags) * copy_src.waitSemaphoreCount); + } + + if (copy_src.pCommandBuffers) { + pCommandBuffers = new VkCommandBuffer[copy_src.commandBufferCount]; + memcpy((void*)pCommandBuffers, (void*)copy_src.pCommandBuffers, sizeof(VkCommandBuffer) * copy_src.commandBufferCount); + } + if (signalSemaphoreCount && copy_src.pSignalSemaphores) { + pSignalSemaphores = new VkSemaphore[signalSemaphoreCount]; + for (uint32_t i = 0; i < signalSemaphoreCount; ++i) { + pSignalSemaphores[i] = copy_src.pSignalSemaphores[i]; + } + } +} + +safe_VkSubmitInfo& safe_VkSubmitInfo::operator=(const safe_VkSubmitInfo& copy_src) { + if (©_src == this) return *this; + + if (pWaitSemaphores) delete[] pWaitSemaphores; + if (pWaitDstStageMask) delete[] pWaitDstStageMask; + if (pCommandBuffers) delete[] pCommandBuffers; + if (pSignalSemaphores) delete[] pSignalSemaphores; + FreePnextChain(pNext); + + sType = copy_src.sType; + waitSemaphoreCount = copy_src.waitSemaphoreCount; + pWaitSemaphores = nullptr; + pWaitDstStageMask = nullptr; + commandBufferCount = copy_src.commandBufferCount; + pCommandBuffers = nullptr; + signalSemaphoreCount = copy_src.signalSemaphoreCount; + pSignalSemaphores = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (waitSemaphoreCount && copy_src.pWaitSemaphores) { + pWaitSemaphores = new VkSemaphore[waitSemaphoreCount]; + for (uint32_t i = 0; i < waitSemaphoreCount; ++i) { + pWaitSemaphores[i] = copy_src.pWaitSemaphores[i]; + } + } + + if (copy_src.pWaitDstStageMask) { + pWaitDstStageMask = new VkPipelineStageFlags[copy_src.waitSemaphoreCount]; + memcpy((void*)pWaitDstStageMask, (void*)copy_src.pWaitDstStageMask, + sizeof(VkPipelineStageFlags) * copy_src.waitSemaphoreCount); + } + + if (copy_src.pCommandBuffers) { + pCommandBuffers = new VkCommandBuffer[copy_src.commandBufferCount]; + memcpy((void*)pCommandBuffers, (void*)copy_src.pCommandBuffers, sizeof(VkCommandBuffer) * copy_src.commandBufferCount); + } + if (signalSemaphoreCount && copy_src.pSignalSemaphores) { + pSignalSemaphores = new VkSemaphore[signalSemaphoreCount]; + for (uint32_t i = 0; i < signalSemaphoreCount; ++i) { + pSignalSemaphores[i] = copy_src.pSignalSemaphores[i]; + } + } + + return *this; +} + +safe_VkSubmitInfo::~safe_VkSubmitInfo() { + if (pWaitSemaphores) delete[] pWaitSemaphores; + if (pWaitDstStageMask) delete[] pWaitDstStageMask; + if (pCommandBuffers) delete[] pCommandBuffers; + if (pSignalSemaphores) delete[] pSignalSemaphores; + FreePnextChain(pNext); +} + +void safe_VkSubmitInfo::initialize(const VkSubmitInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pWaitSemaphores) delete[] pWaitSemaphores; + if (pWaitDstStageMask) delete[] pWaitDstStageMask; + if (pCommandBuffers) delete[] pCommandBuffers; + if (pSignalSemaphores) delete[] pSignalSemaphores; + FreePnextChain(pNext); + sType = in_struct->sType; + waitSemaphoreCount = in_struct->waitSemaphoreCount; + pWaitSemaphores = nullptr; + pWaitDstStageMask = nullptr; + commandBufferCount = in_struct->commandBufferCount; + pCommandBuffers = nullptr; + signalSemaphoreCount = in_struct->signalSemaphoreCount; + pSignalSemaphores = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (waitSemaphoreCount && in_struct->pWaitSemaphores) { + pWaitSemaphores = new VkSemaphore[waitSemaphoreCount]; + for (uint32_t i = 0; i < waitSemaphoreCount; ++i) { + pWaitSemaphores[i] = in_struct->pWaitSemaphores[i]; + } + } + + if (in_struct->pWaitDstStageMask) { + pWaitDstStageMask = new VkPipelineStageFlags[in_struct->waitSemaphoreCount]; + memcpy((void*)pWaitDstStageMask, (void*)in_struct->pWaitDstStageMask, + sizeof(VkPipelineStageFlags) * in_struct->waitSemaphoreCount); + } + + if (in_struct->pCommandBuffers) { + pCommandBuffers = new VkCommandBuffer[in_struct->commandBufferCount]; + memcpy((void*)pCommandBuffers, (void*)in_struct->pCommandBuffers, sizeof(VkCommandBuffer) * in_struct->commandBufferCount); + } + if (signalSemaphoreCount && in_struct->pSignalSemaphores) { + pSignalSemaphores = new VkSemaphore[signalSemaphoreCount]; + for (uint32_t i = 0; i < signalSemaphoreCount; ++i) { + pSignalSemaphores[i] = in_struct->pSignalSemaphores[i]; + } + } +} + +void safe_VkSubmitInfo::initialize(const safe_VkSubmitInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + waitSemaphoreCount = copy_src->waitSemaphoreCount; + pWaitSemaphores = nullptr; + pWaitDstStageMask = nullptr; + commandBufferCount = copy_src->commandBufferCount; + pCommandBuffers = nullptr; + signalSemaphoreCount = copy_src->signalSemaphoreCount; + pSignalSemaphores = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (waitSemaphoreCount && copy_src->pWaitSemaphores) { + pWaitSemaphores = new VkSemaphore[waitSemaphoreCount]; + for (uint32_t i = 0; i < waitSemaphoreCount; ++i) { + pWaitSemaphores[i] = copy_src->pWaitSemaphores[i]; + } + } + + if (copy_src->pWaitDstStageMask) { + pWaitDstStageMask = new VkPipelineStageFlags[copy_src->waitSemaphoreCount]; + memcpy((void*)pWaitDstStageMask, (void*)copy_src->pWaitDstStageMask, + sizeof(VkPipelineStageFlags) * copy_src->waitSemaphoreCount); + } + + if (copy_src->pCommandBuffers) { + pCommandBuffers = new VkCommandBuffer[copy_src->commandBufferCount]; + memcpy((void*)pCommandBuffers, (void*)copy_src->pCommandBuffers, sizeof(VkCommandBuffer) * copy_src->commandBufferCount); + } + if (signalSemaphoreCount && copy_src->pSignalSemaphores) { + pSignalSemaphores = new VkSemaphore[signalSemaphoreCount]; + for (uint32_t i = 0; i < signalSemaphoreCount; ++i) { + pSignalSemaphores[i] = copy_src->pSignalSemaphores[i]; + } + } +} + +safe_VkMappedMemoryRange::safe_VkMappedMemoryRange(const VkMappedMemoryRange* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), memory(in_struct->memory), offset(in_struct->offset), size(in_struct->size) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMappedMemoryRange::safe_VkMappedMemoryRange() + : sType(VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE), pNext(nullptr), memory(), offset(), size() {} + +safe_VkMappedMemoryRange::safe_VkMappedMemoryRange(const safe_VkMappedMemoryRange& copy_src) { + sType = copy_src.sType; + memory = copy_src.memory; + offset = copy_src.offset; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMappedMemoryRange& safe_VkMappedMemoryRange::operator=(const safe_VkMappedMemoryRange& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memory = copy_src.memory; + offset = copy_src.offset; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMappedMemoryRange::~safe_VkMappedMemoryRange() { FreePnextChain(pNext); } + +void safe_VkMappedMemoryRange::initialize(const VkMappedMemoryRange* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memory = in_struct->memory; + offset = in_struct->offset; + size = in_struct->size; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMappedMemoryRange::initialize(const safe_VkMappedMemoryRange* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memory = copy_src->memory; + offset = copy_src->offset; + size = copy_src->size; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMemoryAllocateInfo::safe_VkMemoryAllocateInfo(const VkMemoryAllocateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), allocationSize(in_struct->allocationSize), memoryTypeIndex(in_struct->memoryTypeIndex) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMemoryAllocateInfo::safe_VkMemoryAllocateInfo() + : sType(VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO), pNext(nullptr), allocationSize(), memoryTypeIndex() {} + +safe_VkMemoryAllocateInfo::safe_VkMemoryAllocateInfo(const safe_VkMemoryAllocateInfo& copy_src) { + sType = copy_src.sType; + allocationSize = copy_src.allocationSize; + memoryTypeIndex = copy_src.memoryTypeIndex; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryAllocateInfo& safe_VkMemoryAllocateInfo::operator=(const safe_VkMemoryAllocateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + allocationSize = copy_src.allocationSize; + memoryTypeIndex = copy_src.memoryTypeIndex; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryAllocateInfo::~safe_VkMemoryAllocateInfo() { FreePnextChain(pNext); } + +void safe_VkMemoryAllocateInfo::initialize(const VkMemoryAllocateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + allocationSize = in_struct->allocationSize; + memoryTypeIndex = in_struct->memoryTypeIndex; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryAllocateInfo::initialize(const safe_VkMemoryAllocateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + allocationSize = copy_src->allocationSize; + memoryTypeIndex = copy_src->memoryTypeIndex; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) + : buffer(in_struct->buffer), bindCount(in_struct->bindCount), pBinds(nullptr) { + if (bindCount && in_struct->pBinds) { + pBinds = new VkSparseMemoryBind[bindCount]; + for (uint32_t i = 0; i < bindCount; ++i) { + pBinds[i] = in_struct->pBinds[i]; + } + } +} + +safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo() : buffer(), bindCount(), pBinds(nullptr) {} + +safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo(const safe_VkSparseBufferMemoryBindInfo& copy_src) { + buffer = copy_src.buffer; + bindCount = copy_src.bindCount; + pBinds = nullptr; + if (bindCount && copy_src.pBinds) { + pBinds = new VkSparseMemoryBind[bindCount]; + for (uint32_t i = 0; i < bindCount; ++i) { + pBinds[i] = copy_src.pBinds[i]; + } + } +} + +safe_VkSparseBufferMemoryBindInfo& safe_VkSparseBufferMemoryBindInfo::operator=(const safe_VkSparseBufferMemoryBindInfo& copy_src) { + if (©_src == this) return *this; + + if (pBinds) delete[] pBinds; + + buffer = copy_src.buffer; + bindCount = copy_src.bindCount; + pBinds = nullptr; + if (bindCount && copy_src.pBinds) { + pBinds = new VkSparseMemoryBind[bindCount]; + for (uint32_t i = 0; i < bindCount; ++i) { + pBinds[i] = copy_src.pBinds[i]; + } + } + + return *this; +} + +safe_VkSparseBufferMemoryBindInfo::~safe_VkSparseBufferMemoryBindInfo() { + if (pBinds) delete[] pBinds; +} + +void safe_VkSparseBufferMemoryBindInfo::initialize(const VkSparseBufferMemoryBindInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pBinds) delete[] pBinds; + buffer = in_struct->buffer; + bindCount = in_struct->bindCount; + pBinds = nullptr; + if (bindCount && in_struct->pBinds) { + pBinds = new VkSparseMemoryBind[bindCount]; + for (uint32_t i = 0; i < bindCount; ++i) { + pBinds[i] = in_struct->pBinds[i]; + } + } +} + +void safe_VkSparseBufferMemoryBindInfo::initialize(const safe_VkSparseBufferMemoryBindInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + buffer = copy_src->buffer; + bindCount = copy_src->bindCount; + pBinds = nullptr; + if (bindCount && copy_src->pBinds) { + pBinds = new VkSparseMemoryBind[bindCount]; + for (uint32_t i = 0; i < bindCount; ++i) { + pBinds[i] = copy_src->pBinds[i]; + } + } +} + +safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) + : image(in_struct->image), bindCount(in_struct->bindCount), pBinds(nullptr) { + if (bindCount && in_struct->pBinds) { + pBinds = new VkSparseMemoryBind[bindCount]; + for (uint32_t i = 0; i < bindCount; ++i) { + pBinds[i] = in_struct->pBinds[i]; + } + } +} + +safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo() : image(), bindCount(), pBinds(nullptr) {} + +safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo( + const safe_VkSparseImageOpaqueMemoryBindInfo& copy_src) { + image = copy_src.image; + bindCount = copy_src.bindCount; + pBinds = nullptr; + if (bindCount && copy_src.pBinds) { + pBinds = new VkSparseMemoryBind[bindCount]; + for (uint32_t i = 0; i < bindCount; ++i) { + pBinds[i] = copy_src.pBinds[i]; + } + } +} + +safe_VkSparseImageOpaqueMemoryBindInfo& safe_VkSparseImageOpaqueMemoryBindInfo::operator=( + const safe_VkSparseImageOpaqueMemoryBindInfo& copy_src) { + if (©_src == this) return *this; + + if (pBinds) delete[] pBinds; + + image = copy_src.image; + bindCount = copy_src.bindCount; + pBinds = nullptr; + if (bindCount && copy_src.pBinds) { + pBinds = new VkSparseMemoryBind[bindCount]; + for (uint32_t i = 0; i < bindCount; ++i) { + pBinds[i] = copy_src.pBinds[i]; + } + } + + return *this; +} + +safe_VkSparseImageOpaqueMemoryBindInfo::~safe_VkSparseImageOpaqueMemoryBindInfo() { + if (pBinds) delete[] pBinds; +} + +void safe_VkSparseImageOpaqueMemoryBindInfo::initialize(const VkSparseImageOpaqueMemoryBindInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pBinds) delete[] pBinds; + image = in_struct->image; + bindCount = in_struct->bindCount; + pBinds = nullptr; + if (bindCount && in_struct->pBinds) { + pBinds = new VkSparseMemoryBind[bindCount]; + for (uint32_t i = 0; i < bindCount; ++i) { + pBinds[i] = in_struct->pBinds[i]; + } + } +} + +void safe_VkSparseImageOpaqueMemoryBindInfo::initialize(const safe_VkSparseImageOpaqueMemoryBindInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + image = copy_src->image; + bindCount = copy_src->bindCount; + pBinds = nullptr; + if (bindCount && copy_src->pBinds) { + pBinds = new VkSparseMemoryBind[bindCount]; + for (uint32_t i = 0; i < bindCount; ++i) { + pBinds[i] = copy_src->pBinds[i]; + } + } +} + +safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) + : image(in_struct->image), bindCount(in_struct->bindCount), pBinds(nullptr) { + if (bindCount && in_struct->pBinds) { + pBinds = new VkSparseImageMemoryBind[bindCount]; + for (uint32_t i = 0; i < bindCount; ++i) { + pBinds[i] = in_struct->pBinds[i]; + } + } +} + +safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo() : image(), bindCount(), pBinds(nullptr) {} + +safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo(const safe_VkSparseImageMemoryBindInfo& copy_src) { + image = copy_src.image; + bindCount = copy_src.bindCount; + pBinds = nullptr; + if (bindCount && copy_src.pBinds) { + pBinds = new VkSparseImageMemoryBind[bindCount]; + for (uint32_t i = 0; i < bindCount; ++i) { + pBinds[i] = copy_src.pBinds[i]; + } + } +} + +safe_VkSparseImageMemoryBindInfo& safe_VkSparseImageMemoryBindInfo::operator=(const safe_VkSparseImageMemoryBindInfo& copy_src) { + if (©_src == this) return *this; + + if (pBinds) delete[] pBinds; + + image = copy_src.image; + bindCount = copy_src.bindCount; + pBinds = nullptr; + if (bindCount && copy_src.pBinds) { + pBinds = new VkSparseImageMemoryBind[bindCount]; + for (uint32_t i = 0; i < bindCount; ++i) { + pBinds[i] = copy_src.pBinds[i]; + } + } + + return *this; +} + +safe_VkSparseImageMemoryBindInfo::~safe_VkSparseImageMemoryBindInfo() { + if (pBinds) delete[] pBinds; +} + +void safe_VkSparseImageMemoryBindInfo::initialize(const VkSparseImageMemoryBindInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pBinds) delete[] pBinds; + image = in_struct->image; + bindCount = in_struct->bindCount; + pBinds = nullptr; + if (bindCount && in_struct->pBinds) { + pBinds = new VkSparseImageMemoryBind[bindCount]; + for (uint32_t i = 0; i < bindCount; ++i) { + pBinds[i] = in_struct->pBinds[i]; + } + } +} + +void safe_VkSparseImageMemoryBindInfo::initialize(const safe_VkSparseImageMemoryBindInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + image = copy_src->image; + bindCount = copy_src->bindCount; + pBinds = nullptr; + if (bindCount && copy_src->pBinds) { + pBinds = new VkSparseImageMemoryBind[bindCount]; + for (uint32_t i = 0; i < bindCount; ++i) { + pBinds[i] = copy_src->pBinds[i]; + } + } +} + +safe_VkBindSparseInfo::safe_VkBindSparseInfo(const VkBindSparseInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + waitSemaphoreCount(in_struct->waitSemaphoreCount), + pWaitSemaphores(nullptr), + bufferBindCount(in_struct->bufferBindCount), + pBufferBinds(nullptr), + imageOpaqueBindCount(in_struct->imageOpaqueBindCount), + pImageOpaqueBinds(nullptr), + imageBindCount(in_struct->imageBindCount), + pImageBinds(nullptr), + signalSemaphoreCount(in_struct->signalSemaphoreCount), + pSignalSemaphores(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (waitSemaphoreCount && in_struct->pWaitSemaphores) { + pWaitSemaphores = new VkSemaphore[waitSemaphoreCount]; + for (uint32_t i = 0; i < waitSemaphoreCount; ++i) { + pWaitSemaphores[i] = in_struct->pWaitSemaphores[i]; + } + } + if (bufferBindCount && in_struct->pBufferBinds) { + pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount]; + for (uint32_t i = 0; i < bufferBindCount; ++i) { + pBufferBinds[i].initialize(&in_struct->pBufferBinds[i]); + } + } + if (imageOpaqueBindCount && in_struct->pImageOpaqueBinds) { + pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount]; + for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) { + pImageOpaqueBinds[i].initialize(&in_struct->pImageOpaqueBinds[i]); + } + } + if (imageBindCount && in_struct->pImageBinds) { + pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount]; + for (uint32_t i = 0; i < imageBindCount; ++i) { + pImageBinds[i].initialize(&in_struct->pImageBinds[i]); + } + } + if (signalSemaphoreCount && in_struct->pSignalSemaphores) { + pSignalSemaphores = new VkSemaphore[signalSemaphoreCount]; + for (uint32_t i = 0; i < signalSemaphoreCount; ++i) { + pSignalSemaphores[i] = in_struct->pSignalSemaphores[i]; + } + } +} + +safe_VkBindSparseInfo::safe_VkBindSparseInfo() + : sType(VK_STRUCTURE_TYPE_BIND_SPARSE_INFO), + pNext(nullptr), + waitSemaphoreCount(), + pWaitSemaphores(nullptr), + bufferBindCount(), + pBufferBinds(nullptr), + imageOpaqueBindCount(), + pImageOpaqueBinds(nullptr), + imageBindCount(), + pImageBinds(nullptr), + signalSemaphoreCount(), + pSignalSemaphores(nullptr) {} + +safe_VkBindSparseInfo::safe_VkBindSparseInfo(const safe_VkBindSparseInfo& copy_src) { + sType = copy_src.sType; + waitSemaphoreCount = copy_src.waitSemaphoreCount; + pWaitSemaphores = nullptr; + bufferBindCount = copy_src.bufferBindCount; + pBufferBinds = nullptr; + imageOpaqueBindCount = copy_src.imageOpaqueBindCount; + pImageOpaqueBinds = nullptr; + imageBindCount = copy_src.imageBindCount; + pImageBinds = nullptr; + signalSemaphoreCount = copy_src.signalSemaphoreCount; + pSignalSemaphores = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (waitSemaphoreCount && copy_src.pWaitSemaphores) { + pWaitSemaphores = new VkSemaphore[waitSemaphoreCount]; + for (uint32_t i = 0; i < waitSemaphoreCount; ++i) { + pWaitSemaphores[i] = copy_src.pWaitSemaphores[i]; + } + } + if (bufferBindCount && copy_src.pBufferBinds) { + pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount]; + for (uint32_t i = 0; i < bufferBindCount; ++i) { + pBufferBinds[i].initialize(©_src.pBufferBinds[i]); + } + } + if (imageOpaqueBindCount && copy_src.pImageOpaqueBinds) { + pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount]; + for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) { + pImageOpaqueBinds[i].initialize(©_src.pImageOpaqueBinds[i]); + } + } + if (imageBindCount && copy_src.pImageBinds) { + pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount]; + for (uint32_t i = 0; i < imageBindCount; ++i) { + pImageBinds[i].initialize(©_src.pImageBinds[i]); + } + } + if (signalSemaphoreCount && copy_src.pSignalSemaphores) { + pSignalSemaphores = new VkSemaphore[signalSemaphoreCount]; + for (uint32_t i = 0; i < signalSemaphoreCount; ++i) { + pSignalSemaphores[i] = copy_src.pSignalSemaphores[i]; + } + } +} + +safe_VkBindSparseInfo& safe_VkBindSparseInfo::operator=(const safe_VkBindSparseInfo& copy_src) { + if (©_src == this) return *this; + + if (pWaitSemaphores) delete[] pWaitSemaphores; + if (pBufferBinds) delete[] pBufferBinds; + if (pImageOpaqueBinds) delete[] pImageOpaqueBinds; + if (pImageBinds) delete[] pImageBinds; + if (pSignalSemaphores) delete[] pSignalSemaphores; + FreePnextChain(pNext); + + sType = copy_src.sType; + waitSemaphoreCount = copy_src.waitSemaphoreCount; + pWaitSemaphores = nullptr; + bufferBindCount = copy_src.bufferBindCount; + pBufferBinds = nullptr; + imageOpaqueBindCount = copy_src.imageOpaqueBindCount; + pImageOpaqueBinds = nullptr; + imageBindCount = copy_src.imageBindCount; + pImageBinds = nullptr; + signalSemaphoreCount = copy_src.signalSemaphoreCount; + pSignalSemaphores = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (waitSemaphoreCount && copy_src.pWaitSemaphores) { + pWaitSemaphores = new VkSemaphore[waitSemaphoreCount]; + for (uint32_t i = 0; i < waitSemaphoreCount; ++i) { + pWaitSemaphores[i] = copy_src.pWaitSemaphores[i]; + } + } + if (bufferBindCount && copy_src.pBufferBinds) { + pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount]; + for (uint32_t i = 0; i < bufferBindCount; ++i) { + pBufferBinds[i].initialize(©_src.pBufferBinds[i]); + } + } + if (imageOpaqueBindCount && copy_src.pImageOpaqueBinds) { + pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount]; + for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) { + pImageOpaqueBinds[i].initialize(©_src.pImageOpaqueBinds[i]); + } + } + if (imageBindCount && copy_src.pImageBinds) { + pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount]; + for (uint32_t i = 0; i < imageBindCount; ++i) { + pImageBinds[i].initialize(©_src.pImageBinds[i]); + } + } + if (signalSemaphoreCount && copy_src.pSignalSemaphores) { + pSignalSemaphores = new VkSemaphore[signalSemaphoreCount]; + for (uint32_t i = 0; i < signalSemaphoreCount; ++i) { + pSignalSemaphores[i] = copy_src.pSignalSemaphores[i]; + } + } + + return *this; +} + +safe_VkBindSparseInfo::~safe_VkBindSparseInfo() { + if (pWaitSemaphores) delete[] pWaitSemaphores; + if (pBufferBinds) delete[] pBufferBinds; + if (pImageOpaqueBinds) delete[] pImageOpaqueBinds; + if (pImageBinds) delete[] pImageBinds; + if (pSignalSemaphores) delete[] pSignalSemaphores; + FreePnextChain(pNext); +} + +void safe_VkBindSparseInfo::initialize(const VkBindSparseInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pWaitSemaphores) delete[] pWaitSemaphores; + if (pBufferBinds) delete[] pBufferBinds; + if (pImageOpaqueBinds) delete[] pImageOpaqueBinds; + if (pImageBinds) delete[] pImageBinds; + if (pSignalSemaphores) delete[] pSignalSemaphores; + FreePnextChain(pNext); + sType = in_struct->sType; + waitSemaphoreCount = in_struct->waitSemaphoreCount; + pWaitSemaphores = nullptr; + bufferBindCount = in_struct->bufferBindCount; + pBufferBinds = nullptr; + imageOpaqueBindCount = in_struct->imageOpaqueBindCount; + pImageOpaqueBinds = nullptr; + imageBindCount = in_struct->imageBindCount; + pImageBinds = nullptr; + signalSemaphoreCount = in_struct->signalSemaphoreCount; + pSignalSemaphores = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (waitSemaphoreCount && in_struct->pWaitSemaphores) { + pWaitSemaphores = new VkSemaphore[waitSemaphoreCount]; + for (uint32_t i = 0; i < waitSemaphoreCount; ++i) { + pWaitSemaphores[i] = in_struct->pWaitSemaphores[i]; + } + } + if (bufferBindCount && in_struct->pBufferBinds) { + pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount]; + for (uint32_t i = 0; i < bufferBindCount; ++i) { + pBufferBinds[i].initialize(&in_struct->pBufferBinds[i]); + } + } + if (imageOpaqueBindCount && in_struct->pImageOpaqueBinds) { + pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount]; + for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) { + pImageOpaqueBinds[i].initialize(&in_struct->pImageOpaqueBinds[i]); + } + } + if (imageBindCount && in_struct->pImageBinds) { + pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount]; + for (uint32_t i = 0; i < imageBindCount; ++i) { + pImageBinds[i].initialize(&in_struct->pImageBinds[i]); + } + } + if (signalSemaphoreCount && in_struct->pSignalSemaphores) { + pSignalSemaphores = new VkSemaphore[signalSemaphoreCount]; + for (uint32_t i = 0; i < signalSemaphoreCount; ++i) { + pSignalSemaphores[i] = in_struct->pSignalSemaphores[i]; + } + } +} + +void safe_VkBindSparseInfo::initialize(const safe_VkBindSparseInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + waitSemaphoreCount = copy_src->waitSemaphoreCount; + pWaitSemaphores = nullptr; + bufferBindCount = copy_src->bufferBindCount; + pBufferBinds = nullptr; + imageOpaqueBindCount = copy_src->imageOpaqueBindCount; + pImageOpaqueBinds = nullptr; + imageBindCount = copy_src->imageBindCount; + pImageBinds = nullptr; + signalSemaphoreCount = copy_src->signalSemaphoreCount; + pSignalSemaphores = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (waitSemaphoreCount && copy_src->pWaitSemaphores) { + pWaitSemaphores = new VkSemaphore[waitSemaphoreCount]; + for (uint32_t i = 0; i < waitSemaphoreCount; ++i) { + pWaitSemaphores[i] = copy_src->pWaitSemaphores[i]; + } + } + if (bufferBindCount && copy_src->pBufferBinds) { + pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount]; + for (uint32_t i = 0; i < bufferBindCount; ++i) { + pBufferBinds[i].initialize(©_src->pBufferBinds[i]); + } + } + if (imageOpaqueBindCount && copy_src->pImageOpaqueBinds) { + pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount]; + for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) { + pImageOpaqueBinds[i].initialize(©_src->pImageOpaqueBinds[i]); + } + } + if (imageBindCount && copy_src->pImageBinds) { + pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount]; + for (uint32_t i = 0; i < imageBindCount; ++i) { + pImageBinds[i].initialize(©_src->pImageBinds[i]); + } + } + if (signalSemaphoreCount && copy_src->pSignalSemaphores) { + pSignalSemaphores = new VkSemaphore[signalSemaphoreCount]; + for (uint32_t i = 0; i < signalSemaphoreCount; ++i) { + pSignalSemaphores[i] = copy_src->pSignalSemaphores[i]; + } + } +} + +safe_VkFenceCreateInfo::safe_VkFenceCreateInfo(const VkFenceCreateInfo* 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_VkFenceCreateInfo::safe_VkFenceCreateInfo() : sType(VK_STRUCTURE_TYPE_FENCE_CREATE_INFO), pNext(nullptr), flags() {} + +safe_VkFenceCreateInfo::safe_VkFenceCreateInfo(const safe_VkFenceCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkFenceCreateInfo& safe_VkFenceCreateInfo::operator=(const safe_VkFenceCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkFenceCreateInfo::~safe_VkFenceCreateInfo() { FreePnextChain(pNext); } + +void safe_VkFenceCreateInfo::initialize(const VkFenceCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkFenceCreateInfo::initialize(const safe_VkFenceCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSemaphoreCreateInfo::safe_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo* 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_VkSemaphoreCreateInfo::safe_VkSemaphoreCreateInfo() + : sType(VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO), pNext(nullptr), flags() {} + +safe_VkSemaphoreCreateInfo::safe_VkSemaphoreCreateInfo(const safe_VkSemaphoreCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSemaphoreCreateInfo& safe_VkSemaphoreCreateInfo::operator=(const safe_VkSemaphoreCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSemaphoreCreateInfo::~safe_VkSemaphoreCreateInfo() { FreePnextChain(pNext); } + +void safe_VkSemaphoreCreateInfo::initialize(const VkSemaphoreCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSemaphoreCreateInfo::initialize(const safe_VkSemaphoreCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkEventCreateInfo::safe_VkEventCreateInfo(const VkEventCreateInfo* 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_VkEventCreateInfo::safe_VkEventCreateInfo() : sType(VK_STRUCTURE_TYPE_EVENT_CREATE_INFO), pNext(nullptr), flags() {} + +safe_VkEventCreateInfo::safe_VkEventCreateInfo(const safe_VkEventCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkEventCreateInfo& safe_VkEventCreateInfo::operator=(const safe_VkEventCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkEventCreateInfo::~safe_VkEventCreateInfo() { FreePnextChain(pNext); } + +void safe_VkEventCreateInfo::initialize(const VkEventCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkEventCreateInfo::initialize(const safe_VkEventCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkQueryPoolCreateInfo::safe_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + queryType(in_struct->queryType), + queryCount(in_struct->queryCount), + pipelineStatistics(in_struct->pipelineStatistics) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkQueryPoolCreateInfo::safe_VkQueryPoolCreateInfo() + : sType(VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO), pNext(nullptr), flags(), queryType(), queryCount(), pipelineStatistics() {} + +safe_VkQueryPoolCreateInfo::safe_VkQueryPoolCreateInfo(const safe_VkQueryPoolCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + queryType = copy_src.queryType; + queryCount = copy_src.queryCount; + pipelineStatistics = copy_src.pipelineStatistics; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkQueryPoolCreateInfo& safe_VkQueryPoolCreateInfo::operator=(const safe_VkQueryPoolCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + queryType = copy_src.queryType; + queryCount = copy_src.queryCount; + pipelineStatistics = copy_src.pipelineStatistics; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkQueryPoolCreateInfo::~safe_VkQueryPoolCreateInfo() { FreePnextChain(pNext); } + +void safe_VkQueryPoolCreateInfo::initialize(const VkQueryPoolCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + queryType = in_struct->queryType; + queryCount = in_struct->queryCount; + pipelineStatistics = in_struct->pipelineStatistics; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkQueryPoolCreateInfo::initialize(const safe_VkQueryPoolCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + queryType = copy_src->queryType; + queryCount = copy_src->queryCount; + pipelineStatistics = copy_src->pipelineStatistics; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBufferCreateInfo::safe_VkBufferCreateInfo(const VkBufferCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + size(in_struct->size), + usage(in_struct->usage), + sharingMode(in_struct->sharingMode), + queueFamilyIndexCount(0), + pQueueFamilyIndices(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices, + sizeof(uint32_t) * in_struct->queueFamilyIndexCount); + queueFamilyIndexCount = in_struct->queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +safe_VkBufferCreateInfo::safe_VkBufferCreateInfo() + : sType(VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO), + pNext(nullptr), + flags(), + size(), + usage(), + sharingMode(), + queueFamilyIndexCount(), + pQueueFamilyIndices(nullptr) {} + +safe_VkBufferCreateInfo::safe_VkBufferCreateInfo(const safe_VkBufferCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + size = copy_src.size; + usage = copy_src.usage; + sharingMode = copy_src.sharingMode; + pQueueFamilyIndices = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount); + queueFamilyIndexCount = copy_src.queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +safe_VkBufferCreateInfo& safe_VkBufferCreateInfo::operator=(const safe_VkBufferCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pQueueFamilyIndices) delete[] pQueueFamilyIndices; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + size = copy_src.size; + usage = copy_src.usage; + sharingMode = copy_src.sharingMode; + pQueueFamilyIndices = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount); + queueFamilyIndexCount = copy_src.queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } + + return *this; +} + +safe_VkBufferCreateInfo::~safe_VkBufferCreateInfo() { + if (pQueueFamilyIndices) delete[] pQueueFamilyIndices; + FreePnextChain(pNext); +} + +void safe_VkBufferCreateInfo::initialize(const VkBufferCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pQueueFamilyIndices) delete[] pQueueFamilyIndices; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + size = in_struct->size; + usage = in_struct->usage; + sharingMode = in_struct->sharingMode; + pQueueFamilyIndices = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices, + sizeof(uint32_t) * in_struct->queueFamilyIndexCount); + queueFamilyIndexCount = in_struct->queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +void safe_VkBufferCreateInfo::initialize(const safe_VkBufferCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + size = copy_src->size; + usage = copy_src->usage; + sharingMode = copy_src->sharingMode; + pQueueFamilyIndices = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if ((copy_src->sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src->pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[copy_src->queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)copy_src->pQueueFamilyIndices, + sizeof(uint32_t) * copy_src->queueFamilyIndexCount); + queueFamilyIndexCount = copy_src->queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo(const VkBufferViewCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + buffer(in_struct->buffer), + format(in_struct->format), + offset(in_struct->offset), + range(in_struct->range) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo() + : sType(VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO), pNext(nullptr), flags(), buffer(), format(), offset(), range() {} + +safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo(const safe_VkBufferViewCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + buffer = copy_src.buffer; + format = copy_src.format; + offset = copy_src.offset; + range = copy_src.range; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBufferViewCreateInfo& safe_VkBufferViewCreateInfo::operator=(const safe_VkBufferViewCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + buffer = copy_src.buffer; + format = copy_src.format; + offset = copy_src.offset; + range = copy_src.range; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBufferViewCreateInfo::~safe_VkBufferViewCreateInfo() { FreePnextChain(pNext); } + +void safe_VkBufferViewCreateInfo::initialize(const VkBufferViewCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + buffer = in_struct->buffer; + format = in_struct->format; + offset = in_struct->offset; + range = in_struct->range; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBufferViewCreateInfo::initialize(const safe_VkBufferViewCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + buffer = copy_src->buffer; + format = copy_src->format; + offset = copy_src->offset; + range = copy_src->range; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImageCreateInfo::safe_VkImageCreateInfo(const VkImageCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + imageType(in_struct->imageType), + format(in_struct->format), + extent(in_struct->extent), + mipLevels(in_struct->mipLevels), + arrayLayers(in_struct->arrayLayers), + samples(in_struct->samples), + tiling(in_struct->tiling), + usage(in_struct->usage), + sharingMode(in_struct->sharingMode), + queueFamilyIndexCount(0), + pQueueFamilyIndices(nullptr), + initialLayout(in_struct->initialLayout) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices, + sizeof(uint32_t) * in_struct->queueFamilyIndexCount); + queueFamilyIndexCount = in_struct->queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +safe_VkImageCreateInfo::safe_VkImageCreateInfo() + : sType(VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO), + pNext(nullptr), + flags(), + imageType(), + format(), + extent(), + mipLevels(), + arrayLayers(), + samples(), + tiling(), + usage(), + sharingMode(), + queueFamilyIndexCount(), + pQueueFamilyIndices(nullptr), + initialLayout() {} + +safe_VkImageCreateInfo::safe_VkImageCreateInfo(const safe_VkImageCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + imageType = copy_src.imageType; + format = copy_src.format; + extent = copy_src.extent; + mipLevels = copy_src.mipLevels; + arrayLayers = copy_src.arrayLayers; + samples = copy_src.samples; + tiling = copy_src.tiling; + usage = copy_src.usage; + sharingMode = copy_src.sharingMode; + pQueueFamilyIndices = nullptr; + initialLayout = copy_src.initialLayout; + pNext = SafePnextCopy(copy_src.pNext); + + if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount); + queueFamilyIndexCount = copy_src.queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +safe_VkImageCreateInfo& safe_VkImageCreateInfo::operator=(const safe_VkImageCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pQueueFamilyIndices) delete[] pQueueFamilyIndices; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + imageType = copy_src.imageType; + format = copy_src.format; + extent = copy_src.extent; + mipLevels = copy_src.mipLevels; + arrayLayers = copy_src.arrayLayers; + samples = copy_src.samples; + tiling = copy_src.tiling; + usage = copy_src.usage; + sharingMode = copy_src.sharingMode; + pQueueFamilyIndices = nullptr; + initialLayout = copy_src.initialLayout; + pNext = SafePnextCopy(copy_src.pNext); + + if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount); + queueFamilyIndexCount = copy_src.queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } + + return *this; +} + +safe_VkImageCreateInfo::~safe_VkImageCreateInfo() { + if (pQueueFamilyIndices) delete[] pQueueFamilyIndices; + FreePnextChain(pNext); +} + +void safe_VkImageCreateInfo::initialize(const VkImageCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pQueueFamilyIndices) delete[] pQueueFamilyIndices; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + imageType = in_struct->imageType; + format = in_struct->format; + extent = in_struct->extent; + mipLevels = in_struct->mipLevels; + arrayLayers = in_struct->arrayLayers; + samples = in_struct->samples; + tiling = in_struct->tiling; + usage = in_struct->usage; + sharingMode = in_struct->sharingMode; + pQueueFamilyIndices = nullptr; + initialLayout = in_struct->initialLayout; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices, + sizeof(uint32_t) * in_struct->queueFamilyIndexCount); + queueFamilyIndexCount = in_struct->queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +void safe_VkImageCreateInfo::initialize(const safe_VkImageCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + imageType = copy_src->imageType; + format = copy_src->format; + extent = copy_src->extent; + mipLevels = copy_src->mipLevels; + arrayLayers = copy_src->arrayLayers; + samples = copy_src->samples; + tiling = copy_src->tiling; + usage = copy_src->usage; + sharingMode = copy_src->sharingMode; + pQueueFamilyIndices = nullptr; + initialLayout = copy_src->initialLayout; + pNext = SafePnextCopy(copy_src->pNext); + + if ((copy_src->sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src->pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[copy_src->queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)copy_src->pQueueFamilyIndices, + sizeof(uint32_t) * copy_src->queueFamilyIndexCount); + queueFamilyIndexCount = copy_src->queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +safe_VkImageViewCreateInfo::safe_VkImageViewCreateInfo(const VkImageViewCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + image(in_struct->image), + viewType(in_struct->viewType), + format(in_struct->format), + components(in_struct->components), + subresourceRange(in_struct->subresourceRange) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageViewCreateInfo::safe_VkImageViewCreateInfo() + : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO), + pNext(nullptr), + flags(), + image(), + viewType(), + format(), + components(), + subresourceRange() {} + +safe_VkImageViewCreateInfo::safe_VkImageViewCreateInfo(const safe_VkImageViewCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + image = copy_src.image; + viewType = copy_src.viewType; + format = copy_src.format; + components = copy_src.components; + subresourceRange = copy_src.subresourceRange; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageViewCreateInfo& safe_VkImageViewCreateInfo::operator=(const safe_VkImageViewCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + image = copy_src.image; + viewType = copy_src.viewType; + format = copy_src.format; + components = copy_src.components; + subresourceRange = copy_src.subresourceRange; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageViewCreateInfo::~safe_VkImageViewCreateInfo() { FreePnextChain(pNext); } + +void safe_VkImageViewCreateInfo::initialize(const VkImageViewCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + image = in_struct->image; + viewType = in_struct->viewType; + format = in_struct->format; + components = in_struct->components; + subresourceRange = in_struct->subresourceRange; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageViewCreateInfo::initialize(const safe_VkImageViewCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + image = copy_src->image; + viewType = copy_src->viewType; + format = copy_src->format; + components = copy_src->components; + subresourceRange = copy_src->subresourceRange; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), codeSize(in_struct->codeSize), pCode(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pCode) { + pCode = reinterpret_cast(new uint8_t[codeSize]); + memcpy((void*)pCode, (void*)in_struct->pCode, codeSize); + } +} + +safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo() + : sType(VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO), pNext(nullptr), flags(), codeSize(), pCode(nullptr) {} + +safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo(const safe_VkShaderModuleCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + codeSize = copy_src.codeSize; + pCode = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pCode) { + pCode = reinterpret_cast(new uint8_t[codeSize]); + memcpy((void*)pCode, (void*)copy_src.pCode, codeSize); + } +} + +safe_VkShaderModuleCreateInfo& safe_VkShaderModuleCreateInfo::operator=(const safe_VkShaderModuleCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pCode) delete[] reinterpret_cast(pCode); + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + codeSize = copy_src.codeSize; + pCode = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pCode) { + pCode = reinterpret_cast(new uint8_t[codeSize]); + memcpy((void*)pCode, (void*)copy_src.pCode, codeSize); + } + + return *this; +} + +safe_VkShaderModuleCreateInfo::~safe_VkShaderModuleCreateInfo() { + if (pCode) delete[] reinterpret_cast(pCode); + FreePnextChain(pNext); +} + +void safe_VkShaderModuleCreateInfo::initialize(const VkShaderModuleCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pCode) delete[] reinterpret_cast(pCode); + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + codeSize = in_struct->codeSize; + pCode = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pCode) { + pCode = reinterpret_cast(new uint8_t[codeSize]); + memcpy((void*)pCode, (void*)in_struct->pCode, codeSize); + } +} + +void safe_VkShaderModuleCreateInfo::initialize(const safe_VkShaderModuleCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + codeSize = copy_src->codeSize; + pCode = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pCode) { + pCode = reinterpret_cast(new uint8_t[codeSize]); + memcpy((void*)pCode, (void*)copy_src->pCode, codeSize); + } +} + +safe_VkPipelineCacheCreateInfo::safe_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + initialDataSize(in_struct->initialDataSize), + pInitialData(in_struct->pInitialData) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineCacheCreateInfo::safe_VkPipelineCacheCreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO), pNext(nullptr), flags(), initialDataSize(), pInitialData(nullptr) {} + +safe_VkPipelineCacheCreateInfo::safe_VkPipelineCacheCreateInfo(const safe_VkPipelineCacheCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + initialDataSize = copy_src.initialDataSize; + pInitialData = copy_src.pInitialData; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineCacheCreateInfo& safe_VkPipelineCacheCreateInfo::operator=(const safe_VkPipelineCacheCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + initialDataSize = copy_src.initialDataSize; + pInitialData = copy_src.pInitialData; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineCacheCreateInfo::~safe_VkPipelineCacheCreateInfo() { FreePnextChain(pNext); } + +void safe_VkPipelineCacheCreateInfo::initialize(const VkPipelineCacheCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + initialDataSize = in_struct->initialDataSize; + pInitialData = in_struct->pInitialData; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineCacheCreateInfo::initialize(const safe_VkPipelineCacheCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + initialDataSize = copy_src->initialDataSize; + pInitialData = copy_src->pInitialData; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSpecializationInfo::safe_VkSpecializationInfo(const VkSpecializationInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) + : mapEntryCount(in_struct->mapEntryCount), pMapEntries(nullptr), dataSize(in_struct->dataSize), pData(nullptr) { + if (in_struct->pMapEntries) { + pMapEntries = new VkSpecializationMapEntry[in_struct->mapEntryCount]; + memcpy((void*)pMapEntries, (void*)in_struct->pMapEntries, sizeof(VkSpecializationMapEntry) * in_struct->mapEntryCount); + } + + 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_VkSpecializationInfo::safe_VkSpecializationInfo() : mapEntryCount(), pMapEntries(nullptr), dataSize(), pData(nullptr) {} + +safe_VkSpecializationInfo::safe_VkSpecializationInfo(const safe_VkSpecializationInfo& copy_src) { + mapEntryCount = copy_src.mapEntryCount; + pMapEntries = nullptr; + dataSize = copy_src.dataSize; + + if (copy_src.pMapEntries) { + pMapEntries = new VkSpecializationMapEntry[copy_src.mapEntryCount]; + memcpy((void*)pMapEntries, (void*)copy_src.pMapEntries, sizeof(VkSpecializationMapEntry) * copy_src.mapEntryCount); + } + + 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_VkSpecializationInfo& safe_VkSpecializationInfo::operator=(const safe_VkSpecializationInfo& copy_src) { + if (©_src == this) return *this; + + if (pMapEntries) delete[] pMapEntries; + + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + + mapEntryCount = copy_src.mapEntryCount; + pMapEntries = nullptr; + dataSize = copy_src.dataSize; + + if (copy_src.pMapEntries) { + pMapEntries = new VkSpecializationMapEntry[copy_src.mapEntryCount]; + memcpy((void*)pMapEntries, (void*)copy_src.pMapEntries, sizeof(VkSpecializationMapEntry) * copy_src.mapEntryCount); + } + + 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_VkSpecializationInfo::~safe_VkSpecializationInfo() { + if (pMapEntries) delete[] pMapEntries; + + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } +} + +void safe_VkSpecializationInfo::initialize(const VkSpecializationInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pMapEntries) delete[] pMapEntries; + + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + mapEntryCount = in_struct->mapEntryCount; + pMapEntries = nullptr; + dataSize = in_struct->dataSize; + + if (in_struct->pMapEntries) { + pMapEntries = new VkSpecializationMapEntry[in_struct->mapEntryCount]; + memcpy((void*)pMapEntries, (void*)in_struct->pMapEntries, sizeof(VkSpecializationMapEntry) * in_struct->mapEntryCount); + } + + 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_VkSpecializationInfo::initialize(const safe_VkSpecializationInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + mapEntryCount = copy_src->mapEntryCount; + pMapEntries = nullptr; + dataSize = copy_src->dataSize; + + if (copy_src->pMapEntries) { + pMapEntries = new VkSpecializationMapEntry[copy_src->mapEntryCount]; + memcpy((void*)pMapEntries, (void*)copy_src->pMapEntries, sizeof(VkSpecializationMapEntry) * copy_src->mapEntryCount); + } + + 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_VkPipelineShaderStageCreateInfo::safe_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + stage(in_struct->stage), + module(in_struct->module), + pSpecializationInfo(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + pName = SafeStringCopy(in_struct->pName); + if (in_struct->pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(in_struct->pSpecializationInfo); +} + +safe_VkPipelineShaderStageCreateInfo::safe_VkPipelineShaderStageCreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO), + pNext(nullptr), + flags(), + stage(), + module(), + pName(nullptr), + pSpecializationInfo(nullptr) {} + +safe_VkPipelineShaderStageCreateInfo::safe_VkPipelineShaderStageCreateInfo(const safe_VkPipelineShaderStageCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + stage = copy_src.stage; + module = copy_src.module; + pSpecializationInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + pName = SafeStringCopy(copy_src.pName); + if (copy_src.pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(*copy_src.pSpecializationInfo); +} + +safe_VkPipelineShaderStageCreateInfo& safe_VkPipelineShaderStageCreateInfo::operator=( + const safe_VkPipelineShaderStageCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pName) delete[] pName; + if (pSpecializationInfo) delete pSpecializationInfo; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + stage = copy_src.stage; + module = copy_src.module; + pSpecializationInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + pName = SafeStringCopy(copy_src.pName); + if (copy_src.pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(*copy_src.pSpecializationInfo); + + return *this; +} + +safe_VkPipelineShaderStageCreateInfo::~safe_VkPipelineShaderStageCreateInfo() { + if (pName) delete[] pName; + if (pSpecializationInfo) delete pSpecializationInfo; + FreePnextChain(pNext); +} + +void safe_VkPipelineShaderStageCreateInfo::initialize(const VkPipelineShaderStageCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pName) delete[] pName; + if (pSpecializationInfo) delete pSpecializationInfo; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + stage = in_struct->stage; + module = in_struct->module; + pSpecializationInfo = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + pName = SafeStringCopy(in_struct->pName); + if (in_struct->pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(in_struct->pSpecializationInfo); +} + +void safe_VkPipelineShaderStageCreateInfo::initialize(const safe_VkPipelineShaderStageCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + stage = copy_src->stage; + module = copy_src->module; + pSpecializationInfo = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + pName = SafeStringCopy(copy_src->pName); + if (copy_src->pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(*copy_src->pSpecializationInfo); +} + +safe_VkComputePipelineCreateInfo::safe_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + stage(&in_struct->stage), + layout(in_struct->layout), + basePipelineHandle(in_struct->basePipelineHandle), + basePipelineIndex(in_struct->basePipelineIndex) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkComputePipelineCreateInfo::safe_VkComputePipelineCreateInfo() + : sType(VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO), + pNext(nullptr), + flags(), + layout(), + basePipelineHandle(), + basePipelineIndex() {} + +safe_VkComputePipelineCreateInfo::safe_VkComputePipelineCreateInfo(const safe_VkComputePipelineCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + stage.initialize(©_src.stage); + layout = copy_src.layout; + basePipelineHandle = copy_src.basePipelineHandle; + basePipelineIndex = copy_src.basePipelineIndex; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkComputePipelineCreateInfo& safe_VkComputePipelineCreateInfo::operator=(const safe_VkComputePipelineCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + stage.initialize(©_src.stage); + layout = copy_src.layout; + basePipelineHandle = copy_src.basePipelineHandle; + basePipelineIndex = copy_src.basePipelineIndex; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkComputePipelineCreateInfo::~safe_VkComputePipelineCreateInfo() { FreePnextChain(pNext); } + +void safe_VkComputePipelineCreateInfo::initialize(const VkComputePipelineCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + stage.initialize(&in_struct->stage); + layout = in_struct->layout; + basePipelineHandle = in_struct->basePipelineHandle; + basePipelineIndex = in_struct->basePipelineIndex; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkComputePipelineCreateInfo::initialize(const safe_VkComputePipelineCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + stage.initialize(©_src->stage); + layout = copy_src->layout; + basePipelineHandle = copy_src->basePipelineHandle; + basePipelineIndex = copy_src->basePipelineIndex; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo( + const VkPipelineVertexInputStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + vertexBindingDescriptionCount(in_struct->vertexBindingDescriptionCount), + pVertexBindingDescriptions(nullptr), + vertexAttributeDescriptionCount(in_struct->vertexAttributeDescriptionCount), + pVertexAttributeDescriptions(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pVertexBindingDescriptions) { + pVertexBindingDescriptions = new VkVertexInputBindingDescription[in_struct->vertexBindingDescriptionCount]; + memcpy((void*)pVertexBindingDescriptions, (void*)in_struct->pVertexBindingDescriptions, + sizeof(VkVertexInputBindingDescription) * in_struct->vertexBindingDescriptionCount); + } + + if (in_struct->pVertexAttributeDescriptions) { + pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[in_struct->vertexAttributeDescriptionCount]; + memcpy((void*)pVertexAttributeDescriptions, (void*)in_struct->pVertexAttributeDescriptions, + sizeof(VkVertexInputAttributeDescription) * in_struct->vertexAttributeDescriptionCount); + } +} + +safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO), + pNext(nullptr), + flags(), + vertexBindingDescriptionCount(), + pVertexBindingDescriptions(nullptr), + vertexAttributeDescriptionCount(), + pVertexAttributeDescriptions(nullptr) {} + +safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo( + const safe_VkPipelineVertexInputStateCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + vertexBindingDescriptionCount = copy_src.vertexBindingDescriptionCount; + pVertexBindingDescriptions = nullptr; + vertexAttributeDescriptionCount = copy_src.vertexAttributeDescriptionCount; + pVertexAttributeDescriptions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pVertexBindingDescriptions) { + pVertexBindingDescriptions = new VkVertexInputBindingDescription[copy_src.vertexBindingDescriptionCount]; + memcpy((void*)pVertexBindingDescriptions, (void*)copy_src.pVertexBindingDescriptions, + sizeof(VkVertexInputBindingDescription) * copy_src.vertexBindingDescriptionCount); + } + + if (copy_src.pVertexAttributeDescriptions) { + pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[copy_src.vertexAttributeDescriptionCount]; + memcpy((void*)pVertexAttributeDescriptions, (void*)copy_src.pVertexAttributeDescriptions, + sizeof(VkVertexInputAttributeDescription) * copy_src.vertexAttributeDescriptionCount); + } +} + +safe_VkPipelineVertexInputStateCreateInfo& safe_VkPipelineVertexInputStateCreateInfo::operator=( + const safe_VkPipelineVertexInputStateCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pVertexBindingDescriptions) delete[] pVertexBindingDescriptions; + if (pVertexAttributeDescriptions) delete[] pVertexAttributeDescriptions; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + vertexBindingDescriptionCount = copy_src.vertexBindingDescriptionCount; + pVertexBindingDescriptions = nullptr; + vertexAttributeDescriptionCount = copy_src.vertexAttributeDescriptionCount; + pVertexAttributeDescriptions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pVertexBindingDescriptions) { + pVertexBindingDescriptions = new VkVertexInputBindingDescription[copy_src.vertexBindingDescriptionCount]; + memcpy((void*)pVertexBindingDescriptions, (void*)copy_src.pVertexBindingDescriptions, + sizeof(VkVertexInputBindingDescription) * copy_src.vertexBindingDescriptionCount); + } + + if (copy_src.pVertexAttributeDescriptions) { + pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[copy_src.vertexAttributeDescriptionCount]; + memcpy((void*)pVertexAttributeDescriptions, (void*)copy_src.pVertexAttributeDescriptions, + sizeof(VkVertexInputAttributeDescription) * copy_src.vertexAttributeDescriptionCount); + } + + return *this; +} + +safe_VkPipelineVertexInputStateCreateInfo::~safe_VkPipelineVertexInputStateCreateInfo() { + if (pVertexBindingDescriptions) delete[] pVertexBindingDescriptions; + if (pVertexAttributeDescriptions) delete[] pVertexAttributeDescriptions; + FreePnextChain(pNext); +} + +void safe_VkPipelineVertexInputStateCreateInfo::initialize(const VkPipelineVertexInputStateCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pVertexBindingDescriptions) delete[] pVertexBindingDescriptions; + if (pVertexAttributeDescriptions) delete[] pVertexAttributeDescriptions; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + vertexBindingDescriptionCount = in_struct->vertexBindingDescriptionCount; + pVertexBindingDescriptions = nullptr; + vertexAttributeDescriptionCount = in_struct->vertexAttributeDescriptionCount; + pVertexAttributeDescriptions = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pVertexBindingDescriptions) { + pVertexBindingDescriptions = new VkVertexInputBindingDescription[in_struct->vertexBindingDescriptionCount]; + memcpy((void*)pVertexBindingDescriptions, (void*)in_struct->pVertexBindingDescriptions, + sizeof(VkVertexInputBindingDescription) * in_struct->vertexBindingDescriptionCount); + } + + if (in_struct->pVertexAttributeDescriptions) { + pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[in_struct->vertexAttributeDescriptionCount]; + memcpy((void*)pVertexAttributeDescriptions, (void*)in_struct->pVertexAttributeDescriptions, + sizeof(VkVertexInputAttributeDescription) * in_struct->vertexAttributeDescriptionCount); + } +} + +void safe_VkPipelineVertexInputStateCreateInfo::initialize(const safe_VkPipelineVertexInputStateCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + vertexBindingDescriptionCount = copy_src->vertexBindingDescriptionCount; + pVertexBindingDescriptions = nullptr; + vertexAttributeDescriptionCount = copy_src->vertexAttributeDescriptionCount; + pVertexAttributeDescriptions = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pVertexBindingDescriptions) { + pVertexBindingDescriptions = new VkVertexInputBindingDescription[copy_src->vertexBindingDescriptionCount]; + memcpy((void*)pVertexBindingDescriptions, (void*)copy_src->pVertexBindingDescriptions, + sizeof(VkVertexInputBindingDescription) * copy_src->vertexBindingDescriptionCount); + } + + if (copy_src->pVertexAttributeDescriptions) { + pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[copy_src->vertexAttributeDescriptionCount]; + memcpy((void*)pVertexAttributeDescriptions, (void*)copy_src->pVertexAttributeDescriptions, + sizeof(VkVertexInputAttributeDescription) * copy_src->vertexAttributeDescriptionCount); + } +} + +safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo( + const VkPipelineInputAssemblyStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + topology(in_struct->topology), + primitiveRestartEnable(in_struct->primitiveRestartEnable) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO), + pNext(nullptr), + flags(), + topology(), + primitiveRestartEnable() {} + +safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo( + const safe_VkPipelineInputAssemblyStateCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + topology = copy_src.topology; + primitiveRestartEnable = copy_src.primitiveRestartEnable; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineInputAssemblyStateCreateInfo& safe_VkPipelineInputAssemblyStateCreateInfo::operator=( + const safe_VkPipelineInputAssemblyStateCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + topology = copy_src.topology; + primitiveRestartEnable = copy_src.primitiveRestartEnable; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineInputAssemblyStateCreateInfo::~safe_VkPipelineInputAssemblyStateCreateInfo() { FreePnextChain(pNext); } + +void safe_VkPipelineInputAssemblyStateCreateInfo::initialize(const VkPipelineInputAssemblyStateCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + topology = in_struct->topology; + primitiveRestartEnable = in_struct->primitiveRestartEnable; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineInputAssemblyStateCreateInfo::initialize(const safe_VkPipelineInputAssemblyStateCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + topology = copy_src->topology; + primitiveRestartEnable = copy_src->primitiveRestartEnable; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo( + const VkPipelineTessellationStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), patchControlPoints(in_struct->patchControlPoints) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO), pNext(nullptr), flags(), patchControlPoints() {} + +safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo( + const safe_VkPipelineTessellationStateCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + patchControlPoints = copy_src.patchControlPoints; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineTessellationStateCreateInfo& safe_VkPipelineTessellationStateCreateInfo::operator=( + const safe_VkPipelineTessellationStateCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + patchControlPoints = copy_src.patchControlPoints; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineTessellationStateCreateInfo::~safe_VkPipelineTessellationStateCreateInfo() { FreePnextChain(pNext); } + +void safe_VkPipelineTessellationStateCreateInfo::initialize(const VkPipelineTessellationStateCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + patchControlPoints = in_struct->patchControlPoints; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineTessellationStateCreateInfo::initialize(const safe_VkPipelineTessellationStateCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + patchControlPoints = copy_src->patchControlPoints; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo( + const VkPipelineRasterizationStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + depthClampEnable(in_struct->depthClampEnable), + rasterizerDiscardEnable(in_struct->rasterizerDiscardEnable), + polygonMode(in_struct->polygonMode), + cullMode(in_struct->cullMode), + frontFace(in_struct->frontFace), + depthBiasEnable(in_struct->depthBiasEnable), + depthBiasConstantFactor(in_struct->depthBiasConstantFactor), + depthBiasClamp(in_struct->depthBiasClamp), + depthBiasSlopeFactor(in_struct->depthBiasSlopeFactor), + lineWidth(in_struct->lineWidth) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO), + pNext(nullptr), + flags(), + depthClampEnable(), + rasterizerDiscardEnable(), + polygonMode(), + cullMode(), + frontFace(), + depthBiasEnable(), + depthBiasConstantFactor(), + depthBiasClamp(), + depthBiasSlopeFactor(), + lineWidth() {} + +safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo( + const safe_VkPipelineRasterizationStateCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + depthClampEnable = copy_src.depthClampEnable; + rasterizerDiscardEnable = copy_src.rasterizerDiscardEnable; + polygonMode = copy_src.polygonMode; + cullMode = copy_src.cullMode; + frontFace = copy_src.frontFace; + depthBiasEnable = copy_src.depthBiasEnable; + depthBiasConstantFactor = copy_src.depthBiasConstantFactor; + depthBiasClamp = copy_src.depthBiasClamp; + depthBiasSlopeFactor = copy_src.depthBiasSlopeFactor; + lineWidth = copy_src.lineWidth; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineRasterizationStateCreateInfo& safe_VkPipelineRasterizationStateCreateInfo::operator=( + const safe_VkPipelineRasterizationStateCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + depthClampEnable = copy_src.depthClampEnable; + rasterizerDiscardEnable = copy_src.rasterizerDiscardEnable; + polygonMode = copy_src.polygonMode; + cullMode = copy_src.cullMode; + frontFace = copy_src.frontFace; + depthBiasEnable = copy_src.depthBiasEnable; + depthBiasConstantFactor = copy_src.depthBiasConstantFactor; + depthBiasClamp = copy_src.depthBiasClamp; + depthBiasSlopeFactor = copy_src.depthBiasSlopeFactor; + lineWidth = copy_src.lineWidth; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineRasterizationStateCreateInfo::~safe_VkPipelineRasterizationStateCreateInfo() { FreePnextChain(pNext); } + +void safe_VkPipelineRasterizationStateCreateInfo::initialize(const VkPipelineRasterizationStateCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + depthClampEnable = in_struct->depthClampEnable; + rasterizerDiscardEnable = in_struct->rasterizerDiscardEnable; + polygonMode = in_struct->polygonMode; + cullMode = in_struct->cullMode; + frontFace = in_struct->frontFace; + depthBiasEnable = in_struct->depthBiasEnable; + depthBiasConstantFactor = in_struct->depthBiasConstantFactor; + depthBiasClamp = in_struct->depthBiasClamp; + depthBiasSlopeFactor = in_struct->depthBiasSlopeFactor; + lineWidth = in_struct->lineWidth; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineRasterizationStateCreateInfo::initialize(const safe_VkPipelineRasterizationStateCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + depthClampEnable = copy_src->depthClampEnable; + rasterizerDiscardEnable = copy_src->rasterizerDiscardEnable; + polygonMode = copy_src->polygonMode; + cullMode = copy_src->cullMode; + frontFace = copy_src->frontFace; + depthBiasEnable = copy_src->depthBiasEnable; + depthBiasConstantFactor = copy_src->depthBiasConstantFactor; + depthBiasClamp = copy_src->depthBiasClamp; + depthBiasSlopeFactor = copy_src->depthBiasSlopeFactor; + lineWidth = copy_src->lineWidth; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineMultisampleStateCreateInfo::safe_VkPipelineMultisampleStateCreateInfo( + const VkPipelineMultisampleStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + rasterizationSamples(in_struct->rasterizationSamples), + sampleShadingEnable(in_struct->sampleShadingEnable), + minSampleShading(in_struct->minSampleShading), + pSampleMask(nullptr), + alphaToCoverageEnable(in_struct->alphaToCoverageEnable), + alphaToOneEnable(in_struct->alphaToOneEnable) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pSampleMask) { + pSampleMask = new VkSampleMask(*in_struct->pSampleMask); + } +} + +safe_VkPipelineMultisampleStateCreateInfo::safe_VkPipelineMultisampleStateCreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO), + pNext(nullptr), + flags(), + rasterizationSamples(), + sampleShadingEnable(), + minSampleShading(), + pSampleMask(nullptr), + alphaToCoverageEnable(), + alphaToOneEnable() {} + +safe_VkPipelineMultisampleStateCreateInfo::safe_VkPipelineMultisampleStateCreateInfo( + const safe_VkPipelineMultisampleStateCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + rasterizationSamples = copy_src.rasterizationSamples; + sampleShadingEnable = copy_src.sampleShadingEnable; + minSampleShading = copy_src.minSampleShading; + pSampleMask = nullptr; + alphaToCoverageEnable = copy_src.alphaToCoverageEnable; + alphaToOneEnable = copy_src.alphaToOneEnable; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pSampleMask) { + pSampleMask = new VkSampleMask(*copy_src.pSampleMask); + } +} + +safe_VkPipelineMultisampleStateCreateInfo& safe_VkPipelineMultisampleStateCreateInfo::operator=( + const safe_VkPipelineMultisampleStateCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pSampleMask) delete pSampleMask; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + rasterizationSamples = copy_src.rasterizationSamples; + sampleShadingEnable = copy_src.sampleShadingEnable; + minSampleShading = copy_src.minSampleShading; + pSampleMask = nullptr; + alphaToCoverageEnable = copy_src.alphaToCoverageEnable; + alphaToOneEnable = copy_src.alphaToOneEnable; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pSampleMask) { + pSampleMask = new VkSampleMask(*copy_src.pSampleMask); + } + + return *this; +} + +safe_VkPipelineMultisampleStateCreateInfo::~safe_VkPipelineMultisampleStateCreateInfo() { + if (pSampleMask) delete pSampleMask; + FreePnextChain(pNext); +} + +void safe_VkPipelineMultisampleStateCreateInfo::initialize(const VkPipelineMultisampleStateCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pSampleMask) delete pSampleMask; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + rasterizationSamples = in_struct->rasterizationSamples; + sampleShadingEnable = in_struct->sampleShadingEnable; + minSampleShading = in_struct->minSampleShading; + pSampleMask = nullptr; + alphaToCoverageEnable = in_struct->alphaToCoverageEnable; + alphaToOneEnable = in_struct->alphaToOneEnable; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pSampleMask) { + pSampleMask = new VkSampleMask(*in_struct->pSampleMask); + } +} + +void safe_VkPipelineMultisampleStateCreateInfo::initialize(const safe_VkPipelineMultisampleStateCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + rasterizationSamples = copy_src->rasterizationSamples; + sampleShadingEnable = copy_src->sampleShadingEnable; + minSampleShading = copy_src->minSampleShading; + pSampleMask = nullptr; + alphaToCoverageEnable = copy_src->alphaToCoverageEnable; + alphaToOneEnable = copy_src->alphaToOneEnable; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pSampleMask) { + pSampleMask = new VkSampleMask(*copy_src->pSampleMask); + } +} + +safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo( + const VkPipelineDepthStencilStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + depthTestEnable(in_struct->depthTestEnable), + depthWriteEnable(in_struct->depthWriteEnable), + depthCompareOp(in_struct->depthCompareOp), + depthBoundsTestEnable(in_struct->depthBoundsTestEnable), + stencilTestEnable(in_struct->stencilTestEnable), + front(in_struct->front), + back(in_struct->back), + minDepthBounds(in_struct->minDepthBounds), + maxDepthBounds(in_struct->maxDepthBounds) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO), + pNext(nullptr), + flags(), + depthTestEnable(), + depthWriteEnable(), + depthCompareOp(), + depthBoundsTestEnable(), + stencilTestEnable(), + front(), + back(), + minDepthBounds(), + maxDepthBounds() {} + +safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo( + const safe_VkPipelineDepthStencilStateCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + depthTestEnable = copy_src.depthTestEnable; + depthWriteEnable = copy_src.depthWriteEnable; + depthCompareOp = copy_src.depthCompareOp; + depthBoundsTestEnable = copy_src.depthBoundsTestEnable; + stencilTestEnable = copy_src.stencilTestEnable; + front = copy_src.front; + back = copy_src.back; + minDepthBounds = copy_src.minDepthBounds; + maxDepthBounds = copy_src.maxDepthBounds; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineDepthStencilStateCreateInfo& safe_VkPipelineDepthStencilStateCreateInfo::operator=( + const safe_VkPipelineDepthStencilStateCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + depthTestEnable = copy_src.depthTestEnable; + depthWriteEnable = copy_src.depthWriteEnable; + depthCompareOp = copy_src.depthCompareOp; + depthBoundsTestEnable = copy_src.depthBoundsTestEnable; + stencilTestEnable = copy_src.stencilTestEnable; + front = copy_src.front; + back = copy_src.back; + minDepthBounds = copy_src.minDepthBounds; + maxDepthBounds = copy_src.maxDepthBounds; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineDepthStencilStateCreateInfo::~safe_VkPipelineDepthStencilStateCreateInfo() { FreePnextChain(pNext); } + +void safe_VkPipelineDepthStencilStateCreateInfo::initialize(const VkPipelineDepthStencilStateCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + depthTestEnable = in_struct->depthTestEnable; + depthWriteEnable = in_struct->depthWriteEnable; + depthCompareOp = in_struct->depthCompareOp; + depthBoundsTestEnable = in_struct->depthBoundsTestEnable; + stencilTestEnable = in_struct->stencilTestEnable; + front = in_struct->front; + back = in_struct->back; + minDepthBounds = in_struct->minDepthBounds; + maxDepthBounds = in_struct->maxDepthBounds; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineDepthStencilStateCreateInfo::initialize(const safe_VkPipelineDepthStencilStateCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + depthTestEnable = copy_src->depthTestEnable; + depthWriteEnable = copy_src->depthWriteEnable; + depthCompareOp = copy_src->depthCompareOp; + depthBoundsTestEnable = copy_src->depthBoundsTestEnable; + stencilTestEnable = copy_src->stencilTestEnable; + front = copy_src->front; + back = copy_src->back; + minDepthBounds = copy_src->minDepthBounds; + maxDepthBounds = copy_src->maxDepthBounds; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo( + const VkPipelineColorBlendStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + logicOpEnable(in_struct->logicOpEnable), + logicOp(in_struct->logicOp), + attachmentCount(in_struct->attachmentCount), + pAttachments(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pAttachments) { + pAttachments = new VkPipelineColorBlendAttachmentState[in_struct->attachmentCount]; + memcpy((void*)pAttachments, (void*)in_struct->pAttachments, + sizeof(VkPipelineColorBlendAttachmentState) * in_struct->attachmentCount); + } + + for (uint32_t i = 0; i < 4; ++i) { + blendConstants[i] = in_struct->blendConstants[i]; + } +} + +safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO), + pNext(nullptr), + flags(), + logicOpEnable(), + logicOp(), + attachmentCount(), + pAttachments(nullptr) {} + +safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo( + const safe_VkPipelineColorBlendStateCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + logicOpEnable = copy_src.logicOpEnable; + logicOp = copy_src.logicOp; + attachmentCount = copy_src.attachmentCount; + pAttachments = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pAttachments) { + pAttachments = new VkPipelineColorBlendAttachmentState[copy_src.attachmentCount]; + memcpy((void*)pAttachments, (void*)copy_src.pAttachments, + sizeof(VkPipelineColorBlendAttachmentState) * copy_src.attachmentCount); + } + + for (uint32_t i = 0; i < 4; ++i) { + blendConstants[i] = copy_src.blendConstants[i]; + } +} + +safe_VkPipelineColorBlendStateCreateInfo& safe_VkPipelineColorBlendStateCreateInfo::operator=( + const safe_VkPipelineColorBlendStateCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pAttachments) delete[] pAttachments; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + logicOpEnable = copy_src.logicOpEnable; + logicOp = copy_src.logicOp; + attachmentCount = copy_src.attachmentCount; + pAttachments = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pAttachments) { + pAttachments = new VkPipelineColorBlendAttachmentState[copy_src.attachmentCount]; + memcpy((void*)pAttachments, (void*)copy_src.pAttachments, + sizeof(VkPipelineColorBlendAttachmentState) * copy_src.attachmentCount); + } + + for (uint32_t i = 0; i < 4; ++i) { + blendConstants[i] = copy_src.blendConstants[i]; + } + + return *this; +} + +safe_VkPipelineColorBlendStateCreateInfo::~safe_VkPipelineColorBlendStateCreateInfo() { + if (pAttachments) delete[] pAttachments; + FreePnextChain(pNext); +} + +void safe_VkPipelineColorBlendStateCreateInfo::initialize(const VkPipelineColorBlendStateCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pAttachments) delete[] pAttachments; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + logicOpEnable = in_struct->logicOpEnable; + logicOp = in_struct->logicOp; + attachmentCount = in_struct->attachmentCount; + pAttachments = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pAttachments) { + pAttachments = new VkPipelineColorBlendAttachmentState[in_struct->attachmentCount]; + memcpy((void*)pAttachments, (void*)in_struct->pAttachments, + sizeof(VkPipelineColorBlendAttachmentState) * in_struct->attachmentCount); + } + + for (uint32_t i = 0; i < 4; ++i) { + blendConstants[i] = in_struct->blendConstants[i]; + } +} + +void safe_VkPipelineColorBlendStateCreateInfo::initialize(const safe_VkPipelineColorBlendStateCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + logicOpEnable = copy_src->logicOpEnable; + logicOp = copy_src->logicOp; + attachmentCount = copy_src->attachmentCount; + pAttachments = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pAttachments) { + pAttachments = new VkPipelineColorBlendAttachmentState[copy_src->attachmentCount]; + memcpy((void*)pAttachments, (void*)copy_src->pAttachments, + sizeof(VkPipelineColorBlendAttachmentState) * copy_src->attachmentCount); + } + + for (uint32_t i = 0; i < 4; ++i) { + blendConstants[i] = copy_src->blendConstants[i]; + } +} + +safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), dynamicStateCount(in_struct->dynamicStateCount), pDynamicStates(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pDynamicStates) { + pDynamicStates = new VkDynamicState[in_struct->dynamicStateCount]; + memcpy((void*)pDynamicStates, (void*)in_struct->pDynamicStates, sizeof(VkDynamicState) * in_struct->dynamicStateCount); + } +} + +safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO), + pNext(nullptr), + flags(), + dynamicStateCount(), + pDynamicStates(nullptr) {} + +safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo( + const safe_VkPipelineDynamicStateCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + dynamicStateCount = copy_src.dynamicStateCount; + pDynamicStates = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDynamicStates) { + pDynamicStates = new VkDynamicState[copy_src.dynamicStateCount]; + memcpy((void*)pDynamicStates, (void*)copy_src.pDynamicStates, sizeof(VkDynamicState) * copy_src.dynamicStateCount); + } +} + +safe_VkPipelineDynamicStateCreateInfo& safe_VkPipelineDynamicStateCreateInfo::operator=( + const safe_VkPipelineDynamicStateCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pDynamicStates) delete[] pDynamicStates; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + dynamicStateCount = copy_src.dynamicStateCount; + pDynamicStates = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDynamicStates) { + pDynamicStates = new VkDynamicState[copy_src.dynamicStateCount]; + memcpy((void*)pDynamicStates, (void*)copy_src.pDynamicStates, sizeof(VkDynamicState) * copy_src.dynamicStateCount); + } + + return *this; +} + +safe_VkPipelineDynamicStateCreateInfo::~safe_VkPipelineDynamicStateCreateInfo() { + if (pDynamicStates) delete[] pDynamicStates; + FreePnextChain(pNext); +} + +void safe_VkPipelineDynamicStateCreateInfo::initialize(const VkPipelineDynamicStateCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDynamicStates) delete[] pDynamicStates; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + dynamicStateCount = in_struct->dynamicStateCount; + pDynamicStates = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pDynamicStates) { + pDynamicStates = new VkDynamicState[in_struct->dynamicStateCount]; + memcpy((void*)pDynamicStates, (void*)in_struct->pDynamicStates, sizeof(VkDynamicState) * in_struct->dynamicStateCount); + } +} + +void safe_VkPipelineDynamicStateCreateInfo::initialize(const safe_VkPipelineDynamicStateCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + dynamicStateCount = copy_src->dynamicStateCount; + pDynamicStates = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pDynamicStates) { + pDynamicStates = new VkDynamicState[copy_src->dynamicStateCount]; + memcpy((void*)pDynamicStates, (void*)copy_src->pDynamicStates, sizeof(VkDynamicState) * copy_src->dynamicStateCount); + } +} + +safe_VkPipelineLayoutCreateInfo::safe_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + setLayoutCount(in_struct->setLayoutCount), + pSetLayouts(nullptr), + pushConstantRangeCount(in_struct->pushConstantRangeCount), + pPushConstantRanges(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (setLayoutCount && in_struct->pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[setLayoutCount]; + for (uint32_t i = 0; i < setLayoutCount; ++i) { + pSetLayouts[i] = in_struct->pSetLayouts[i]; + } + } + + if (in_struct->pPushConstantRanges) { + pPushConstantRanges = new VkPushConstantRange[in_struct->pushConstantRangeCount]; + memcpy((void*)pPushConstantRanges, (void*)in_struct->pPushConstantRanges, + sizeof(VkPushConstantRange) * in_struct->pushConstantRangeCount); + } +} + +safe_VkPipelineLayoutCreateInfo::safe_VkPipelineLayoutCreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO), + pNext(nullptr), + flags(), + setLayoutCount(), + pSetLayouts(nullptr), + pushConstantRangeCount(), + pPushConstantRanges(nullptr) {} + +safe_VkPipelineLayoutCreateInfo::safe_VkPipelineLayoutCreateInfo(const safe_VkPipelineLayoutCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + setLayoutCount = copy_src.setLayoutCount; + pSetLayouts = nullptr; + pushConstantRangeCount = copy_src.pushConstantRangeCount; + pPushConstantRanges = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (setLayoutCount && copy_src.pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[setLayoutCount]; + for (uint32_t i = 0; i < setLayoutCount; ++i) { + pSetLayouts[i] = copy_src.pSetLayouts[i]; + } + } + + if (copy_src.pPushConstantRanges) { + pPushConstantRanges = new VkPushConstantRange[copy_src.pushConstantRangeCount]; + memcpy((void*)pPushConstantRanges, (void*)copy_src.pPushConstantRanges, + sizeof(VkPushConstantRange) * copy_src.pushConstantRangeCount); + } +} + +safe_VkPipelineLayoutCreateInfo& safe_VkPipelineLayoutCreateInfo::operator=(const safe_VkPipelineLayoutCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pSetLayouts) delete[] pSetLayouts; + if (pPushConstantRanges) delete[] pPushConstantRanges; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + setLayoutCount = copy_src.setLayoutCount; + pSetLayouts = nullptr; + pushConstantRangeCount = copy_src.pushConstantRangeCount; + pPushConstantRanges = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (setLayoutCount && copy_src.pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[setLayoutCount]; + for (uint32_t i = 0; i < setLayoutCount; ++i) { + pSetLayouts[i] = copy_src.pSetLayouts[i]; + } + } + + if (copy_src.pPushConstantRanges) { + pPushConstantRanges = new VkPushConstantRange[copy_src.pushConstantRangeCount]; + memcpy((void*)pPushConstantRanges, (void*)copy_src.pPushConstantRanges, + sizeof(VkPushConstantRange) * copy_src.pushConstantRangeCount); + } + + return *this; +} + +safe_VkPipelineLayoutCreateInfo::~safe_VkPipelineLayoutCreateInfo() { + if (pSetLayouts) delete[] pSetLayouts; + if (pPushConstantRanges) delete[] pPushConstantRanges; + FreePnextChain(pNext); +} + +void safe_VkPipelineLayoutCreateInfo::initialize(const VkPipelineLayoutCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pSetLayouts) delete[] pSetLayouts; + if (pPushConstantRanges) delete[] pPushConstantRanges; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + setLayoutCount = in_struct->setLayoutCount; + pSetLayouts = nullptr; + pushConstantRangeCount = in_struct->pushConstantRangeCount; + pPushConstantRanges = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (setLayoutCount && in_struct->pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[setLayoutCount]; + for (uint32_t i = 0; i < setLayoutCount; ++i) { + pSetLayouts[i] = in_struct->pSetLayouts[i]; + } + } + + if (in_struct->pPushConstantRanges) { + pPushConstantRanges = new VkPushConstantRange[in_struct->pushConstantRangeCount]; + memcpy((void*)pPushConstantRanges, (void*)in_struct->pPushConstantRanges, + sizeof(VkPushConstantRange) * in_struct->pushConstantRangeCount); + } +} + +void safe_VkPipelineLayoutCreateInfo::initialize(const safe_VkPipelineLayoutCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + setLayoutCount = copy_src->setLayoutCount; + pSetLayouts = nullptr; + pushConstantRangeCount = copy_src->pushConstantRangeCount; + pPushConstantRanges = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (setLayoutCount && copy_src->pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[setLayoutCount]; + for (uint32_t i = 0; i < setLayoutCount; ++i) { + pSetLayouts[i] = copy_src->pSetLayouts[i]; + } + } + + if (copy_src->pPushConstantRanges) { + pPushConstantRanges = new VkPushConstantRange[copy_src->pushConstantRangeCount]; + memcpy((void*)pPushConstantRanges, (void*)copy_src->pPushConstantRanges, + sizeof(VkPushConstantRange) * copy_src->pushConstantRangeCount); + } +} + +safe_VkSamplerCreateInfo::safe_VkSamplerCreateInfo(const VkSamplerCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + magFilter(in_struct->magFilter), + minFilter(in_struct->minFilter), + mipmapMode(in_struct->mipmapMode), + addressModeU(in_struct->addressModeU), + addressModeV(in_struct->addressModeV), + addressModeW(in_struct->addressModeW), + mipLodBias(in_struct->mipLodBias), + anisotropyEnable(in_struct->anisotropyEnable), + maxAnisotropy(in_struct->maxAnisotropy), + compareEnable(in_struct->compareEnable), + compareOp(in_struct->compareOp), + minLod(in_struct->minLod), + maxLod(in_struct->maxLod), + borderColor(in_struct->borderColor), + unnormalizedCoordinates(in_struct->unnormalizedCoordinates) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSamplerCreateInfo::safe_VkSamplerCreateInfo() + : sType(VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO), + pNext(nullptr), + flags(), + magFilter(), + minFilter(), + mipmapMode(), + addressModeU(), + addressModeV(), + addressModeW(), + mipLodBias(), + anisotropyEnable(), + maxAnisotropy(), + compareEnable(), + compareOp(), + minLod(), + maxLod(), + borderColor(), + unnormalizedCoordinates() {} + +safe_VkSamplerCreateInfo::safe_VkSamplerCreateInfo(const safe_VkSamplerCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + magFilter = copy_src.magFilter; + minFilter = copy_src.minFilter; + mipmapMode = copy_src.mipmapMode; + addressModeU = copy_src.addressModeU; + addressModeV = copy_src.addressModeV; + addressModeW = copy_src.addressModeW; + mipLodBias = copy_src.mipLodBias; + anisotropyEnable = copy_src.anisotropyEnable; + maxAnisotropy = copy_src.maxAnisotropy; + compareEnable = copy_src.compareEnable; + compareOp = copy_src.compareOp; + minLod = copy_src.minLod; + maxLod = copy_src.maxLod; + borderColor = copy_src.borderColor; + unnormalizedCoordinates = copy_src.unnormalizedCoordinates; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSamplerCreateInfo& safe_VkSamplerCreateInfo::operator=(const safe_VkSamplerCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + magFilter = copy_src.magFilter; + minFilter = copy_src.minFilter; + mipmapMode = copy_src.mipmapMode; + addressModeU = copy_src.addressModeU; + addressModeV = copy_src.addressModeV; + addressModeW = copy_src.addressModeW; + mipLodBias = copy_src.mipLodBias; + anisotropyEnable = copy_src.anisotropyEnable; + maxAnisotropy = copy_src.maxAnisotropy; + compareEnable = copy_src.compareEnable; + compareOp = copy_src.compareOp; + minLod = copy_src.minLod; + maxLod = copy_src.maxLod; + borderColor = copy_src.borderColor; + unnormalizedCoordinates = copy_src.unnormalizedCoordinates; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSamplerCreateInfo::~safe_VkSamplerCreateInfo() { FreePnextChain(pNext); } + +void safe_VkSamplerCreateInfo::initialize(const VkSamplerCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + magFilter = in_struct->magFilter; + minFilter = in_struct->minFilter; + mipmapMode = in_struct->mipmapMode; + addressModeU = in_struct->addressModeU; + addressModeV = in_struct->addressModeV; + addressModeW = in_struct->addressModeW; + mipLodBias = in_struct->mipLodBias; + anisotropyEnable = in_struct->anisotropyEnable; + maxAnisotropy = in_struct->maxAnisotropy; + compareEnable = in_struct->compareEnable; + compareOp = in_struct->compareOp; + minLod = in_struct->minLod; + maxLod = in_struct->maxLod; + borderColor = in_struct->borderColor; + unnormalizedCoordinates = in_struct->unnormalizedCoordinates; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSamplerCreateInfo::initialize(const safe_VkSamplerCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + magFilter = copy_src->magFilter; + minFilter = copy_src->minFilter; + mipmapMode = copy_src->mipmapMode; + addressModeU = copy_src->addressModeU; + addressModeV = copy_src->addressModeV; + addressModeW = copy_src->addressModeW; + mipLodBias = copy_src->mipLodBias; + anisotropyEnable = copy_src->anisotropyEnable; + maxAnisotropy = copy_src->maxAnisotropy; + compareEnable = copy_src->compareEnable; + compareOp = copy_src->compareOp; + minLod = copy_src->minLod; + maxLod = copy_src->maxLod; + borderColor = copy_src->borderColor; + unnormalizedCoordinates = copy_src->unnormalizedCoordinates; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCopyDescriptorSet::safe_VkCopyDescriptorSet(const VkCopyDescriptorSet* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + srcSet(in_struct->srcSet), + srcBinding(in_struct->srcBinding), + srcArrayElement(in_struct->srcArrayElement), + dstSet(in_struct->dstSet), + dstBinding(in_struct->dstBinding), + dstArrayElement(in_struct->dstArrayElement), + descriptorCount(in_struct->descriptorCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCopyDescriptorSet::safe_VkCopyDescriptorSet() + : sType(VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET), + pNext(nullptr), + srcSet(), + srcBinding(), + srcArrayElement(), + dstSet(), + dstBinding(), + dstArrayElement(), + descriptorCount() {} + +safe_VkCopyDescriptorSet::safe_VkCopyDescriptorSet(const safe_VkCopyDescriptorSet& copy_src) { + sType = copy_src.sType; + srcSet = copy_src.srcSet; + srcBinding = copy_src.srcBinding; + srcArrayElement = copy_src.srcArrayElement; + dstSet = copy_src.dstSet; + dstBinding = copy_src.dstBinding; + dstArrayElement = copy_src.dstArrayElement; + descriptorCount = copy_src.descriptorCount; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCopyDescriptorSet& safe_VkCopyDescriptorSet::operator=(const safe_VkCopyDescriptorSet& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + srcSet = copy_src.srcSet; + srcBinding = copy_src.srcBinding; + srcArrayElement = copy_src.srcArrayElement; + dstSet = copy_src.dstSet; + dstBinding = copy_src.dstBinding; + dstArrayElement = copy_src.dstArrayElement; + descriptorCount = copy_src.descriptorCount; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCopyDescriptorSet::~safe_VkCopyDescriptorSet() { FreePnextChain(pNext); } + +void safe_VkCopyDescriptorSet::initialize(const VkCopyDescriptorSet* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + srcSet = in_struct->srcSet; + srcBinding = in_struct->srcBinding; + srcArrayElement = in_struct->srcArrayElement; + dstSet = in_struct->dstSet; + dstBinding = in_struct->dstBinding; + dstArrayElement = in_struct->dstArrayElement; + descriptorCount = in_struct->descriptorCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCopyDescriptorSet::initialize(const safe_VkCopyDescriptorSet* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcSet = copy_src->srcSet; + srcBinding = copy_src->srcBinding; + srcArrayElement = copy_src->srcArrayElement; + dstSet = copy_src->dstSet; + dstBinding = copy_src->dstBinding; + dstArrayElement = copy_src->dstArrayElement; + descriptorCount = copy_src->descriptorCount; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDescriptorPoolCreateInfo::safe_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + maxSets(in_struct->maxSets), + poolSizeCount(in_struct->poolSizeCount), + pPoolSizes(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pPoolSizes) { + pPoolSizes = new VkDescriptorPoolSize[in_struct->poolSizeCount]; + memcpy((void*)pPoolSizes, (void*)in_struct->pPoolSizes, sizeof(VkDescriptorPoolSize) * in_struct->poolSizeCount); + } +} + +safe_VkDescriptorPoolCreateInfo::safe_VkDescriptorPoolCreateInfo() + : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO), + pNext(nullptr), + flags(), + maxSets(), + poolSizeCount(), + pPoolSizes(nullptr) {} + +safe_VkDescriptorPoolCreateInfo::safe_VkDescriptorPoolCreateInfo(const safe_VkDescriptorPoolCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + maxSets = copy_src.maxSets; + poolSizeCount = copy_src.poolSizeCount; + pPoolSizes = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPoolSizes) { + pPoolSizes = new VkDescriptorPoolSize[copy_src.poolSizeCount]; + memcpy((void*)pPoolSizes, (void*)copy_src.pPoolSizes, sizeof(VkDescriptorPoolSize) * copy_src.poolSizeCount); + } +} + +safe_VkDescriptorPoolCreateInfo& safe_VkDescriptorPoolCreateInfo::operator=(const safe_VkDescriptorPoolCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pPoolSizes) delete[] pPoolSizes; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + maxSets = copy_src.maxSets; + poolSizeCount = copy_src.poolSizeCount; + pPoolSizes = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPoolSizes) { + pPoolSizes = new VkDescriptorPoolSize[copy_src.poolSizeCount]; + memcpy((void*)pPoolSizes, (void*)copy_src.pPoolSizes, sizeof(VkDescriptorPoolSize) * copy_src.poolSizeCount); + } + + return *this; +} + +safe_VkDescriptorPoolCreateInfo::~safe_VkDescriptorPoolCreateInfo() { + if (pPoolSizes) delete[] pPoolSizes; + FreePnextChain(pNext); +} + +void safe_VkDescriptorPoolCreateInfo::initialize(const VkDescriptorPoolCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPoolSizes) delete[] pPoolSizes; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + maxSets = in_struct->maxSets; + poolSizeCount = in_struct->poolSizeCount; + pPoolSizes = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pPoolSizes) { + pPoolSizes = new VkDescriptorPoolSize[in_struct->poolSizeCount]; + memcpy((void*)pPoolSizes, (void*)in_struct->pPoolSizes, sizeof(VkDescriptorPoolSize) * in_struct->poolSizeCount); + } +} + +void safe_VkDescriptorPoolCreateInfo::initialize(const safe_VkDescriptorPoolCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + maxSets = copy_src->maxSets; + poolSizeCount = copy_src->poolSizeCount; + pPoolSizes = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pPoolSizes) { + pPoolSizes = new VkDescriptorPoolSize[copy_src->poolSizeCount]; + memcpy((void*)pPoolSizes, (void*)copy_src->pPoolSizes, sizeof(VkDescriptorPoolSize) * copy_src->poolSizeCount); + } +} + +safe_VkDescriptorSetAllocateInfo::safe_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + descriptorPool(in_struct->descriptorPool), + descriptorSetCount(in_struct->descriptorSetCount), + pSetLayouts(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (descriptorSetCount && in_struct->pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount]; + for (uint32_t i = 0; i < descriptorSetCount; ++i) { + pSetLayouts[i] = in_struct->pSetLayouts[i]; + } + } +} + +safe_VkDescriptorSetAllocateInfo::safe_VkDescriptorSetAllocateInfo() + : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO), + pNext(nullptr), + descriptorPool(), + descriptorSetCount(), + pSetLayouts(nullptr) {} + +safe_VkDescriptorSetAllocateInfo::safe_VkDescriptorSetAllocateInfo(const safe_VkDescriptorSetAllocateInfo& copy_src) { + sType = copy_src.sType; + descriptorPool = copy_src.descriptorPool; + descriptorSetCount = copy_src.descriptorSetCount; + pSetLayouts = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (descriptorSetCount && copy_src.pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount]; + for (uint32_t i = 0; i < descriptorSetCount; ++i) { + pSetLayouts[i] = copy_src.pSetLayouts[i]; + } + } +} + +safe_VkDescriptorSetAllocateInfo& safe_VkDescriptorSetAllocateInfo::operator=(const safe_VkDescriptorSetAllocateInfo& copy_src) { + if (©_src == this) return *this; + + if (pSetLayouts) delete[] pSetLayouts; + FreePnextChain(pNext); + + sType = copy_src.sType; + descriptorPool = copy_src.descriptorPool; + descriptorSetCount = copy_src.descriptorSetCount; + pSetLayouts = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (descriptorSetCount && copy_src.pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount]; + for (uint32_t i = 0; i < descriptorSetCount; ++i) { + pSetLayouts[i] = copy_src.pSetLayouts[i]; + } + } + + return *this; +} + +safe_VkDescriptorSetAllocateInfo::~safe_VkDescriptorSetAllocateInfo() { + if (pSetLayouts) delete[] pSetLayouts; + FreePnextChain(pNext); +} + +void safe_VkDescriptorSetAllocateInfo::initialize(const VkDescriptorSetAllocateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pSetLayouts) delete[] pSetLayouts; + FreePnextChain(pNext); + sType = in_struct->sType; + descriptorPool = in_struct->descriptorPool; + descriptorSetCount = in_struct->descriptorSetCount; + pSetLayouts = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (descriptorSetCount && in_struct->pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount]; + for (uint32_t i = 0; i < descriptorSetCount; ++i) { + pSetLayouts[i] = in_struct->pSetLayouts[i]; + } + } +} + +void safe_VkDescriptorSetAllocateInfo::initialize(const safe_VkDescriptorSetAllocateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + descriptorPool = copy_src->descriptorPool; + descriptorSetCount = copy_src->descriptorSetCount; + pSetLayouts = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (descriptorSetCount && copy_src->pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount]; + for (uint32_t i = 0; i < descriptorSetCount; ++i) { + pSetLayouts[i] = copy_src->pSetLayouts[i]; + } + } +} + +safe_VkDescriptorSetLayoutBinding::safe_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) + : binding(in_struct->binding), + descriptorType(in_struct->descriptorType), + descriptorCount(in_struct->descriptorCount), + stageFlags(in_struct->stageFlags), + pImmutableSamplers(nullptr) { + const bool sampler_type = in_struct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || + in_struct->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + if (descriptorCount && in_struct->pImmutableSamplers && sampler_type) { + pImmutableSamplers = new VkSampler[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pImmutableSamplers[i] = in_struct->pImmutableSamplers[i]; + } + } +} + +safe_VkDescriptorSetLayoutBinding::safe_VkDescriptorSetLayoutBinding() + : binding(), descriptorType(), descriptorCount(), stageFlags(), pImmutableSamplers(nullptr) {} + +safe_VkDescriptorSetLayoutBinding::safe_VkDescriptorSetLayoutBinding(const safe_VkDescriptorSetLayoutBinding& copy_src) { + binding = copy_src.binding; + descriptorType = copy_src.descriptorType; + descriptorCount = copy_src.descriptorCount; + stageFlags = copy_src.stageFlags; + pImmutableSamplers = nullptr; + + const bool sampler_type = copy_src.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || + copy_src.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + if (descriptorCount && copy_src.pImmutableSamplers && sampler_type) { + pImmutableSamplers = new VkSampler[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pImmutableSamplers[i] = copy_src.pImmutableSamplers[i]; + } + } +} + +safe_VkDescriptorSetLayoutBinding& safe_VkDescriptorSetLayoutBinding::operator=(const safe_VkDescriptorSetLayoutBinding& copy_src) { + if (©_src == this) return *this; + + if (pImmutableSamplers) delete[] pImmutableSamplers; + + binding = copy_src.binding; + descriptorType = copy_src.descriptorType; + descriptorCount = copy_src.descriptorCount; + stageFlags = copy_src.stageFlags; + pImmutableSamplers = nullptr; + + const bool sampler_type = copy_src.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || + copy_src.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + if (descriptorCount && copy_src.pImmutableSamplers && sampler_type) { + pImmutableSamplers = new VkSampler[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pImmutableSamplers[i] = copy_src.pImmutableSamplers[i]; + } + } + + return *this; +} + +safe_VkDescriptorSetLayoutBinding::~safe_VkDescriptorSetLayoutBinding() { + if (pImmutableSamplers) delete[] pImmutableSamplers; +} + +void safe_VkDescriptorSetLayoutBinding::initialize(const VkDescriptorSetLayoutBinding* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pImmutableSamplers) delete[] pImmutableSamplers; + binding = in_struct->binding; + descriptorType = in_struct->descriptorType; + descriptorCount = in_struct->descriptorCount; + stageFlags = in_struct->stageFlags; + pImmutableSamplers = nullptr; + + const bool sampler_type = in_struct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || + in_struct->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + if (descriptorCount && in_struct->pImmutableSamplers && sampler_type) { + pImmutableSamplers = new VkSampler[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pImmutableSamplers[i] = in_struct->pImmutableSamplers[i]; + } + } +} + +void safe_VkDescriptorSetLayoutBinding::initialize(const safe_VkDescriptorSetLayoutBinding* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + binding = copy_src->binding; + descriptorType = copy_src->descriptorType; + descriptorCount = copy_src->descriptorCount; + stageFlags = copy_src->stageFlags; + pImmutableSamplers = nullptr; + + const bool sampler_type = copy_src->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || + copy_src->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + if (descriptorCount && copy_src->pImmutableSamplers && sampler_type) { + pImmutableSamplers = new VkSampler[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pImmutableSamplers[i] = copy_src->pImmutableSamplers[i]; + } + } +} + +safe_VkDescriptorSetLayoutCreateInfo::safe_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), bindingCount(in_struct->bindingCount), pBindings(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (bindingCount && in_struct->pBindings) { + pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount]; + for (uint32_t i = 0; i < bindingCount; ++i) { + pBindings[i].initialize(&in_struct->pBindings[i]); + } + } +} + +safe_VkDescriptorSetLayoutCreateInfo::safe_VkDescriptorSetLayoutCreateInfo() + : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO), pNext(nullptr), flags(), bindingCount(), pBindings(nullptr) {} + +safe_VkDescriptorSetLayoutCreateInfo::safe_VkDescriptorSetLayoutCreateInfo(const safe_VkDescriptorSetLayoutCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + bindingCount = copy_src.bindingCount; + pBindings = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (bindingCount && copy_src.pBindings) { + pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount]; + for (uint32_t i = 0; i < bindingCount; ++i) { + pBindings[i].initialize(©_src.pBindings[i]); + } + } +} + +safe_VkDescriptorSetLayoutCreateInfo& safe_VkDescriptorSetLayoutCreateInfo::operator=( + const safe_VkDescriptorSetLayoutCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pBindings) delete[] pBindings; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + bindingCount = copy_src.bindingCount; + pBindings = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (bindingCount && copy_src.pBindings) { + pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount]; + for (uint32_t i = 0; i < bindingCount; ++i) { + pBindings[i].initialize(©_src.pBindings[i]); + } + } + + return *this; +} + +safe_VkDescriptorSetLayoutCreateInfo::~safe_VkDescriptorSetLayoutCreateInfo() { + if (pBindings) delete[] pBindings; + FreePnextChain(pNext); +} + +void safe_VkDescriptorSetLayoutCreateInfo::initialize(const VkDescriptorSetLayoutCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pBindings) delete[] pBindings; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + bindingCount = in_struct->bindingCount; + pBindings = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (bindingCount && in_struct->pBindings) { + pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount]; + for (uint32_t i = 0; i < bindingCount; ++i) { + pBindings[i].initialize(&in_struct->pBindings[i]); + } + } +} + +void safe_VkDescriptorSetLayoutCreateInfo::initialize(const safe_VkDescriptorSetLayoutCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + bindingCount = copy_src->bindingCount; + pBindings = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (bindingCount && copy_src->pBindings) { + pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount]; + for (uint32_t i = 0; i < bindingCount; ++i) { + pBindings[i].initialize(©_src->pBindings[i]); + } + } +} + +safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const VkWriteDescriptorSet* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + dstSet(in_struct->dstSet), + dstBinding(in_struct->dstBinding), + dstArrayElement(in_struct->dstArrayElement), + descriptorCount(in_struct->descriptorCount), + descriptorType(in_struct->descriptorType), + pImageInfo(nullptr), + pBufferInfo(nullptr), + pTexelBufferView(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + switch (descriptorType) { + case VK_DESCRIPTOR_TYPE_SAMPLER: + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + case VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM: + case VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM: + if (descriptorCount && in_struct->pImageInfo) { + pImageInfo = new VkDescriptorImageInfo[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pImageInfo[i] = in_struct->pImageInfo[i]; + } + } + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + if (descriptorCount && in_struct->pBufferInfo) { + pBufferInfo = new VkDescriptorBufferInfo[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pBufferInfo[i] = in_struct->pBufferInfo[i]; + } + } + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + if (descriptorCount && in_struct->pTexelBufferView) { + pTexelBufferView = new VkBufferView[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pTexelBufferView[i] = in_struct->pTexelBufferView[i]; + } + } + break; + default: + break; + } +} + +safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet() + : sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET), + pNext(nullptr), + dstSet(), + dstBinding(), + dstArrayElement(), + descriptorCount(), + descriptorType(), + pImageInfo(nullptr), + pBufferInfo(nullptr), + pTexelBufferView(nullptr) {} + +safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const safe_VkWriteDescriptorSet& copy_src) { + sType = copy_src.sType; + dstSet = copy_src.dstSet; + dstBinding = copy_src.dstBinding; + dstArrayElement = copy_src.dstArrayElement; + descriptorCount = copy_src.descriptorCount; + descriptorType = copy_src.descriptorType; + pImageInfo = nullptr; + pBufferInfo = nullptr; + pTexelBufferView = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + switch (descriptorType) { + case VK_DESCRIPTOR_TYPE_SAMPLER: + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + case VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM: + case VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM: + if (descriptorCount && copy_src.pImageInfo) { + pImageInfo = new VkDescriptorImageInfo[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pImageInfo[i] = copy_src.pImageInfo[i]; + } + } + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + if (descriptorCount && copy_src.pBufferInfo) { + pBufferInfo = new VkDescriptorBufferInfo[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pBufferInfo[i] = copy_src.pBufferInfo[i]; + } + } + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + if (descriptorCount && copy_src.pTexelBufferView) { + pTexelBufferView = new VkBufferView[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pTexelBufferView[i] = copy_src.pTexelBufferView[i]; + } + } + break; + default: + break; + } +} + +safe_VkWriteDescriptorSet& safe_VkWriteDescriptorSet::operator=(const safe_VkWriteDescriptorSet& copy_src) { + if (©_src == this) return *this; + + if (pImageInfo) delete[] pImageInfo; + if (pBufferInfo) delete[] pBufferInfo; + if (pTexelBufferView) delete[] pTexelBufferView; + FreePnextChain(pNext); + + sType = copy_src.sType; + dstSet = copy_src.dstSet; + dstBinding = copy_src.dstBinding; + dstArrayElement = copy_src.dstArrayElement; + descriptorCount = copy_src.descriptorCount; + descriptorType = copy_src.descriptorType; + pImageInfo = nullptr; + pBufferInfo = nullptr; + pTexelBufferView = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + switch (descriptorType) { + case VK_DESCRIPTOR_TYPE_SAMPLER: + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + case VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM: + case VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM: + if (descriptorCount && copy_src.pImageInfo) { + pImageInfo = new VkDescriptorImageInfo[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pImageInfo[i] = copy_src.pImageInfo[i]; + } + } + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + if (descriptorCount && copy_src.pBufferInfo) { + pBufferInfo = new VkDescriptorBufferInfo[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pBufferInfo[i] = copy_src.pBufferInfo[i]; + } + } + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + if (descriptorCount && copy_src.pTexelBufferView) { + pTexelBufferView = new VkBufferView[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pTexelBufferView[i] = copy_src.pTexelBufferView[i]; + } + } + break; + default: + break; + } + + return *this; +} + +safe_VkWriteDescriptorSet::~safe_VkWriteDescriptorSet() { + if (pImageInfo) delete[] pImageInfo; + if (pBufferInfo) delete[] pBufferInfo; + if (pTexelBufferView) delete[] pTexelBufferView; + FreePnextChain(pNext); +} + +void safe_VkWriteDescriptorSet::initialize(const VkWriteDescriptorSet* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pImageInfo) delete[] pImageInfo; + if (pBufferInfo) delete[] pBufferInfo; + if (pTexelBufferView) delete[] pTexelBufferView; + FreePnextChain(pNext); + sType = in_struct->sType; + dstSet = in_struct->dstSet; + dstBinding = in_struct->dstBinding; + dstArrayElement = in_struct->dstArrayElement; + descriptorCount = in_struct->descriptorCount; + descriptorType = in_struct->descriptorType; + pImageInfo = nullptr; + pBufferInfo = nullptr; + pTexelBufferView = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + switch (descriptorType) { + case VK_DESCRIPTOR_TYPE_SAMPLER: + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + case VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM: + case VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM: + if (descriptorCount && in_struct->pImageInfo) { + pImageInfo = new VkDescriptorImageInfo[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pImageInfo[i] = in_struct->pImageInfo[i]; + } + } + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + if (descriptorCount && in_struct->pBufferInfo) { + pBufferInfo = new VkDescriptorBufferInfo[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pBufferInfo[i] = in_struct->pBufferInfo[i]; + } + } + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + if (descriptorCount && in_struct->pTexelBufferView) { + pTexelBufferView = new VkBufferView[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pTexelBufferView[i] = in_struct->pTexelBufferView[i]; + } + } + break; + default: + break; + } +} + +void safe_VkWriteDescriptorSet::initialize(const safe_VkWriteDescriptorSet* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + dstSet = copy_src->dstSet; + dstBinding = copy_src->dstBinding; + dstArrayElement = copy_src->dstArrayElement; + descriptorCount = copy_src->descriptorCount; + descriptorType = copy_src->descriptorType; + pImageInfo = nullptr; + pBufferInfo = nullptr; + pTexelBufferView = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + switch (descriptorType) { + case VK_DESCRIPTOR_TYPE_SAMPLER: + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + case VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM: + case VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM: + if (descriptorCount && copy_src->pImageInfo) { + pImageInfo = new VkDescriptorImageInfo[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pImageInfo[i] = copy_src->pImageInfo[i]; + } + } + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + if (descriptorCount && copy_src->pBufferInfo) { + pBufferInfo = new VkDescriptorBufferInfo[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pBufferInfo[i] = copy_src->pBufferInfo[i]; + } + } + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + if (descriptorCount && copy_src->pTexelBufferView) { + pTexelBufferView = new VkBufferView[descriptorCount]; + for (uint32_t i = 0; i < descriptorCount; ++i) { + pTexelBufferView[i] = copy_src->pTexelBufferView[i]; + } + } + break; + default: + break; + } +} + +safe_VkFramebufferCreateInfo::safe_VkFramebufferCreateInfo(const VkFramebufferCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + renderPass(in_struct->renderPass), + attachmentCount(in_struct->attachmentCount), + pAttachments(nullptr), + width(in_struct->width), + height(in_struct->height), + layers(in_struct->layers) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (attachmentCount && in_struct->pAttachments && !(flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)) { + pAttachments = new VkImageView[attachmentCount]; + for (uint32_t i = 0; i < attachmentCount; ++i) { + pAttachments[i] = in_struct->pAttachments[i]; + } + } +} + +safe_VkFramebufferCreateInfo::safe_VkFramebufferCreateInfo() + : sType(VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO), + pNext(nullptr), + flags(), + renderPass(), + attachmentCount(), + pAttachments(nullptr), + width(), + height(), + layers() {} + +safe_VkFramebufferCreateInfo::safe_VkFramebufferCreateInfo(const safe_VkFramebufferCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + renderPass = copy_src.renderPass; + attachmentCount = copy_src.attachmentCount; + pAttachments = nullptr; + width = copy_src.width; + height = copy_src.height; + layers = copy_src.layers; + + pNext = SafePnextCopy(copy_src.pNext); + if (attachmentCount && copy_src.pAttachments && !(flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)) { + pAttachments = new VkImageView[attachmentCount]; + for (uint32_t i = 0; i < attachmentCount; ++i) { + pAttachments[i] = copy_src.pAttachments[i]; + } + } +} + +safe_VkFramebufferCreateInfo& safe_VkFramebufferCreateInfo::operator=(const safe_VkFramebufferCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pAttachments) delete[] pAttachments; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + renderPass = copy_src.renderPass; + attachmentCount = copy_src.attachmentCount; + pAttachments = nullptr; + width = copy_src.width; + height = copy_src.height; + layers = copy_src.layers; + + pNext = SafePnextCopy(copy_src.pNext); + if (attachmentCount && copy_src.pAttachments && !(flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)) { + pAttachments = new VkImageView[attachmentCount]; + for (uint32_t i = 0; i < attachmentCount; ++i) { + pAttachments[i] = copy_src.pAttachments[i]; + } + } + + return *this; +} + +safe_VkFramebufferCreateInfo::~safe_VkFramebufferCreateInfo() { + if (pAttachments) delete[] pAttachments; + FreePnextChain(pNext); +} + +void safe_VkFramebufferCreateInfo::initialize(const VkFramebufferCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pAttachments) delete[] pAttachments; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + renderPass = in_struct->renderPass; + attachmentCount = in_struct->attachmentCount; + pAttachments = nullptr; + width = in_struct->width; + height = in_struct->height; + layers = in_struct->layers; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (attachmentCount && in_struct->pAttachments && !(flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)) { + pAttachments = new VkImageView[attachmentCount]; + for (uint32_t i = 0; i < attachmentCount; ++i) { + pAttachments[i] = in_struct->pAttachments[i]; + } + } +} + +void safe_VkFramebufferCreateInfo::initialize(const safe_VkFramebufferCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + renderPass = copy_src->renderPass; + attachmentCount = copy_src->attachmentCount; + pAttachments = nullptr; + width = copy_src->width; + height = copy_src->height; + layers = copy_src->layers; + + pNext = SafePnextCopy(copy_src->pNext); + if (attachmentCount && copy_src->pAttachments && !(flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)) { + pAttachments = new VkImageView[attachmentCount]; + for (uint32_t i = 0; i < attachmentCount; ++i) { + pAttachments[i] = copy_src->pAttachments[i]; + } + } +} + +safe_VkSubpassDescription::safe_VkSubpassDescription(const VkSubpassDescription* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) + : flags(in_struct->flags), + pipelineBindPoint(in_struct->pipelineBindPoint), + inputAttachmentCount(in_struct->inputAttachmentCount), + pInputAttachments(nullptr), + colorAttachmentCount(in_struct->colorAttachmentCount), + pColorAttachments(nullptr), + pResolveAttachments(nullptr), + pDepthStencilAttachment(nullptr), + preserveAttachmentCount(in_struct->preserveAttachmentCount), + pPreserveAttachments(nullptr) { + if (in_struct->pInputAttachments) { + pInputAttachments = new VkAttachmentReference[in_struct->inputAttachmentCount]; + memcpy((void*)pInputAttachments, (void*)in_struct->pInputAttachments, + sizeof(VkAttachmentReference) * in_struct->inputAttachmentCount); + } + + if (in_struct->pColorAttachments) { + pColorAttachments = new VkAttachmentReference[in_struct->colorAttachmentCount]; + memcpy((void*)pColorAttachments, (void*)in_struct->pColorAttachments, + sizeof(VkAttachmentReference) * in_struct->colorAttachmentCount); + } + + if (in_struct->pResolveAttachments) { + pResolveAttachments = new VkAttachmentReference[in_struct->colorAttachmentCount]; + memcpy((void*)pResolveAttachments, (void*)in_struct->pResolveAttachments, + sizeof(VkAttachmentReference) * in_struct->colorAttachmentCount); + } + + if (in_struct->pDepthStencilAttachment) { + pDepthStencilAttachment = new VkAttachmentReference(*in_struct->pDepthStencilAttachment); + } + + if (in_struct->pPreserveAttachments) { + pPreserveAttachments = new uint32_t[in_struct->preserveAttachmentCount]; + memcpy((void*)pPreserveAttachments, (void*)in_struct->pPreserveAttachments, + sizeof(uint32_t) * in_struct->preserveAttachmentCount); + } +} + +safe_VkSubpassDescription::safe_VkSubpassDescription() + : flags(), + pipelineBindPoint(), + inputAttachmentCount(), + pInputAttachments(nullptr), + colorAttachmentCount(), + pColorAttachments(nullptr), + pResolveAttachments(nullptr), + pDepthStencilAttachment(nullptr), + preserveAttachmentCount(), + pPreserveAttachments(nullptr) {} + +safe_VkSubpassDescription::safe_VkSubpassDescription(const safe_VkSubpassDescription& copy_src) { + flags = copy_src.flags; + pipelineBindPoint = copy_src.pipelineBindPoint; + inputAttachmentCount = copy_src.inputAttachmentCount; + pInputAttachments = nullptr; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachments = nullptr; + pResolveAttachments = nullptr; + pDepthStencilAttachment = nullptr; + preserveAttachmentCount = copy_src.preserveAttachmentCount; + pPreserveAttachments = nullptr; + + if (copy_src.pInputAttachments) { + pInputAttachments = new VkAttachmentReference[copy_src.inputAttachmentCount]; + memcpy((void*)pInputAttachments, (void*)copy_src.pInputAttachments, + sizeof(VkAttachmentReference) * copy_src.inputAttachmentCount); + } + + if (copy_src.pColorAttachments) { + pColorAttachments = new VkAttachmentReference[copy_src.colorAttachmentCount]; + memcpy((void*)pColorAttachments, (void*)copy_src.pColorAttachments, + sizeof(VkAttachmentReference) * copy_src.colorAttachmentCount); + } + + if (copy_src.pResolveAttachments) { + pResolveAttachments = new VkAttachmentReference[copy_src.colorAttachmentCount]; + memcpy((void*)pResolveAttachments, (void*)copy_src.pResolveAttachments, + sizeof(VkAttachmentReference) * copy_src.colorAttachmentCount); + } + + if (copy_src.pDepthStencilAttachment) { + pDepthStencilAttachment = new VkAttachmentReference(*copy_src.pDepthStencilAttachment); + } + + if (copy_src.pPreserveAttachments) { + pPreserveAttachments = new uint32_t[copy_src.preserveAttachmentCount]; + memcpy((void*)pPreserveAttachments, (void*)copy_src.pPreserveAttachments, + sizeof(uint32_t) * copy_src.preserveAttachmentCount); + } +} + +safe_VkSubpassDescription& safe_VkSubpassDescription::operator=(const safe_VkSubpassDescription& copy_src) { + if (©_src == this) return *this; + + if (pInputAttachments) delete[] pInputAttachments; + if (pColorAttachments) delete[] pColorAttachments; + if (pResolveAttachments) delete[] pResolveAttachments; + if (pDepthStencilAttachment) delete pDepthStencilAttachment; + if (pPreserveAttachments) delete[] pPreserveAttachments; + + flags = copy_src.flags; + pipelineBindPoint = copy_src.pipelineBindPoint; + inputAttachmentCount = copy_src.inputAttachmentCount; + pInputAttachments = nullptr; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachments = nullptr; + pResolveAttachments = nullptr; + pDepthStencilAttachment = nullptr; + preserveAttachmentCount = copy_src.preserveAttachmentCount; + pPreserveAttachments = nullptr; + + if (copy_src.pInputAttachments) { + pInputAttachments = new VkAttachmentReference[copy_src.inputAttachmentCount]; + memcpy((void*)pInputAttachments, (void*)copy_src.pInputAttachments, + sizeof(VkAttachmentReference) * copy_src.inputAttachmentCount); + } + + if (copy_src.pColorAttachments) { + pColorAttachments = new VkAttachmentReference[copy_src.colorAttachmentCount]; + memcpy((void*)pColorAttachments, (void*)copy_src.pColorAttachments, + sizeof(VkAttachmentReference) * copy_src.colorAttachmentCount); + } + + if (copy_src.pResolveAttachments) { + pResolveAttachments = new VkAttachmentReference[copy_src.colorAttachmentCount]; + memcpy((void*)pResolveAttachments, (void*)copy_src.pResolveAttachments, + sizeof(VkAttachmentReference) * copy_src.colorAttachmentCount); + } + + if (copy_src.pDepthStencilAttachment) { + pDepthStencilAttachment = new VkAttachmentReference(*copy_src.pDepthStencilAttachment); + } + + if (copy_src.pPreserveAttachments) { + pPreserveAttachments = new uint32_t[copy_src.preserveAttachmentCount]; + memcpy((void*)pPreserveAttachments, (void*)copy_src.pPreserveAttachments, + sizeof(uint32_t) * copy_src.preserveAttachmentCount); + } + + return *this; +} + +safe_VkSubpassDescription::~safe_VkSubpassDescription() { + if (pInputAttachments) delete[] pInputAttachments; + if (pColorAttachments) delete[] pColorAttachments; + if (pResolveAttachments) delete[] pResolveAttachments; + if (pDepthStencilAttachment) delete pDepthStencilAttachment; + if (pPreserveAttachments) delete[] pPreserveAttachments; +} + +void safe_VkSubpassDescription::initialize(const VkSubpassDescription* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pInputAttachments) delete[] pInputAttachments; + if (pColorAttachments) delete[] pColorAttachments; + if (pResolveAttachments) delete[] pResolveAttachments; + if (pDepthStencilAttachment) delete pDepthStencilAttachment; + if (pPreserveAttachments) delete[] pPreserveAttachments; + flags = in_struct->flags; + pipelineBindPoint = in_struct->pipelineBindPoint; + inputAttachmentCount = in_struct->inputAttachmentCount; + pInputAttachments = nullptr; + colorAttachmentCount = in_struct->colorAttachmentCount; + pColorAttachments = nullptr; + pResolveAttachments = nullptr; + pDepthStencilAttachment = nullptr; + preserveAttachmentCount = in_struct->preserveAttachmentCount; + pPreserveAttachments = nullptr; + + if (in_struct->pInputAttachments) { + pInputAttachments = new VkAttachmentReference[in_struct->inputAttachmentCount]; + memcpy((void*)pInputAttachments, (void*)in_struct->pInputAttachments, + sizeof(VkAttachmentReference) * in_struct->inputAttachmentCount); + } + + if (in_struct->pColorAttachments) { + pColorAttachments = new VkAttachmentReference[in_struct->colorAttachmentCount]; + memcpy((void*)pColorAttachments, (void*)in_struct->pColorAttachments, + sizeof(VkAttachmentReference) * in_struct->colorAttachmentCount); + } + + if (in_struct->pResolveAttachments) { + pResolveAttachments = new VkAttachmentReference[in_struct->colorAttachmentCount]; + memcpy((void*)pResolveAttachments, (void*)in_struct->pResolveAttachments, + sizeof(VkAttachmentReference) * in_struct->colorAttachmentCount); + } + + if (in_struct->pDepthStencilAttachment) { + pDepthStencilAttachment = new VkAttachmentReference(*in_struct->pDepthStencilAttachment); + } + + if (in_struct->pPreserveAttachments) { + pPreserveAttachments = new uint32_t[in_struct->preserveAttachmentCount]; + memcpy((void*)pPreserveAttachments, (void*)in_struct->pPreserveAttachments, + sizeof(uint32_t) * in_struct->preserveAttachmentCount); + } +} + +void safe_VkSubpassDescription::initialize(const safe_VkSubpassDescription* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + flags = copy_src->flags; + pipelineBindPoint = copy_src->pipelineBindPoint; + inputAttachmentCount = copy_src->inputAttachmentCount; + pInputAttachments = nullptr; + colorAttachmentCount = copy_src->colorAttachmentCount; + pColorAttachments = nullptr; + pResolveAttachments = nullptr; + pDepthStencilAttachment = nullptr; + preserveAttachmentCount = copy_src->preserveAttachmentCount; + pPreserveAttachments = nullptr; + + if (copy_src->pInputAttachments) { + pInputAttachments = new VkAttachmentReference[copy_src->inputAttachmentCount]; + memcpy((void*)pInputAttachments, (void*)copy_src->pInputAttachments, + sizeof(VkAttachmentReference) * copy_src->inputAttachmentCount); + } + + if (copy_src->pColorAttachments) { + pColorAttachments = new VkAttachmentReference[copy_src->colorAttachmentCount]; + memcpy((void*)pColorAttachments, (void*)copy_src->pColorAttachments, + sizeof(VkAttachmentReference) * copy_src->colorAttachmentCount); + } + + if (copy_src->pResolveAttachments) { + pResolveAttachments = new VkAttachmentReference[copy_src->colorAttachmentCount]; + memcpy((void*)pResolveAttachments, (void*)copy_src->pResolveAttachments, + sizeof(VkAttachmentReference) * copy_src->colorAttachmentCount); + } + + if (copy_src->pDepthStencilAttachment) { + pDepthStencilAttachment = new VkAttachmentReference(*copy_src->pDepthStencilAttachment); + } + + if (copy_src->pPreserveAttachments) { + pPreserveAttachments = new uint32_t[copy_src->preserveAttachmentCount]; + memcpy((void*)pPreserveAttachments, (void*)copy_src->pPreserveAttachments, + sizeof(uint32_t) * copy_src->preserveAttachmentCount); + } +} + +safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo(const VkRenderPassCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + attachmentCount(in_struct->attachmentCount), + pAttachments(nullptr), + subpassCount(in_struct->subpassCount), + pSubpasses(nullptr), + dependencyCount(in_struct->dependencyCount), + pDependencies(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pAttachments) { + pAttachments = new VkAttachmentDescription[in_struct->attachmentCount]; + memcpy((void*)pAttachments, (void*)in_struct->pAttachments, sizeof(VkAttachmentDescription) * in_struct->attachmentCount); + } + if (subpassCount && in_struct->pSubpasses) { + pSubpasses = new safe_VkSubpassDescription[subpassCount]; + for (uint32_t i = 0; i < subpassCount; ++i) { + pSubpasses[i].initialize(&in_struct->pSubpasses[i]); + } + } + + if (in_struct->pDependencies) { + pDependencies = new VkSubpassDependency[in_struct->dependencyCount]; + memcpy((void*)pDependencies, (void*)in_struct->pDependencies, sizeof(VkSubpassDependency) * in_struct->dependencyCount); + } +} + +safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo() + : sType(VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO), + pNext(nullptr), + flags(), + attachmentCount(), + pAttachments(nullptr), + subpassCount(), + pSubpasses(nullptr), + dependencyCount(), + pDependencies(nullptr) {} + +safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo(const safe_VkRenderPassCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + attachmentCount = copy_src.attachmentCount; + pAttachments = nullptr; + subpassCount = copy_src.subpassCount; + pSubpasses = nullptr; + dependencyCount = copy_src.dependencyCount; + pDependencies = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pAttachments) { + pAttachments = new VkAttachmentDescription[copy_src.attachmentCount]; + memcpy((void*)pAttachments, (void*)copy_src.pAttachments, sizeof(VkAttachmentDescription) * copy_src.attachmentCount); + } + if (subpassCount && copy_src.pSubpasses) { + pSubpasses = new safe_VkSubpassDescription[subpassCount]; + for (uint32_t i = 0; i < subpassCount; ++i) { + pSubpasses[i].initialize(©_src.pSubpasses[i]); + } + } + + if (copy_src.pDependencies) { + pDependencies = new VkSubpassDependency[copy_src.dependencyCount]; + memcpy((void*)pDependencies, (void*)copy_src.pDependencies, sizeof(VkSubpassDependency) * copy_src.dependencyCount); + } +} + +safe_VkRenderPassCreateInfo& safe_VkRenderPassCreateInfo::operator=(const safe_VkRenderPassCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pAttachments) delete[] pAttachments; + if (pSubpasses) delete[] pSubpasses; + if (pDependencies) delete[] pDependencies; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + attachmentCount = copy_src.attachmentCount; + pAttachments = nullptr; + subpassCount = copy_src.subpassCount; + pSubpasses = nullptr; + dependencyCount = copy_src.dependencyCount; + pDependencies = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pAttachments) { + pAttachments = new VkAttachmentDescription[copy_src.attachmentCount]; + memcpy((void*)pAttachments, (void*)copy_src.pAttachments, sizeof(VkAttachmentDescription) * copy_src.attachmentCount); + } + if (subpassCount && copy_src.pSubpasses) { + pSubpasses = new safe_VkSubpassDescription[subpassCount]; + for (uint32_t i = 0; i < subpassCount; ++i) { + pSubpasses[i].initialize(©_src.pSubpasses[i]); + } + } + + if (copy_src.pDependencies) { + pDependencies = new VkSubpassDependency[copy_src.dependencyCount]; + memcpy((void*)pDependencies, (void*)copy_src.pDependencies, sizeof(VkSubpassDependency) * copy_src.dependencyCount); + } + + return *this; +} + +safe_VkRenderPassCreateInfo::~safe_VkRenderPassCreateInfo() { + if (pAttachments) delete[] pAttachments; + if (pSubpasses) delete[] pSubpasses; + if (pDependencies) delete[] pDependencies; + FreePnextChain(pNext); +} + +void safe_VkRenderPassCreateInfo::initialize(const VkRenderPassCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pAttachments) delete[] pAttachments; + if (pSubpasses) delete[] pSubpasses; + if (pDependencies) delete[] pDependencies; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + attachmentCount = in_struct->attachmentCount; + pAttachments = nullptr; + subpassCount = in_struct->subpassCount; + pSubpasses = nullptr; + dependencyCount = in_struct->dependencyCount; + pDependencies = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pAttachments) { + pAttachments = new VkAttachmentDescription[in_struct->attachmentCount]; + memcpy((void*)pAttachments, (void*)in_struct->pAttachments, sizeof(VkAttachmentDescription) * in_struct->attachmentCount); + } + if (subpassCount && in_struct->pSubpasses) { + pSubpasses = new safe_VkSubpassDescription[subpassCount]; + for (uint32_t i = 0; i < subpassCount; ++i) { + pSubpasses[i].initialize(&in_struct->pSubpasses[i]); + } + } + + if (in_struct->pDependencies) { + pDependencies = new VkSubpassDependency[in_struct->dependencyCount]; + memcpy((void*)pDependencies, (void*)in_struct->pDependencies, sizeof(VkSubpassDependency) * in_struct->dependencyCount); + } +} + +void safe_VkRenderPassCreateInfo::initialize(const safe_VkRenderPassCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + attachmentCount = copy_src->attachmentCount; + pAttachments = nullptr; + subpassCount = copy_src->subpassCount; + pSubpasses = nullptr; + dependencyCount = copy_src->dependencyCount; + pDependencies = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pAttachments) { + pAttachments = new VkAttachmentDescription[copy_src->attachmentCount]; + memcpy((void*)pAttachments, (void*)copy_src->pAttachments, sizeof(VkAttachmentDescription) * copy_src->attachmentCount); + } + if (subpassCount && copy_src->pSubpasses) { + pSubpasses = new safe_VkSubpassDescription[subpassCount]; + for (uint32_t i = 0; i < subpassCount; ++i) { + pSubpasses[i].initialize(©_src->pSubpasses[i]); + } + } + + if (copy_src->pDependencies) { + pDependencies = new VkSubpassDependency[copy_src->dependencyCount]; + memcpy((void*)pDependencies, (void*)copy_src->pDependencies, sizeof(VkSubpassDependency) * copy_src->dependencyCount); + } +} + +safe_VkCommandPoolCreateInfo::safe_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), queueFamilyIndex(in_struct->queueFamilyIndex) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCommandPoolCreateInfo::safe_VkCommandPoolCreateInfo() + : sType(VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO), pNext(nullptr), flags(), queueFamilyIndex() {} + +safe_VkCommandPoolCreateInfo::safe_VkCommandPoolCreateInfo(const safe_VkCommandPoolCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + queueFamilyIndex = copy_src.queueFamilyIndex; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCommandPoolCreateInfo& safe_VkCommandPoolCreateInfo::operator=(const safe_VkCommandPoolCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + queueFamilyIndex = copy_src.queueFamilyIndex; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCommandPoolCreateInfo::~safe_VkCommandPoolCreateInfo() { FreePnextChain(pNext); } + +void safe_VkCommandPoolCreateInfo::initialize(const VkCommandPoolCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + queueFamilyIndex = in_struct->queueFamilyIndex; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCommandPoolCreateInfo::initialize(const safe_VkCommandPoolCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + queueFamilyIndex = copy_src->queueFamilyIndex; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCommandBufferAllocateInfo::safe_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + commandPool(in_struct->commandPool), + level(in_struct->level), + commandBufferCount(in_struct->commandBufferCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCommandBufferAllocateInfo::safe_VkCommandBufferAllocateInfo() + : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO), pNext(nullptr), commandPool(), level(), commandBufferCount() {} + +safe_VkCommandBufferAllocateInfo::safe_VkCommandBufferAllocateInfo(const safe_VkCommandBufferAllocateInfo& copy_src) { + sType = copy_src.sType; + commandPool = copy_src.commandPool; + level = copy_src.level; + commandBufferCount = copy_src.commandBufferCount; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCommandBufferAllocateInfo& safe_VkCommandBufferAllocateInfo::operator=(const safe_VkCommandBufferAllocateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + commandPool = copy_src.commandPool; + level = copy_src.level; + commandBufferCount = copy_src.commandBufferCount; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCommandBufferAllocateInfo::~safe_VkCommandBufferAllocateInfo() { FreePnextChain(pNext); } + +void safe_VkCommandBufferAllocateInfo::initialize(const VkCommandBufferAllocateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + commandPool = in_struct->commandPool; + level = in_struct->level; + commandBufferCount = in_struct->commandBufferCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCommandBufferAllocateInfo::initialize(const safe_VkCommandBufferAllocateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + commandPool = copy_src->commandPool; + level = copy_src->level; + commandBufferCount = copy_src->commandBufferCount; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCommandBufferInheritanceInfo::safe_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + renderPass(in_struct->renderPass), + subpass(in_struct->subpass), + framebuffer(in_struct->framebuffer), + occlusionQueryEnable(in_struct->occlusionQueryEnable), + queryFlags(in_struct->queryFlags), + pipelineStatistics(in_struct->pipelineStatistics) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCommandBufferInheritanceInfo::safe_VkCommandBufferInheritanceInfo() + : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO), + pNext(nullptr), + renderPass(), + subpass(), + framebuffer(), + occlusionQueryEnable(), + queryFlags(), + pipelineStatistics() {} + +safe_VkCommandBufferInheritanceInfo::safe_VkCommandBufferInheritanceInfo(const safe_VkCommandBufferInheritanceInfo& copy_src) { + sType = copy_src.sType; + renderPass = copy_src.renderPass; + subpass = copy_src.subpass; + framebuffer = copy_src.framebuffer; + occlusionQueryEnable = copy_src.occlusionQueryEnable; + queryFlags = copy_src.queryFlags; + pipelineStatistics = copy_src.pipelineStatistics; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCommandBufferInheritanceInfo& safe_VkCommandBufferInheritanceInfo::operator=( + const safe_VkCommandBufferInheritanceInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + renderPass = copy_src.renderPass; + subpass = copy_src.subpass; + framebuffer = copy_src.framebuffer; + occlusionQueryEnable = copy_src.occlusionQueryEnable; + queryFlags = copy_src.queryFlags; + pipelineStatistics = copy_src.pipelineStatistics; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCommandBufferInheritanceInfo::~safe_VkCommandBufferInheritanceInfo() { FreePnextChain(pNext); } + +void safe_VkCommandBufferInheritanceInfo::initialize(const VkCommandBufferInheritanceInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + renderPass = in_struct->renderPass; + subpass = in_struct->subpass; + framebuffer = in_struct->framebuffer; + occlusionQueryEnable = in_struct->occlusionQueryEnable; + queryFlags = in_struct->queryFlags; + pipelineStatistics = in_struct->pipelineStatistics; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCommandBufferInheritanceInfo::initialize(const safe_VkCommandBufferInheritanceInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + renderPass = copy_src->renderPass; + subpass = copy_src->subpass; + framebuffer = copy_src->framebuffer; + occlusionQueryEnable = copy_src->occlusionQueryEnable; + queryFlags = copy_src->queryFlags; + pipelineStatistics = copy_src->pipelineStatistics; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCommandBufferBeginInfo::safe_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), pInheritanceInfo(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pInheritanceInfo) pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(in_struct->pInheritanceInfo); +} + +safe_VkCommandBufferBeginInfo::safe_VkCommandBufferBeginInfo() + : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO), pNext(nullptr), flags(), pInheritanceInfo(nullptr) {} + +safe_VkCommandBufferBeginInfo::safe_VkCommandBufferBeginInfo(const safe_VkCommandBufferBeginInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pInheritanceInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pInheritanceInfo) pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(*copy_src.pInheritanceInfo); +} + +safe_VkCommandBufferBeginInfo& safe_VkCommandBufferBeginInfo::operator=(const safe_VkCommandBufferBeginInfo& copy_src) { + if (©_src == this) return *this; + + if (pInheritanceInfo) delete pInheritanceInfo; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pInheritanceInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pInheritanceInfo) pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(*copy_src.pInheritanceInfo); + + return *this; +} + +safe_VkCommandBufferBeginInfo::~safe_VkCommandBufferBeginInfo() { + if (pInheritanceInfo) delete pInheritanceInfo; + FreePnextChain(pNext); +} + +void safe_VkCommandBufferBeginInfo::initialize(const VkCommandBufferBeginInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pInheritanceInfo) delete pInheritanceInfo; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pInheritanceInfo = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (in_struct->pInheritanceInfo) pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(in_struct->pInheritanceInfo); +} + +void safe_VkCommandBufferBeginInfo::initialize(const safe_VkCommandBufferBeginInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pInheritanceInfo = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (copy_src->pInheritanceInfo) pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(*copy_src->pInheritanceInfo); +} + +safe_VkRenderPassBeginInfo::safe_VkRenderPassBeginInfo(const VkRenderPassBeginInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + renderPass(in_struct->renderPass), + framebuffer(in_struct->framebuffer), + renderArea(in_struct->renderArea), + clearValueCount(in_struct->clearValueCount), + pClearValues(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pClearValues) { + pClearValues = new VkClearValue[in_struct->clearValueCount]; + memcpy((void*)pClearValues, (void*)in_struct->pClearValues, sizeof(VkClearValue) * in_struct->clearValueCount); + } +} + +safe_VkRenderPassBeginInfo::safe_VkRenderPassBeginInfo() + : sType(VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO), + pNext(nullptr), + renderPass(), + framebuffer(), + renderArea(), + clearValueCount(), + pClearValues(nullptr) {} + +safe_VkRenderPassBeginInfo::safe_VkRenderPassBeginInfo(const safe_VkRenderPassBeginInfo& copy_src) { + sType = copy_src.sType; + renderPass = copy_src.renderPass; + framebuffer = copy_src.framebuffer; + renderArea = copy_src.renderArea; + clearValueCount = copy_src.clearValueCount; + pClearValues = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pClearValues) { + pClearValues = new VkClearValue[copy_src.clearValueCount]; + memcpy((void*)pClearValues, (void*)copy_src.pClearValues, sizeof(VkClearValue) * copy_src.clearValueCount); + } +} + +safe_VkRenderPassBeginInfo& safe_VkRenderPassBeginInfo::operator=(const safe_VkRenderPassBeginInfo& copy_src) { + if (©_src == this) return *this; + + if (pClearValues) delete[] pClearValues; + FreePnextChain(pNext); + + sType = copy_src.sType; + renderPass = copy_src.renderPass; + framebuffer = copy_src.framebuffer; + renderArea = copy_src.renderArea; + clearValueCount = copy_src.clearValueCount; + pClearValues = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pClearValues) { + pClearValues = new VkClearValue[copy_src.clearValueCount]; + memcpy((void*)pClearValues, (void*)copy_src.pClearValues, sizeof(VkClearValue) * copy_src.clearValueCount); + } + + return *this; +} + +safe_VkRenderPassBeginInfo::~safe_VkRenderPassBeginInfo() { + if (pClearValues) delete[] pClearValues; + FreePnextChain(pNext); +} + +void safe_VkRenderPassBeginInfo::initialize(const VkRenderPassBeginInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pClearValues) delete[] pClearValues; + FreePnextChain(pNext); + sType = in_struct->sType; + renderPass = in_struct->renderPass; + framebuffer = in_struct->framebuffer; + renderArea = in_struct->renderArea; + clearValueCount = in_struct->clearValueCount; + pClearValues = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pClearValues) { + pClearValues = new VkClearValue[in_struct->clearValueCount]; + memcpy((void*)pClearValues, (void*)in_struct->pClearValues, sizeof(VkClearValue) * in_struct->clearValueCount); + } +} + +void safe_VkRenderPassBeginInfo::initialize(const safe_VkRenderPassBeginInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + renderPass = copy_src->renderPass; + framebuffer = copy_src->framebuffer; + renderArea = copy_src->renderArea; + clearValueCount = copy_src->clearValueCount; + pClearValues = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pClearValues) { + pClearValues = new VkClearValue[copy_src->clearValueCount]; + memcpy((void*)pClearValues, (void*)copy_src->pClearValues, sizeof(VkClearValue) * copy_src->clearValueCount); + } +} + +safe_VkPhysicalDeviceSubgroupProperties::safe_VkPhysicalDeviceSubgroupProperties( + const VkPhysicalDeviceSubgroupProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + subgroupSize(in_struct->subgroupSize), + supportedStages(in_struct->supportedStages), + supportedOperations(in_struct->supportedOperations), + quadOperationsInAllStages(in_struct->quadOperationsInAllStages) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceSubgroupProperties::safe_VkPhysicalDeviceSubgroupProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES), + pNext(nullptr), + subgroupSize(), + supportedStages(), + supportedOperations(), + quadOperationsInAllStages() {} + +safe_VkPhysicalDeviceSubgroupProperties::safe_VkPhysicalDeviceSubgroupProperties( + const safe_VkPhysicalDeviceSubgroupProperties& copy_src) { + sType = copy_src.sType; + subgroupSize = copy_src.subgroupSize; + supportedStages = copy_src.supportedStages; + supportedOperations = copy_src.supportedOperations; + quadOperationsInAllStages = copy_src.quadOperationsInAllStages; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceSubgroupProperties& safe_VkPhysicalDeviceSubgroupProperties::operator=( + const safe_VkPhysicalDeviceSubgroupProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + subgroupSize = copy_src.subgroupSize; + supportedStages = copy_src.supportedStages; + supportedOperations = copy_src.supportedOperations; + quadOperationsInAllStages = copy_src.quadOperationsInAllStages; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceSubgroupProperties::~safe_VkPhysicalDeviceSubgroupProperties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceSubgroupProperties::initialize(const VkPhysicalDeviceSubgroupProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + subgroupSize = in_struct->subgroupSize; + supportedStages = in_struct->supportedStages; + supportedOperations = in_struct->supportedOperations; + quadOperationsInAllStages = in_struct->quadOperationsInAllStages; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceSubgroupProperties::initialize(const safe_VkPhysicalDeviceSubgroupProperties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + subgroupSize = copy_src->subgroupSize; + supportedStages = copy_src->supportedStages; + supportedOperations = copy_src->supportedOperations; + quadOperationsInAllStages = copy_src->quadOperationsInAllStages; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBindBufferMemoryInfo::safe_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), buffer(in_struct->buffer), memory(in_struct->memory), memoryOffset(in_struct->memoryOffset) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBindBufferMemoryInfo::safe_VkBindBufferMemoryInfo() + : sType(VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO), pNext(nullptr), buffer(), memory(), memoryOffset() {} + +safe_VkBindBufferMemoryInfo::safe_VkBindBufferMemoryInfo(const safe_VkBindBufferMemoryInfo& copy_src) { + sType = copy_src.sType; + buffer = copy_src.buffer; + memory = copy_src.memory; + memoryOffset = copy_src.memoryOffset; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBindBufferMemoryInfo& safe_VkBindBufferMemoryInfo::operator=(const safe_VkBindBufferMemoryInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + buffer = copy_src.buffer; + memory = copy_src.memory; + memoryOffset = copy_src.memoryOffset; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBindBufferMemoryInfo::~safe_VkBindBufferMemoryInfo() { FreePnextChain(pNext); } + +void safe_VkBindBufferMemoryInfo::initialize(const VkBindBufferMemoryInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + buffer = in_struct->buffer; + memory = in_struct->memory; + memoryOffset = in_struct->memoryOffset; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBindBufferMemoryInfo::initialize(const safe_VkBindBufferMemoryInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + buffer = copy_src->buffer; + memory = copy_src->memory; + memoryOffset = copy_src->memoryOffset; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBindImageMemoryInfo::safe_VkBindImageMemoryInfo(const VkBindImageMemoryInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), image(in_struct->image), memory(in_struct->memory), memoryOffset(in_struct->memoryOffset) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBindImageMemoryInfo::safe_VkBindImageMemoryInfo() + : sType(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO), pNext(nullptr), image(), memory(), memoryOffset() {} + +safe_VkBindImageMemoryInfo::safe_VkBindImageMemoryInfo(const safe_VkBindImageMemoryInfo& copy_src) { + sType = copy_src.sType; + image = copy_src.image; + memory = copy_src.memory; + memoryOffset = copy_src.memoryOffset; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBindImageMemoryInfo& safe_VkBindImageMemoryInfo::operator=(const safe_VkBindImageMemoryInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + image = copy_src.image; + memory = copy_src.memory; + memoryOffset = copy_src.memoryOffset; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBindImageMemoryInfo::~safe_VkBindImageMemoryInfo() { FreePnextChain(pNext); } + +void safe_VkBindImageMemoryInfo::initialize(const VkBindImageMemoryInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + image = in_struct->image; + memory = in_struct->memory; + memoryOffset = in_struct->memoryOffset; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBindImageMemoryInfo::initialize(const safe_VkBindImageMemoryInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + image = copy_src->image; + memory = copy_src->memory; + memoryOffset = copy_src->memoryOffset; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevice16BitStorageFeatures::safe_VkPhysicalDevice16BitStorageFeatures( + const VkPhysicalDevice16BitStorageFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + storageBuffer16BitAccess(in_struct->storageBuffer16BitAccess), + uniformAndStorageBuffer16BitAccess(in_struct->uniformAndStorageBuffer16BitAccess), + storagePushConstant16(in_struct->storagePushConstant16), + storageInputOutput16(in_struct->storageInputOutput16) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevice16BitStorageFeatures::safe_VkPhysicalDevice16BitStorageFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES), + pNext(nullptr), + storageBuffer16BitAccess(), + uniformAndStorageBuffer16BitAccess(), + storagePushConstant16(), + storageInputOutput16() {} + +safe_VkPhysicalDevice16BitStorageFeatures::safe_VkPhysicalDevice16BitStorageFeatures( + const safe_VkPhysicalDevice16BitStorageFeatures& copy_src) { + sType = copy_src.sType; + storageBuffer16BitAccess = copy_src.storageBuffer16BitAccess; + uniformAndStorageBuffer16BitAccess = copy_src.uniformAndStorageBuffer16BitAccess; + storagePushConstant16 = copy_src.storagePushConstant16; + storageInputOutput16 = copy_src.storageInputOutput16; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevice16BitStorageFeatures& safe_VkPhysicalDevice16BitStorageFeatures::operator=( + const safe_VkPhysicalDevice16BitStorageFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + storageBuffer16BitAccess = copy_src.storageBuffer16BitAccess; + uniformAndStorageBuffer16BitAccess = copy_src.uniformAndStorageBuffer16BitAccess; + storagePushConstant16 = copy_src.storagePushConstant16; + storageInputOutput16 = copy_src.storageInputOutput16; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevice16BitStorageFeatures::~safe_VkPhysicalDevice16BitStorageFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevice16BitStorageFeatures::initialize(const VkPhysicalDevice16BitStorageFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + storageBuffer16BitAccess = in_struct->storageBuffer16BitAccess; + uniformAndStorageBuffer16BitAccess = in_struct->uniformAndStorageBuffer16BitAccess; + storagePushConstant16 = in_struct->storagePushConstant16; + storageInputOutput16 = in_struct->storageInputOutput16; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevice16BitStorageFeatures::initialize(const safe_VkPhysicalDevice16BitStorageFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + storageBuffer16BitAccess = copy_src->storageBuffer16BitAccess; + uniformAndStorageBuffer16BitAccess = copy_src->uniformAndStorageBuffer16BitAccess; + storagePushConstant16 = copy_src->storagePushConstant16; + storageInputOutput16 = copy_src->storageInputOutput16; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMemoryDedicatedRequirements::safe_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + prefersDedicatedAllocation(in_struct->prefersDedicatedAllocation), + requiresDedicatedAllocation(in_struct->requiresDedicatedAllocation) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMemoryDedicatedRequirements::safe_VkMemoryDedicatedRequirements() + : sType(VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS), + pNext(nullptr), + prefersDedicatedAllocation(), + requiresDedicatedAllocation() {} + +safe_VkMemoryDedicatedRequirements::safe_VkMemoryDedicatedRequirements(const safe_VkMemoryDedicatedRequirements& copy_src) { + sType = copy_src.sType; + prefersDedicatedAllocation = copy_src.prefersDedicatedAllocation; + requiresDedicatedAllocation = copy_src.requiresDedicatedAllocation; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryDedicatedRequirements& safe_VkMemoryDedicatedRequirements::operator=( + const safe_VkMemoryDedicatedRequirements& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + prefersDedicatedAllocation = copy_src.prefersDedicatedAllocation; + requiresDedicatedAllocation = copy_src.requiresDedicatedAllocation; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryDedicatedRequirements::~safe_VkMemoryDedicatedRequirements() { FreePnextChain(pNext); } + +void safe_VkMemoryDedicatedRequirements::initialize(const VkMemoryDedicatedRequirements* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + prefersDedicatedAllocation = in_struct->prefersDedicatedAllocation; + requiresDedicatedAllocation = in_struct->requiresDedicatedAllocation; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryDedicatedRequirements::initialize(const safe_VkMemoryDedicatedRequirements* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + prefersDedicatedAllocation = copy_src->prefersDedicatedAllocation; + requiresDedicatedAllocation = copy_src->requiresDedicatedAllocation; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMemoryDedicatedAllocateInfo::safe_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), image(in_struct->image), buffer(in_struct->buffer) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMemoryDedicatedAllocateInfo::safe_VkMemoryDedicatedAllocateInfo() + : sType(VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO), pNext(nullptr), image(), buffer() {} + +safe_VkMemoryDedicatedAllocateInfo::safe_VkMemoryDedicatedAllocateInfo(const safe_VkMemoryDedicatedAllocateInfo& copy_src) { + sType = copy_src.sType; + image = copy_src.image; + buffer = copy_src.buffer; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryDedicatedAllocateInfo& safe_VkMemoryDedicatedAllocateInfo::operator=( + const safe_VkMemoryDedicatedAllocateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + image = copy_src.image; + buffer = copy_src.buffer; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryDedicatedAllocateInfo::~safe_VkMemoryDedicatedAllocateInfo() { FreePnextChain(pNext); } + +void safe_VkMemoryDedicatedAllocateInfo::initialize(const VkMemoryDedicatedAllocateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + image = in_struct->image; + buffer = in_struct->buffer; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryDedicatedAllocateInfo::initialize(const safe_VkMemoryDedicatedAllocateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + image = copy_src->image; + buffer = copy_src->buffer; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMemoryAllocateFlagsInfo::safe_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), deviceMask(in_struct->deviceMask) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMemoryAllocateFlagsInfo::safe_VkMemoryAllocateFlagsInfo() + : sType(VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO), pNext(nullptr), flags(), deviceMask() {} + +safe_VkMemoryAllocateFlagsInfo::safe_VkMemoryAllocateFlagsInfo(const safe_VkMemoryAllocateFlagsInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + deviceMask = copy_src.deviceMask; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryAllocateFlagsInfo& safe_VkMemoryAllocateFlagsInfo::operator=(const safe_VkMemoryAllocateFlagsInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + deviceMask = copy_src.deviceMask; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryAllocateFlagsInfo::~safe_VkMemoryAllocateFlagsInfo() { FreePnextChain(pNext); } + +void safe_VkMemoryAllocateFlagsInfo::initialize(const VkMemoryAllocateFlagsInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + deviceMask = in_struct->deviceMask; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryAllocateFlagsInfo::initialize(const safe_VkMemoryAllocateFlagsInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + deviceMask = copy_src->deviceMask; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDeviceGroupRenderPassBeginInfo::safe_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + deviceMask(in_struct->deviceMask), + deviceRenderAreaCount(in_struct->deviceRenderAreaCount), + pDeviceRenderAreas(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pDeviceRenderAreas) { + pDeviceRenderAreas = new VkRect2D[in_struct->deviceRenderAreaCount]; + memcpy((void*)pDeviceRenderAreas, (void*)in_struct->pDeviceRenderAreas, + sizeof(VkRect2D) * in_struct->deviceRenderAreaCount); + } +} + +safe_VkDeviceGroupRenderPassBeginInfo::safe_VkDeviceGroupRenderPassBeginInfo() + : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO), + pNext(nullptr), + deviceMask(), + deviceRenderAreaCount(), + pDeviceRenderAreas(nullptr) {} + +safe_VkDeviceGroupRenderPassBeginInfo::safe_VkDeviceGroupRenderPassBeginInfo( + const safe_VkDeviceGroupRenderPassBeginInfo& copy_src) { + sType = copy_src.sType; + deviceMask = copy_src.deviceMask; + deviceRenderAreaCount = copy_src.deviceRenderAreaCount; + pDeviceRenderAreas = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDeviceRenderAreas) { + pDeviceRenderAreas = new VkRect2D[copy_src.deviceRenderAreaCount]; + memcpy((void*)pDeviceRenderAreas, (void*)copy_src.pDeviceRenderAreas, sizeof(VkRect2D) * copy_src.deviceRenderAreaCount); + } +} + +safe_VkDeviceGroupRenderPassBeginInfo& safe_VkDeviceGroupRenderPassBeginInfo::operator=( + const safe_VkDeviceGroupRenderPassBeginInfo& copy_src) { + if (©_src == this) return *this; + + if (pDeviceRenderAreas) delete[] pDeviceRenderAreas; + FreePnextChain(pNext); + + sType = copy_src.sType; + deviceMask = copy_src.deviceMask; + deviceRenderAreaCount = copy_src.deviceRenderAreaCount; + pDeviceRenderAreas = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDeviceRenderAreas) { + pDeviceRenderAreas = new VkRect2D[copy_src.deviceRenderAreaCount]; + memcpy((void*)pDeviceRenderAreas, (void*)copy_src.pDeviceRenderAreas, sizeof(VkRect2D) * copy_src.deviceRenderAreaCount); + } + + return *this; +} + +safe_VkDeviceGroupRenderPassBeginInfo::~safe_VkDeviceGroupRenderPassBeginInfo() { + if (pDeviceRenderAreas) delete[] pDeviceRenderAreas; + FreePnextChain(pNext); +} + +void safe_VkDeviceGroupRenderPassBeginInfo::initialize(const VkDeviceGroupRenderPassBeginInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDeviceRenderAreas) delete[] pDeviceRenderAreas; + FreePnextChain(pNext); + sType = in_struct->sType; + deviceMask = in_struct->deviceMask; + deviceRenderAreaCount = in_struct->deviceRenderAreaCount; + pDeviceRenderAreas = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pDeviceRenderAreas) { + pDeviceRenderAreas = new VkRect2D[in_struct->deviceRenderAreaCount]; + memcpy((void*)pDeviceRenderAreas, (void*)in_struct->pDeviceRenderAreas, + sizeof(VkRect2D) * in_struct->deviceRenderAreaCount); + } +} + +void safe_VkDeviceGroupRenderPassBeginInfo::initialize(const safe_VkDeviceGroupRenderPassBeginInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + deviceMask = copy_src->deviceMask; + deviceRenderAreaCount = copy_src->deviceRenderAreaCount; + pDeviceRenderAreas = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pDeviceRenderAreas) { + pDeviceRenderAreas = new VkRect2D[copy_src->deviceRenderAreaCount]; + memcpy((void*)pDeviceRenderAreas, (void*)copy_src->pDeviceRenderAreas, sizeof(VkRect2D) * copy_src->deviceRenderAreaCount); + } +} + +safe_VkDeviceGroupCommandBufferBeginInfo::safe_VkDeviceGroupCommandBufferBeginInfo( + const VkDeviceGroupCommandBufferBeginInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), deviceMask(in_struct->deviceMask) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDeviceGroupCommandBufferBeginInfo::safe_VkDeviceGroupCommandBufferBeginInfo() + : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO), pNext(nullptr), deviceMask() {} + +safe_VkDeviceGroupCommandBufferBeginInfo::safe_VkDeviceGroupCommandBufferBeginInfo( + const safe_VkDeviceGroupCommandBufferBeginInfo& copy_src) { + sType = copy_src.sType; + deviceMask = copy_src.deviceMask; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDeviceGroupCommandBufferBeginInfo& safe_VkDeviceGroupCommandBufferBeginInfo::operator=( + const safe_VkDeviceGroupCommandBufferBeginInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + deviceMask = copy_src.deviceMask; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDeviceGroupCommandBufferBeginInfo::~safe_VkDeviceGroupCommandBufferBeginInfo() { FreePnextChain(pNext); } + +void safe_VkDeviceGroupCommandBufferBeginInfo::initialize(const VkDeviceGroupCommandBufferBeginInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + deviceMask = in_struct->deviceMask; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDeviceGroupCommandBufferBeginInfo::initialize(const safe_VkDeviceGroupCommandBufferBeginInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + deviceMask = copy_src->deviceMask; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDeviceGroupSubmitInfo::safe_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + waitSemaphoreCount(in_struct->waitSemaphoreCount), + pWaitSemaphoreDeviceIndices(nullptr), + commandBufferCount(in_struct->commandBufferCount), + pCommandBufferDeviceMasks(nullptr), + signalSemaphoreCount(in_struct->signalSemaphoreCount), + pSignalSemaphoreDeviceIndices(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pWaitSemaphoreDeviceIndices) { + pWaitSemaphoreDeviceIndices = new uint32_t[in_struct->waitSemaphoreCount]; + memcpy((void*)pWaitSemaphoreDeviceIndices, (void*)in_struct->pWaitSemaphoreDeviceIndices, + sizeof(uint32_t) * in_struct->waitSemaphoreCount); + } + + if (in_struct->pCommandBufferDeviceMasks) { + pCommandBufferDeviceMasks = new uint32_t[in_struct->commandBufferCount]; + memcpy((void*)pCommandBufferDeviceMasks, (void*)in_struct->pCommandBufferDeviceMasks, + sizeof(uint32_t) * in_struct->commandBufferCount); + } + + if (in_struct->pSignalSemaphoreDeviceIndices) { + pSignalSemaphoreDeviceIndices = new uint32_t[in_struct->signalSemaphoreCount]; + memcpy((void*)pSignalSemaphoreDeviceIndices, (void*)in_struct->pSignalSemaphoreDeviceIndices, + sizeof(uint32_t) * in_struct->signalSemaphoreCount); + } +} + +safe_VkDeviceGroupSubmitInfo::safe_VkDeviceGroupSubmitInfo() + : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO), + pNext(nullptr), + waitSemaphoreCount(), + pWaitSemaphoreDeviceIndices(nullptr), + commandBufferCount(), + pCommandBufferDeviceMasks(nullptr), + signalSemaphoreCount(), + pSignalSemaphoreDeviceIndices(nullptr) {} + +safe_VkDeviceGroupSubmitInfo::safe_VkDeviceGroupSubmitInfo(const safe_VkDeviceGroupSubmitInfo& copy_src) { + sType = copy_src.sType; + waitSemaphoreCount = copy_src.waitSemaphoreCount; + pWaitSemaphoreDeviceIndices = nullptr; + commandBufferCount = copy_src.commandBufferCount; + pCommandBufferDeviceMasks = nullptr; + signalSemaphoreCount = copy_src.signalSemaphoreCount; + pSignalSemaphoreDeviceIndices = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pWaitSemaphoreDeviceIndices) { + pWaitSemaphoreDeviceIndices = new uint32_t[copy_src.waitSemaphoreCount]; + memcpy((void*)pWaitSemaphoreDeviceIndices, (void*)copy_src.pWaitSemaphoreDeviceIndices, + sizeof(uint32_t) * copy_src.waitSemaphoreCount); + } + + if (copy_src.pCommandBufferDeviceMasks) { + pCommandBufferDeviceMasks = new uint32_t[copy_src.commandBufferCount]; + memcpy((void*)pCommandBufferDeviceMasks, (void*)copy_src.pCommandBufferDeviceMasks, + sizeof(uint32_t) * copy_src.commandBufferCount); + } + + if (copy_src.pSignalSemaphoreDeviceIndices) { + pSignalSemaphoreDeviceIndices = new uint32_t[copy_src.signalSemaphoreCount]; + memcpy((void*)pSignalSemaphoreDeviceIndices, (void*)copy_src.pSignalSemaphoreDeviceIndices, + sizeof(uint32_t) * copy_src.signalSemaphoreCount); + } +} + +safe_VkDeviceGroupSubmitInfo& safe_VkDeviceGroupSubmitInfo::operator=(const safe_VkDeviceGroupSubmitInfo& copy_src) { + if (©_src == this) return *this; + + if (pWaitSemaphoreDeviceIndices) delete[] pWaitSemaphoreDeviceIndices; + if (pCommandBufferDeviceMasks) delete[] pCommandBufferDeviceMasks; + if (pSignalSemaphoreDeviceIndices) delete[] pSignalSemaphoreDeviceIndices; + FreePnextChain(pNext); + + sType = copy_src.sType; + waitSemaphoreCount = copy_src.waitSemaphoreCount; + pWaitSemaphoreDeviceIndices = nullptr; + commandBufferCount = copy_src.commandBufferCount; + pCommandBufferDeviceMasks = nullptr; + signalSemaphoreCount = copy_src.signalSemaphoreCount; + pSignalSemaphoreDeviceIndices = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pWaitSemaphoreDeviceIndices) { + pWaitSemaphoreDeviceIndices = new uint32_t[copy_src.waitSemaphoreCount]; + memcpy((void*)pWaitSemaphoreDeviceIndices, (void*)copy_src.pWaitSemaphoreDeviceIndices, + sizeof(uint32_t) * copy_src.waitSemaphoreCount); + } + + if (copy_src.pCommandBufferDeviceMasks) { + pCommandBufferDeviceMasks = new uint32_t[copy_src.commandBufferCount]; + memcpy((void*)pCommandBufferDeviceMasks, (void*)copy_src.pCommandBufferDeviceMasks, + sizeof(uint32_t) * copy_src.commandBufferCount); + } + + if (copy_src.pSignalSemaphoreDeviceIndices) { + pSignalSemaphoreDeviceIndices = new uint32_t[copy_src.signalSemaphoreCount]; + memcpy((void*)pSignalSemaphoreDeviceIndices, (void*)copy_src.pSignalSemaphoreDeviceIndices, + sizeof(uint32_t) * copy_src.signalSemaphoreCount); + } + + return *this; +} + +safe_VkDeviceGroupSubmitInfo::~safe_VkDeviceGroupSubmitInfo() { + if (pWaitSemaphoreDeviceIndices) delete[] pWaitSemaphoreDeviceIndices; + if (pCommandBufferDeviceMasks) delete[] pCommandBufferDeviceMasks; + if (pSignalSemaphoreDeviceIndices) delete[] pSignalSemaphoreDeviceIndices; + FreePnextChain(pNext); +} + +void safe_VkDeviceGroupSubmitInfo::initialize(const VkDeviceGroupSubmitInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pWaitSemaphoreDeviceIndices) delete[] pWaitSemaphoreDeviceIndices; + if (pCommandBufferDeviceMasks) delete[] pCommandBufferDeviceMasks; + if (pSignalSemaphoreDeviceIndices) delete[] pSignalSemaphoreDeviceIndices; + FreePnextChain(pNext); + sType = in_struct->sType; + waitSemaphoreCount = in_struct->waitSemaphoreCount; + pWaitSemaphoreDeviceIndices = nullptr; + commandBufferCount = in_struct->commandBufferCount; + pCommandBufferDeviceMasks = nullptr; + signalSemaphoreCount = in_struct->signalSemaphoreCount; + pSignalSemaphoreDeviceIndices = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pWaitSemaphoreDeviceIndices) { + pWaitSemaphoreDeviceIndices = new uint32_t[in_struct->waitSemaphoreCount]; + memcpy((void*)pWaitSemaphoreDeviceIndices, (void*)in_struct->pWaitSemaphoreDeviceIndices, + sizeof(uint32_t) * in_struct->waitSemaphoreCount); + } + + if (in_struct->pCommandBufferDeviceMasks) { + pCommandBufferDeviceMasks = new uint32_t[in_struct->commandBufferCount]; + memcpy((void*)pCommandBufferDeviceMasks, (void*)in_struct->pCommandBufferDeviceMasks, + sizeof(uint32_t) * in_struct->commandBufferCount); + } + + if (in_struct->pSignalSemaphoreDeviceIndices) { + pSignalSemaphoreDeviceIndices = new uint32_t[in_struct->signalSemaphoreCount]; + memcpy((void*)pSignalSemaphoreDeviceIndices, (void*)in_struct->pSignalSemaphoreDeviceIndices, + sizeof(uint32_t) * in_struct->signalSemaphoreCount); + } +} + +void safe_VkDeviceGroupSubmitInfo::initialize(const safe_VkDeviceGroupSubmitInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + waitSemaphoreCount = copy_src->waitSemaphoreCount; + pWaitSemaphoreDeviceIndices = nullptr; + commandBufferCount = copy_src->commandBufferCount; + pCommandBufferDeviceMasks = nullptr; + signalSemaphoreCount = copy_src->signalSemaphoreCount; + pSignalSemaphoreDeviceIndices = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pWaitSemaphoreDeviceIndices) { + pWaitSemaphoreDeviceIndices = new uint32_t[copy_src->waitSemaphoreCount]; + memcpy((void*)pWaitSemaphoreDeviceIndices, (void*)copy_src->pWaitSemaphoreDeviceIndices, + sizeof(uint32_t) * copy_src->waitSemaphoreCount); + } + + if (copy_src->pCommandBufferDeviceMasks) { + pCommandBufferDeviceMasks = new uint32_t[copy_src->commandBufferCount]; + memcpy((void*)pCommandBufferDeviceMasks, (void*)copy_src->pCommandBufferDeviceMasks, + sizeof(uint32_t) * copy_src->commandBufferCount); + } + + if (copy_src->pSignalSemaphoreDeviceIndices) { + pSignalSemaphoreDeviceIndices = new uint32_t[copy_src->signalSemaphoreCount]; + memcpy((void*)pSignalSemaphoreDeviceIndices, (void*)copy_src->pSignalSemaphoreDeviceIndices, + sizeof(uint32_t) * copy_src->signalSemaphoreCount); + } +} + +safe_VkDeviceGroupBindSparseInfo::safe_VkDeviceGroupBindSparseInfo(const VkDeviceGroupBindSparseInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + resourceDeviceIndex(in_struct->resourceDeviceIndex), + memoryDeviceIndex(in_struct->memoryDeviceIndex) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDeviceGroupBindSparseInfo::safe_VkDeviceGroupBindSparseInfo() + : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO), pNext(nullptr), resourceDeviceIndex(), memoryDeviceIndex() {} + +safe_VkDeviceGroupBindSparseInfo::safe_VkDeviceGroupBindSparseInfo(const safe_VkDeviceGroupBindSparseInfo& copy_src) { + sType = copy_src.sType; + resourceDeviceIndex = copy_src.resourceDeviceIndex; + memoryDeviceIndex = copy_src.memoryDeviceIndex; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDeviceGroupBindSparseInfo& safe_VkDeviceGroupBindSparseInfo::operator=(const safe_VkDeviceGroupBindSparseInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + resourceDeviceIndex = copy_src.resourceDeviceIndex; + memoryDeviceIndex = copy_src.memoryDeviceIndex; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDeviceGroupBindSparseInfo::~safe_VkDeviceGroupBindSparseInfo() { FreePnextChain(pNext); } + +void safe_VkDeviceGroupBindSparseInfo::initialize(const VkDeviceGroupBindSparseInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + resourceDeviceIndex = in_struct->resourceDeviceIndex; + memoryDeviceIndex = in_struct->memoryDeviceIndex; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDeviceGroupBindSparseInfo::initialize(const safe_VkDeviceGroupBindSparseInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + resourceDeviceIndex = copy_src->resourceDeviceIndex; + memoryDeviceIndex = copy_src->memoryDeviceIndex; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBindBufferMemoryDeviceGroupInfo::safe_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), deviceIndexCount(in_struct->deviceIndexCount), pDeviceIndices(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pDeviceIndices) { + pDeviceIndices = new uint32_t[in_struct->deviceIndexCount]; + memcpy((void*)pDeviceIndices, (void*)in_struct->pDeviceIndices, sizeof(uint32_t) * in_struct->deviceIndexCount); + } +} + +safe_VkBindBufferMemoryDeviceGroupInfo::safe_VkBindBufferMemoryDeviceGroupInfo() + : sType(VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO), pNext(nullptr), deviceIndexCount(), pDeviceIndices(nullptr) {} + +safe_VkBindBufferMemoryDeviceGroupInfo::safe_VkBindBufferMemoryDeviceGroupInfo( + const safe_VkBindBufferMemoryDeviceGroupInfo& copy_src) { + sType = copy_src.sType; + deviceIndexCount = copy_src.deviceIndexCount; + pDeviceIndices = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDeviceIndices) { + pDeviceIndices = new uint32_t[copy_src.deviceIndexCount]; + memcpy((void*)pDeviceIndices, (void*)copy_src.pDeviceIndices, sizeof(uint32_t) * copy_src.deviceIndexCount); + } +} + +safe_VkBindBufferMemoryDeviceGroupInfo& safe_VkBindBufferMemoryDeviceGroupInfo::operator=( + const safe_VkBindBufferMemoryDeviceGroupInfo& copy_src) { + if (©_src == this) return *this; + + if (pDeviceIndices) delete[] pDeviceIndices; + FreePnextChain(pNext); + + sType = copy_src.sType; + deviceIndexCount = copy_src.deviceIndexCount; + pDeviceIndices = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDeviceIndices) { + pDeviceIndices = new uint32_t[copy_src.deviceIndexCount]; + memcpy((void*)pDeviceIndices, (void*)copy_src.pDeviceIndices, sizeof(uint32_t) * copy_src.deviceIndexCount); + } + + return *this; +} + +safe_VkBindBufferMemoryDeviceGroupInfo::~safe_VkBindBufferMemoryDeviceGroupInfo() { + if (pDeviceIndices) delete[] pDeviceIndices; + FreePnextChain(pNext); +} + +void safe_VkBindBufferMemoryDeviceGroupInfo::initialize(const VkBindBufferMemoryDeviceGroupInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDeviceIndices) delete[] pDeviceIndices; + FreePnextChain(pNext); + sType = in_struct->sType; + deviceIndexCount = in_struct->deviceIndexCount; + pDeviceIndices = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pDeviceIndices) { + pDeviceIndices = new uint32_t[in_struct->deviceIndexCount]; + memcpy((void*)pDeviceIndices, (void*)in_struct->pDeviceIndices, sizeof(uint32_t) * in_struct->deviceIndexCount); + } +} + +void safe_VkBindBufferMemoryDeviceGroupInfo::initialize(const safe_VkBindBufferMemoryDeviceGroupInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + deviceIndexCount = copy_src->deviceIndexCount; + pDeviceIndices = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pDeviceIndices) { + pDeviceIndices = new uint32_t[copy_src->deviceIndexCount]; + memcpy((void*)pDeviceIndices, (void*)copy_src->pDeviceIndices, sizeof(uint32_t) * copy_src->deviceIndexCount); + } +} + +safe_VkBindImageMemoryDeviceGroupInfo::safe_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + deviceIndexCount(in_struct->deviceIndexCount), + pDeviceIndices(nullptr), + splitInstanceBindRegionCount(in_struct->splitInstanceBindRegionCount), + pSplitInstanceBindRegions(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pDeviceIndices) { + pDeviceIndices = new uint32_t[in_struct->deviceIndexCount]; + memcpy((void*)pDeviceIndices, (void*)in_struct->pDeviceIndices, sizeof(uint32_t) * in_struct->deviceIndexCount); + } + + if (in_struct->pSplitInstanceBindRegions) { + pSplitInstanceBindRegions = new VkRect2D[in_struct->splitInstanceBindRegionCount]; + memcpy((void*)pSplitInstanceBindRegions, (void*)in_struct->pSplitInstanceBindRegions, + sizeof(VkRect2D) * in_struct->splitInstanceBindRegionCount); + } +} + +safe_VkBindImageMemoryDeviceGroupInfo::safe_VkBindImageMemoryDeviceGroupInfo() + : sType(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO), + pNext(nullptr), + deviceIndexCount(), + pDeviceIndices(nullptr), + splitInstanceBindRegionCount(), + pSplitInstanceBindRegions(nullptr) {} + +safe_VkBindImageMemoryDeviceGroupInfo::safe_VkBindImageMemoryDeviceGroupInfo( + const safe_VkBindImageMemoryDeviceGroupInfo& copy_src) { + sType = copy_src.sType; + deviceIndexCount = copy_src.deviceIndexCount; + pDeviceIndices = nullptr; + splitInstanceBindRegionCount = copy_src.splitInstanceBindRegionCount; + pSplitInstanceBindRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDeviceIndices) { + pDeviceIndices = new uint32_t[copy_src.deviceIndexCount]; + memcpy((void*)pDeviceIndices, (void*)copy_src.pDeviceIndices, sizeof(uint32_t) * copy_src.deviceIndexCount); + } + + if (copy_src.pSplitInstanceBindRegions) { + pSplitInstanceBindRegions = new VkRect2D[copy_src.splitInstanceBindRegionCount]; + memcpy((void*)pSplitInstanceBindRegions, (void*)copy_src.pSplitInstanceBindRegions, + sizeof(VkRect2D) * copy_src.splitInstanceBindRegionCount); + } +} + +safe_VkBindImageMemoryDeviceGroupInfo& safe_VkBindImageMemoryDeviceGroupInfo::operator=( + const safe_VkBindImageMemoryDeviceGroupInfo& copy_src) { + if (©_src == this) return *this; + + if (pDeviceIndices) delete[] pDeviceIndices; + if (pSplitInstanceBindRegions) delete[] pSplitInstanceBindRegions; + FreePnextChain(pNext); + + sType = copy_src.sType; + deviceIndexCount = copy_src.deviceIndexCount; + pDeviceIndices = nullptr; + splitInstanceBindRegionCount = copy_src.splitInstanceBindRegionCount; + pSplitInstanceBindRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDeviceIndices) { + pDeviceIndices = new uint32_t[copy_src.deviceIndexCount]; + memcpy((void*)pDeviceIndices, (void*)copy_src.pDeviceIndices, sizeof(uint32_t) * copy_src.deviceIndexCount); + } + + if (copy_src.pSplitInstanceBindRegions) { + pSplitInstanceBindRegions = new VkRect2D[copy_src.splitInstanceBindRegionCount]; + memcpy((void*)pSplitInstanceBindRegions, (void*)copy_src.pSplitInstanceBindRegions, + sizeof(VkRect2D) * copy_src.splitInstanceBindRegionCount); + } + + return *this; +} + +safe_VkBindImageMemoryDeviceGroupInfo::~safe_VkBindImageMemoryDeviceGroupInfo() { + if (pDeviceIndices) delete[] pDeviceIndices; + if (pSplitInstanceBindRegions) delete[] pSplitInstanceBindRegions; + FreePnextChain(pNext); +} + +void safe_VkBindImageMemoryDeviceGroupInfo::initialize(const VkBindImageMemoryDeviceGroupInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDeviceIndices) delete[] pDeviceIndices; + if (pSplitInstanceBindRegions) delete[] pSplitInstanceBindRegions; + FreePnextChain(pNext); + sType = in_struct->sType; + deviceIndexCount = in_struct->deviceIndexCount; + pDeviceIndices = nullptr; + splitInstanceBindRegionCount = in_struct->splitInstanceBindRegionCount; + pSplitInstanceBindRegions = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pDeviceIndices) { + pDeviceIndices = new uint32_t[in_struct->deviceIndexCount]; + memcpy((void*)pDeviceIndices, (void*)in_struct->pDeviceIndices, sizeof(uint32_t) * in_struct->deviceIndexCount); + } + + if (in_struct->pSplitInstanceBindRegions) { + pSplitInstanceBindRegions = new VkRect2D[in_struct->splitInstanceBindRegionCount]; + memcpy((void*)pSplitInstanceBindRegions, (void*)in_struct->pSplitInstanceBindRegions, + sizeof(VkRect2D) * in_struct->splitInstanceBindRegionCount); + } +} + +void safe_VkBindImageMemoryDeviceGroupInfo::initialize(const safe_VkBindImageMemoryDeviceGroupInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + deviceIndexCount = copy_src->deviceIndexCount; + pDeviceIndices = nullptr; + splitInstanceBindRegionCount = copy_src->splitInstanceBindRegionCount; + pSplitInstanceBindRegions = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pDeviceIndices) { + pDeviceIndices = new uint32_t[copy_src->deviceIndexCount]; + memcpy((void*)pDeviceIndices, (void*)copy_src->pDeviceIndices, sizeof(uint32_t) * copy_src->deviceIndexCount); + } + + if (copy_src->pSplitInstanceBindRegions) { + pSplitInstanceBindRegions = new VkRect2D[copy_src->splitInstanceBindRegionCount]; + memcpy((void*)pSplitInstanceBindRegions, (void*)copy_src->pSplitInstanceBindRegions, + sizeof(VkRect2D) * copy_src->splitInstanceBindRegionCount); + } +} + +safe_VkPhysicalDeviceGroupProperties::safe_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), physicalDeviceCount(in_struct->physicalDeviceCount), subsetAllocation(in_struct->subsetAllocation) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) { + physicalDevices[i] = in_struct->physicalDevices[i]; + } +} + +safe_VkPhysicalDeviceGroupProperties::safe_VkPhysicalDeviceGroupProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES), pNext(nullptr), physicalDeviceCount(), subsetAllocation() {} + +safe_VkPhysicalDeviceGroupProperties::safe_VkPhysicalDeviceGroupProperties(const safe_VkPhysicalDeviceGroupProperties& copy_src) { + sType = copy_src.sType; + physicalDeviceCount = copy_src.physicalDeviceCount; + subsetAllocation = copy_src.subsetAllocation; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) { + physicalDevices[i] = copy_src.physicalDevices[i]; + } +} + +safe_VkPhysicalDeviceGroupProperties& safe_VkPhysicalDeviceGroupProperties::operator=( + const safe_VkPhysicalDeviceGroupProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + physicalDeviceCount = copy_src.physicalDeviceCount; + subsetAllocation = copy_src.subsetAllocation; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) { + physicalDevices[i] = copy_src.physicalDevices[i]; + } + + return *this; +} + +safe_VkPhysicalDeviceGroupProperties::~safe_VkPhysicalDeviceGroupProperties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceGroupProperties::initialize(const VkPhysicalDeviceGroupProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + physicalDeviceCount = in_struct->physicalDeviceCount; + subsetAllocation = in_struct->subsetAllocation; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) { + physicalDevices[i] = in_struct->physicalDevices[i]; + } +} + +void safe_VkPhysicalDeviceGroupProperties::initialize(const safe_VkPhysicalDeviceGroupProperties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + physicalDeviceCount = copy_src->physicalDeviceCount; + subsetAllocation = copy_src->subsetAllocation; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) { + physicalDevices[i] = copy_src->physicalDevices[i]; + } +} + +safe_VkDeviceGroupDeviceCreateInfo::safe_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), physicalDeviceCount(in_struct->physicalDeviceCount), pPhysicalDevices(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pPhysicalDevices) { + pPhysicalDevices = new VkPhysicalDevice[in_struct->physicalDeviceCount]; + memcpy((void*)pPhysicalDevices, (void*)in_struct->pPhysicalDevices, + sizeof(VkPhysicalDevice) * in_struct->physicalDeviceCount); + } +} + +safe_VkDeviceGroupDeviceCreateInfo::safe_VkDeviceGroupDeviceCreateInfo() + : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO), pNext(nullptr), physicalDeviceCount(), pPhysicalDevices(nullptr) {} + +safe_VkDeviceGroupDeviceCreateInfo::safe_VkDeviceGroupDeviceCreateInfo(const safe_VkDeviceGroupDeviceCreateInfo& copy_src) { + sType = copy_src.sType; + physicalDeviceCount = copy_src.physicalDeviceCount; + pPhysicalDevices = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPhysicalDevices) { + pPhysicalDevices = new VkPhysicalDevice[copy_src.physicalDeviceCount]; + memcpy((void*)pPhysicalDevices, (void*)copy_src.pPhysicalDevices, sizeof(VkPhysicalDevice) * copy_src.physicalDeviceCount); + } +} + +safe_VkDeviceGroupDeviceCreateInfo& safe_VkDeviceGroupDeviceCreateInfo::operator=( + const safe_VkDeviceGroupDeviceCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pPhysicalDevices) delete[] pPhysicalDevices; + FreePnextChain(pNext); + + sType = copy_src.sType; + physicalDeviceCount = copy_src.physicalDeviceCount; + pPhysicalDevices = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPhysicalDevices) { + pPhysicalDevices = new VkPhysicalDevice[copy_src.physicalDeviceCount]; + memcpy((void*)pPhysicalDevices, (void*)copy_src.pPhysicalDevices, sizeof(VkPhysicalDevice) * copy_src.physicalDeviceCount); + } + + return *this; +} + +safe_VkDeviceGroupDeviceCreateInfo::~safe_VkDeviceGroupDeviceCreateInfo() { + if (pPhysicalDevices) delete[] pPhysicalDevices; + FreePnextChain(pNext); +} + +void safe_VkDeviceGroupDeviceCreateInfo::initialize(const VkDeviceGroupDeviceCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPhysicalDevices) delete[] pPhysicalDevices; + FreePnextChain(pNext); + sType = in_struct->sType; + physicalDeviceCount = in_struct->physicalDeviceCount; + pPhysicalDevices = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pPhysicalDevices) { + pPhysicalDevices = new VkPhysicalDevice[in_struct->physicalDeviceCount]; + memcpy((void*)pPhysicalDevices, (void*)in_struct->pPhysicalDevices, + sizeof(VkPhysicalDevice) * in_struct->physicalDeviceCount); + } +} + +void safe_VkDeviceGroupDeviceCreateInfo::initialize(const safe_VkDeviceGroupDeviceCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + physicalDeviceCount = copy_src->physicalDeviceCount; + pPhysicalDevices = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pPhysicalDevices) { + pPhysicalDevices = new VkPhysicalDevice[copy_src->physicalDeviceCount]; + memcpy((void*)pPhysicalDevices, (void*)copy_src->pPhysicalDevices, + sizeof(VkPhysicalDevice) * copy_src->physicalDeviceCount); + } +} + +safe_VkBufferMemoryRequirementsInfo2::safe_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), buffer(in_struct->buffer) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBufferMemoryRequirementsInfo2::safe_VkBufferMemoryRequirementsInfo2() + : sType(VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2), pNext(nullptr), buffer() {} + +safe_VkBufferMemoryRequirementsInfo2::safe_VkBufferMemoryRequirementsInfo2(const safe_VkBufferMemoryRequirementsInfo2& copy_src) { + sType = copy_src.sType; + buffer = copy_src.buffer; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBufferMemoryRequirementsInfo2& safe_VkBufferMemoryRequirementsInfo2::operator=( + const safe_VkBufferMemoryRequirementsInfo2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + buffer = copy_src.buffer; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBufferMemoryRequirementsInfo2::~safe_VkBufferMemoryRequirementsInfo2() { FreePnextChain(pNext); } + +void safe_VkBufferMemoryRequirementsInfo2::initialize(const VkBufferMemoryRequirementsInfo2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + buffer = in_struct->buffer; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBufferMemoryRequirementsInfo2::initialize(const safe_VkBufferMemoryRequirementsInfo2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + buffer = copy_src->buffer; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImageMemoryRequirementsInfo2::safe_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), image(in_struct->image) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageMemoryRequirementsInfo2::safe_VkImageMemoryRequirementsInfo2() + : sType(VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2), pNext(nullptr), image() {} + +safe_VkImageMemoryRequirementsInfo2::safe_VkImageMemoryRequirementsInfo2(const safe_VkImageMemoryRequirementsInfo2& copy_src) { + sType = copy_src.sType; + image = copy_src.image; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageMemoryRequirementsInfo2& safe_VkImageMemoryRequirementsInfo2::operator=( + const safe_VkImageMemoryRequirementsInfo2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + image = copy_src.image; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageMemoryRequirementsInfo2::~safe_VkImageMemoryRequirementsInfo2() { FreePnextChain(pNext); } + +void safe_VkImageMemoryRequirementsInfo2::initialize(const VkImageMemoryRequirementsInfo2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + image = in_struct->image; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageMemoryRequirementsInfo2::initialize(const safe_VkImageMemoryRequirementsInfo2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + image = copy_src->image; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImageSparseMemoryRequirementsInfo2::safe_VkImageSparseMemoryRequirementsInfo2( + const VkImageSparseMemoryRequirementsInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), image(in_struct->image) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageSparseMemoryRequirementsInfo2::safe_VkImageSparseMemoryRequirementsInfo2() + : sType(VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2), pNext(nullptr), image() {} + +safe_VkImageSparseMemoryRequirementsInfo2::safe_VkImageSparseMemoryRequirementsInfo2( + const safe_VkImageSparseMemoryRequirementsInfo2& copy_src) { + sType = copy_src.sType; + image = copy_src.image; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageSparseMemoryRequirementsInfo2& safe_VkImageSparseMemoryRequirementsInfo2::operator=( + const safe_VkImageSparseMemoryRequirementsInfo2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + image = copy_src.image; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageSparseMemoryRequirementsInfo2::~safe_VkImageSparseMemoryRequirementsInfo2() { FreePnextChain(pNext); } + +void safe_VkImageSparseMemoryRequirementsInfo2::initialize(const VkImageSparseMemoryRequirementsInfo2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + image = in_struct->image; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageSparseMemoryRequirementsInfo2::initialize(const safe_VkImageSparseMemoryRequirementsInfo2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + image = copy_src->image; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMemoryRequirements2::safe_VkMemoryRequirements2(const VkMemoryRequirements2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), memoryRequirements(in_struct->memoryRequirements) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMemoryRequirements2::safe_VkMemoryRequirements2() + : sType(VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2), pNext(nullptr), memoryRequirements() {} + +safe_VkMemoryRequirements2::safe_VkMemoryRequirements2(const safe_VkMemoryRequirements2& copy_src) { + sType = copy_src.sType; + memoryRequirements = copy_src.memoryRequirements; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryRequirements2& safe_VkMemoryRequirements2::operator=(const safe_VkMemoryRequirements2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memoryRequirements = copy_src.memoryRequirements; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryRequirements2::~safe_VkMemoryRequirements2() { FreePnextChain(pNext); } + +void safe_VkMemoryRequirements2::initialize(const VkMemoryRequirements2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memoryRequirements = in_struct->memoryRequirements; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryRequirements2::initialize(const safe_VkMemoryRequirements2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memoryRequirements = copy_src->memoryRequirements; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSparseImageMemoryRequirements2::safe_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), memoryRequirements(in_struct->memoryRequirements) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSparseImageMemoryRequirements2::safe_VkSparseImageMemoryRequirements2() + : sType(VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2), pNext(nullptr), memoryRequirements() {} + +safe_VkSparseImageMemoryRequirements2::safe_VkSparseImageMemoryRequirements2( + const safe_VkSparseImageMemoryRequirements2& copy_src) { + sType = copy_src.sType; + memoryRequirements = copy_src.memoryRequirements; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSparseImageMemoryRequirements2& safe_VkSparseImageMemoryRequirements2::operator=( + const safe_VkSparseImageMemoryRequirements2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memoryRequirements = copy_src.memoryRequirements; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSparseImageMemoryRequirements2::~safe_VkSparseImageMemoryRequirements2() { FreePnextChain(pNext); } + +void safe_VkSparseImageMemoryRequirements2::initialize(const VkSparseImageMemoryRequirements2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memoryRequirements = in_struct->memoryRequirements; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSparseImageMemoryRequirements2::initialize(const safe_VkSparseImageMemoryRequirements2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memoryRequirements = copy_src->memoryRequirements; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceFeatures2::safe_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), features(in_struct->features) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceFeatures2::safe_VkPhysicalDeviceFeatures2() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2), pNext(nullptr), features() {} + +safe_VkPhysicalDeviceFeatures2::safe_VkPhysicalDeviceFeatures2(const safe_VkPhysicalDeviceFeatures2& copy_src) { + sType = copy_src.sType; + features = copy_src.features; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceFeatures2& safe_VkPhysicalDeviceFeatures2::operator=(const safe_VkPhysicalDeviceFeatures2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + features = copy_src.features; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceFeatures2::~safe_VkPhysicalDeviceFeatures2() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceFeatures2::initialize(const VkPhysicalDeviceFeatures2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + features = in_struct->features; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceFeatures2::initialize(const safe_VkPhysicalDeviceFeatures2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + features = copy_src->features; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceProperties2::safe_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), properties(in_struct->properties) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceProperties2::safe_VkPhysicalDeviceProperties2() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2), pNext(nullptr), properties() {} + +safe_VkPhysicalDeviceProperties2::safe_VkPhysicalDeviceProperties2(const safe_VkPhysicalDeviceProperties2& copy_src) { + sType = copy_src.sType; + properties = copy_src.properties; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceProperties2& safe_VkPhysicalDeviceProperties2::operator=(const safe_VkPhysicalDeviceProperties2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + properties = copy_src.properties; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceProperties2::~safe_VkPhysicalDeviceProperties2() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceProperties2::initialize(const VkPhysicalDeviceProperties2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + properties = in_struct->properties; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceProperties2::initialize(const safe_VkPhysicalDeviceProperties2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + properties = copy_src->properties; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkFormatProperties2::safe_VkFormatProperties2(const VkFormatProperties2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), formatProperties(in_struct->formatProperties) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkFormatProperties2::safe_VkFormatProperties2() + : sType(VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2), pNext(nullptr), formatProperties() {} + +safe_VkFormatProperties2::safe_VkFormatProperties2(const safe_VkFormatProperties2& copy_src) { + sType = copy_src.sType; + formatProperties = copy_src.formatProperties; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkFormatProperties2& safe_VkFormatProperties2::operator=(const safe_VkFormatProperties2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + formatProperties = copy_src.formatProperties; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkFormatProperties2::~safe_VkFormatProperties2() { FreePnextChain(pNext); } + +void safe_VkFormatProperties2::initialize(const VkFormatProperties2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + formatProperties = in_struct->formatProperties; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkFormatProperties2::initialize(const safe_VkFormatProperties2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + formatProperties = copy_src->formatProperties; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImageFormatProperties2::safe_VkImageFormatProperties2(const VkImageFormatProperties2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), imageFormatProperties(in_struct->imageFormatProperties) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageFormatProperties2::safe_VkImageFormatProperties2() + : sType(VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2), pNext(nullptr), imageFormatProperties() {} + +safe_VkImageFormatProperties2::safe_VkImageFormatProperties2(const safe_VkImageFormatProperties2& copy_src) { + sType = copy_src.sType; + imageFormatProperties = copy_src.imageFormatProperties; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageFormatProperties2& safe_VkImageFormatProperties2::operator=(const safe_VkImageFormatProperties2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + imageFormatProperties = copy_src.imageFormatProperties; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageFormatProperties2::~safe_VkImageFormatProperties2() { FreePnextChain(pNext); } + +void safe_VkImageFormatProperties2::initialize(const VkImageFormatProperties2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + imageFormatProperties = in_struct->imageFormatProperties; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageFormatProperties2::initialize(const safe_VkImageFormatProperties2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + imageFormatProperties = copy_src->imageFormatProperties; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceImageFormatInfo2::safe_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + format(in_struct->format), + type(in_struct->type), + tiling(in_struct->tiling), + usage(in_struct->usage), + flags(in_struct->flags) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceImageFormatInfo2::safe_VkPhysicalDeviceImageFormatInfo2() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2), pNext(nullptr), format(), type(), tiling(), usage(), flags() {} + +safe_VkPhysicalDeviceImageFormatInfo2::safe_VkPhysicalDeviceImageFormatInfo2( + const safe_VkPhysicalDeviceImageFormatInfo2& copy_src) { + sType = copy_src.sType; + format = copy_src.format; + type = copy_src.type; + tiling = copy_src.tiling; + usage = copy_src.usage; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceImageFormatInfo2& safe_VkPhysicalDeviceImageFormatInfo2::operator=( + const safe_VkPhysicalDeviceImageFormatInfo2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + format = copy_src.format; + type = copy_src.type; + tiling = copy_src.tiling; + usage = copy_src.usage; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceImageFormatInfo2::~safe_VkPhysicalDeviceImageFormatInfo2() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceImageFormatInfo2::initialize(const VkPhysicalDeviceImageFormatInfo2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + format = in_struct->format; + type = in_struct->type; + tiling = in_struct->tiling; + usage = in_struct->usage; + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceImageFormatInfo2::initialize(const safe_VkPhysicalDeviceImageFormatInfo2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + format = copy_src->format; + type = copy_src->type; + tiling = copy_src->tiling; + usage = copy_src->usage; + flags = copy_src->flags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkQueueFamilyProperties2::safe_VkQueueFamilyProperties2(const VkQueueFamilyProperties2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), queueFamilyProperties(in_struct->queueFamilyProperties) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkQueueFamilyProperties2::safe_VkQueueFamilyProperties2() + : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2), pNext(nullptr), queueFamilyProperties() {} + +safe_VkQueueFamilyProperties2::safe_VkQueueFamilyProperties2(const safe_VkQueueFamilyProperties2& copy_src) { + sType = copy_src.sType; + queueFamilyProperties = copy_src.queueFamilyProperties; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkQueueFamilyProperties2& safe_VkQueueFamilyProperties2::operator=(const safe_VkQueueFamilyProperties2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + queueFamilyProperties = copy_src.queueFamilyProperties; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkQueueFamilyProperties2::~safe_VkQueueFamilyProperties2() { FreePnextChain(pNext); } + +void safe_VkQueueFamilyProperties2::initialize(const VkQueueFamilyProperties2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + queueFamilyProperties = in_struct->queueFamilyProperties; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkQueueFamilyProperties2::initialize(const safe_VkQueueFamilyProperties2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + queueFamilyProperties = copy_src->queueFamilyProperties; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMemoryProperties2::safe_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), memoryProperties(in_struct->memoryProperties) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMemoryProperties2::safe_VkPhysicalDeviceMemoryProperties2() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2), pNext(nullptr), memoryProperties() {} + +safe_VkPhysicalDeviceMemoryProperties2::safe_VkPhysicalDeviceMemoryProperties2( + const safe_VkPhysicalDeviceMemoryProperties2& copy_src) { + sType = copy_src.sType; + memoryProperties = copy_src.memoryProperties; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMemoryProperties2& safe_VkPhysicalDeviceMemoryProperties2::operator=( + const safe_VkPhysicalDeviceMemoryProperties2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memoryProperties = copy_src.memoryProperties; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMemoryProperties2::~safe_VkPhysicalDeviceMemoryProperties2() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMemoryProperties2::initialize(const VkPhysicalDeviceMemoryProperties2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memoryProperties = in_struct->memoryProperties; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMemoryProperties2::initialize(const safe_VkPhysicalDeviceMemoryProperties2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memoryProperties = copy_src->memoryProperties; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSparseImageFormatProperties2::safe_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), properties(in_struct->properties) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSparseImageFormatProperties2::safe_VkSparseImageFormatProperties2() + : sType(VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2), pNext(nullptr), properties() {} + +safe_VkSparseImageFormatProperties2::safe_VkSparseImageFormatProperties2(const safe_VkSparseImageFormatProperties2& copy_src) { + sType = copy_src.sType; + properties = copy_src.properties; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSparseImageFormatProperties2& safe_VkSparseImageFormatProperties2::operator=( + const safe_VkSparseImageFormatProperties2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + properties = copy_src.properties; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSparseImageFormatProperties2::~safe_VkSparseImageFormatProperties2() { FreePnextChain(pNext); } + +void safe_VkSparseImageFormatProperties2::initialize(const VkSparseImageFormatProperties2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + properties = in_struct->properties; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSparseImageFormatProperties2::initialize(const safe_VkSparseImageFormatProperties2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + properties = copy_src->properties; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceSparseImageFormatInfo2::safe_VkPhysicalDeviceSparseImageFormatInfo2( + const VkPhysicalDeviceSparseImageFormatInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + format(in_struct->format), + type(in_struct->type), + samples(in_struct->samples), + usage(in_struct->usage), + tiling(in_struct->tiling) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceSparseImageFormatInfo2::safe_VkPhysicalDeviceSparseImageFormatInfo2() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2), + pNext(nullptr), + format(), + type(), + samples(), + usage(), + tiling() {} + +safe_VkPhysicalDeviceSparseImageFormatInfo2::safe_VkPhysicalDeviceSparseImageFormatInfo2( + const safe_VkPhysicalDeviceSparseImageFormatInfo2& copy_src) { + sType = copy_src.sType; + format = copy_src.format; + type = copy_src.type; + samples = copy_src.samples; + usage = copy_src.usage; + tiling = copy_src.tiling; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceSparseImageFormatInfo2& safe_VkPhysicalDeviceSparseImageFormatInfo2::operator=( + const safe_VkPhysicalDeviceSparseImageFormatInfo2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + format = copy_src.format; + type = copy_src.type; + samples = copy_src.samples; + usage = copy_src.usage; + tiling = copy_src.tiling; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceSparseImageFormatInfo2::~safe_VkPhysicalDeviceSparseImageFormatInfo2() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceSparseImageFormatInfo2::initialize(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + format = in_struct->format; + type = in_struct->type; + samples = in_struct->samples; + usage = in_struct->usage; + tiling = in_struct->tiling; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceSparseImageFormatInfo2::initialize(const safe_VkPhysicalDeviceSparseImageFormatInfo2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + format = copy_src->format; + type = copy_src->type; + samples = copy_src->samples; + usage = copy_src->usage; + tiling = copy_src->tiling; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePointClippingProperties::safe_VkPhysicalDevicePointClippingProperties( + const VkPhysicalDevicePointClippingProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pointClippingBehavior(in_struct->pointClippingBehavior) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePointClippingProperties::safe_VkPhysicalDevicePointClippingProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES), pNext(nullptr), pointClippingBehavior() {} + +safe_VkPhysicalDevicePointClippingProperties::safe_VkPhysicalDevicePointClippingProperties( + const safe_VkPhysicalDevicePointClippingProperties& copy_src) { + sType = copy_src.sType; + pointClippingBehavior = copy_src.pointClippingBehavior; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePointClippingProperties& safe_VkPhysicalDevicePointClippingProperties::operator=( + const safe_VkPhysicalDevicePointClippingProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pointClippingBehavior = copy_src.pointClippingBehavior; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePointClippingProperties::~safe_VkPhysicalDevicePointClippingProperties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePointClippingProperties::initialize(const VkPhysicalDevicePointClippingProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pointClippingBehavior = in_struct->pointClippingBehavior; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePointClippingProperties::initialize(const safe_VkPhysicalDevicePointClippingProperties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pointClippingBehavior = copy_src->pointClippingBehavior; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkRenderPassInputAttachmentAspectCreateInfo::safe_VkRenderPassInputAttachmentAspectCreateInfo( + const VkRenderPassInputAttachmentAspectCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), aspectReferenceCount(in_struct->aspectReferenceCount), pAspectReferences(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pAspectReferences) { + pAspectReferences = new VkInputAttachmentAspectReference[in_struct->aspectReferenceCount]; + memcpy((void*)pAspectReferences, (void*)in_struct->pAspectReferences, + sizeof(VkInputAttachmentAspectReference) * in_struct->aspectReferenceCount); + } +} + +safe_VkRenderPassInputAttachmentAspectCreateInfo::safe_VkRenderPassInputAttachmentAspectCreateInfo() + : sType(VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO), + pNext(nullptr), + aspectReferenceCount(), + pAspectReferences(nullptr) {} + +safe_VkRenderPassInputAttachmentAspectCreateInfo::safe_VkRenderPassInputAttachmentAspectCreateInfo( + const safe_VkRenderPassInputAttachmentAspectCreateInfo& copy_src) { + sType = copy_src.sType; + aspectReferenceCount = copy_src.aspectReferenceCount; + pAspectReferences = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pAspectReferences) { + pAspectReferences = new VkInputAttachmentAspectReference[copy_src.aspectReferenceCount]; + memcpy((void*)pAspectReferences, (void*)copy_src.pAspectReferences, + sizeof(VkInputAttachmentAspectReference) * copy_src.aspectReferenceCount); + } +} + +safe_VkRenderPassInputAttachmentAspectCreateInfo& safe_VkRenderPassInputAttachmentAspectCreateInfo::operator=( + const safe_VkRenderPassInputAttachmentAspectCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pAspectReferences) delete[] pAspectReferences; + FreePnextChain(pNext); + + sType = copy_src.sType; + aspectReferenceCount = copy_src.aspectReferenceCount; + pAspectReferences = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pAspectReferences) { + pAspectReferences = new VkInputAttachmentAspectReference[copy_src.aspectReferenceCount]; + memcpy((void*)pAspectReferences, (void*)copy_src.pAspectReferences, + sizeof(VkInputAttachmentAspectReference) * copy_src.aspectReferenceCount); + } + + return *this; +} + +safe_VkRenderPassInputAttachmentAspectCreateInfo::~safe_VkRenderPassInputAttachmentAspectCreateInfo() { + if (pAspectReferences) delete[] pAspectReferences; + FreePnextChain(pNext); +} + +void safe_VkRenderPassInputAttachmentAspectCreateInfo::initialize(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pAspectReferences) delete[] pAspectReferences; + FreePnextChain(pNext); + sType = in_struct->sType; + aspectReferenceCount = in_struct->aspectReferenceCount; + pAspectReferences = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pAspectReferences) { + pAspectReferences = new VkInputAttachmentAspectReference[in_struct->aspectReferenceCount]; + memcpy((void*)pAspectReferences, (void*)in_struct->pAspectReferences, + sizeof(VkInputAttachmentAspectReference) * in_struct->aspectReferenceCount); + } +} + +void safe_VkRenderPassInputAttachmentAspectCreateInfo::initialize(const safe_VkRenderPassInputAttachmentAspectCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + aspectReferenceCount = copy_src->aspectReferenceCount; + pAspectReferences = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pAspectReferences) { + pAspectReferences = new VkInputAttachmentAspectReference[copy_src->aspectReferenceCount]; + memcpy((void*)pAspectReferences, (void*)copy_src->pAspectReferences, + sizeof(VkInputAttachmentAspectReference) * copy_src->aspectReferenceCount); + } +} + +safe_VkImageViewUsageCreateInfo::safe_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo* 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_VkImageViewUsageCreateInfo::safe_VkImageViewUsageCreateInfo() + : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO), pNext(nullptr), usage() {} + +safe_VkImageViewUsageCreateInfo::safe_VkImageViewUsageCreateInfo(const safe_VkImageViewUsageCreateInfo& copy_src) { + sType = copy_src.sType; + usage = copy_src.usage; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageViewUsageCreateInfo& safe_VkImageViewUsageCreateInfo::operator=(const safe_VkImageViewUsageCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + usage = copy_src.usage; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageViewUsageCreateInfo::~safe_VkImageViewUsageCreateInfo() { FreePnextChain(pNext); } + +void safe_VkImageViewUsageCreateInfo::initialize(const VkImageViewUsageCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + usage = in_struct->usage; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageViewUsageCreateInfo::initialize(const safe_VkImageViewUsageCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + usage = copy_src->usage; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineTessellationDomainOriginStateCreateInfo::safe_VkPipelineTessellationDomainOriginStateCreateInfo( + const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), domainOrigin(in_struct->domainOrigin) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineTessellationDomainOriginStateCreateInfo::safe_VkPipelineTessellationDomainOriginStateCreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO), pNext(nullptr), domainOrigin() {} + +safe_VkPipelineTessellationDomainOriginStateCreateInfo::safe_VkPipelineTessellationDomainOriginStateCreateInfo( + const safe_VkPipelineTessellationDomainOriginStateCreateInfo& copy_src) { + sType = copy_src.sType; + domainOrigin = copy_src.domainOrigin; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineTessellationDomainOriginStateCreateInfo& safe_VkPipelineTessellationDomainOriginStateCreateInfo::operator=( + const safe_VkPipelineTessellationDomainOriginStateCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + domainOrigin = copy_src.domainOrigin; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineTessellationDomainOriginStateCreateInfo::~safe_VkPipelineTessellationDomainOriginStateCreateInfo() { + FreePnextChain(pNext); +} + +void safe_VkPipelineTessellationDomainOriginStateCreateInfo::initialize( + const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + domainOrigin = in_struct->domainOrigin; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineTessellationDomainOriginStateCreateInfo::initialize( + const safe_VkPipelineTessellationDomainOriginStateCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + domainOrigin = copy_src->domainOrigin; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkRenderPassMultiviewCreateInfo::safe_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + subpassCount(in_struct->subpassCount), + pViewMasks(nullptr), + dependencyCount(in_struct->dependencyCount), + pViewOffsets(nullptr), + correlationMaskCount(in_struct->correlationMaskCount), + pCorrelationMasks(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pViewMasks) { + pViewMasks = new uint32_t[in_struct->subpassCount]; + memcpy((void*)pViewMasks, (void*)in_struct->pViewMasks, sizeof(uint32_t) * in_struct->subpassCount); + } + + if (in_struct->pViewOffsets) { + pViewOffsets = new int32_t[in_struct->dependencyCount]; + memcpy((void*)pViewOffsets, (void*)in_struct->pViewOffsets, sizeof(int32_t) * in_struct->dependencyCount); + } + + if (in_struct->pCorrelationMasks) { + pCorrelationMasks = new uint32_t[in_struct->correlationMaskCount]; + memcpy((void*)pCorrelationMasks, (void*)in_struct->pCorrelationMasks, sizeof(uint32_t) * in_struct->correlationMaskCount); + } +} + +safe_VkRenderPassMultiviewCreateInfo::safe_VkRenderPassMultiviewCreateInfo() + : sType(VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO), + pNext(nullptr), + subpassCount(), + pViewMasks(nullptr), + dependencyCount(), + pViewOffsets(nullptr), + correlationMaskCount(), + pCorrelationMasks(nullptr) {} + +safe_VkRenderPassMultiviewCreateInfo::safe_VkRenderPassMultiviewCreateInfo(const safe_VkRenderPassMultiviewCreateInfo& copy_src) { + sType = copy_src.sType; + subpassCount = copy_src.subpassCount; + pViewMasks = nullptr; + dependencyCount = copy_src.dependencyCount; + pViewOffsets = nullptr; + correlationMaskCount = copy_src.correlationMaskCount; + pCorrelationMasks = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pViewMasks) { + pViewMasks = new uint32_t[copy_src.subpassCount]; + memcpy((void*)pViewMasks, (void*)copy_src.pViewMasks, sizeof(uint32_t) * copy_src.subpassCount); + } + + if (copy_src.pViewOffsets) { + pViewOffsets = new int32_t[copy_src.dependencyCount]; + memcpy((void*)pViewOffsets, (void*)copy_src.pViewOffsets, sizeof(int32_t) * copy_src.dependencyCount); + } + + if (copy_src.pCorrelationMasks) { + pCorrelationMasks = new uint32_t[copy_src.correlationMaskCount]; + memcpy((void*)pCorrelationMasks, (void*)copy_src.pCorrelationMasks, sizeof(uint32_t) * copy_src.correlationMaskCount); + } +} + +safe_VkRenderPassMultiviewCreateInfo& safe_VkRenderPassMultiviewCreateInfo::operator=( + const safe_VkRenderPassMultiviewCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pViewMasks) delete[] pViewMasks; + if (pViewOffsets) delete[] pViewOffsets; + if (pCorrelationMasks) delete[] pCorrelationMasks; + FreePnextChain(pNext); + + sType = copy_src.sType; + subpassCount = copy_src.subpassCount; + pViewMasks = nullptr; + dependencyCount = copy_src.dependencyCount; + pViewOffsets = nullptr; + correlationMaskCount = copy_src.correlationMaskCount; + pCorrelationMasks = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pViewMasks) { + pViewMasks = new uint32_t[copy_src.subpassCount]; + memcpy((void*)pViewMasks, (void*)copy_src.pViewMasks, sizeof(uint32_t) * copy_src.subpassCount); + } + + if (copy_src.pViewOffsets) { + pViewOffsets = new int32_t[copy_src.dependencyCount]; + memcpy((void*)pViewOffsets, (void*)copy_src.pViewOffsets, sizeof(int32_t) * copy_src.dependencyCount); + } + + if (copy_src.pCorrelationMasks) { + pCorrelationMasks = new uint32_t[copy_src.correlationMaskCount]; + memcpy((void*)pCorrelationMasks, (void*)copy_src.pCorrelationMasks, sizeof(uint32_t) * copy_src.correlationMaskCount); + } + + return *this; +} + +safe_VkRenderPassMultiviewCreateInfo::~safe_VkRenderPassMultiviewCreateInfo() { + if (pViewMasks) delete[] pViewMasks; + if (pViewOffsets) delete[] pViewOffsets; + if (pCorrelationMasks) delete[] pCorrelationMasks; + FreePnextChain(pNext); +} + +void safe_VkRenderPassMultiviewCreateInfo::initialize(const VkRenderPassMultiviewCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pViewMasks) delete[] pViewMasks; + if (pViewOffsets) delete[] pViewOffsets; + if (pCorrelationMasks) delete[] pCorrelationMasks; + FreePnextChain(pNext); + sType = in_struct->sType; + subpassCount = in_struct->subpassCount; + pViewMasks = nullptr; + dependencyCount = in_struct->dependencyCount; + pViewOffsets = nullptr; + correlationMaskCount = in_struct->correlationMaskCount; + pCorrelationMasks = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pViewMasks) { + pViewMasks = new uint32_t[in_struct->subpassCount]; + memcpy((void*)pViewMasks, (void*)in_struct->pViewMasks, sizeof(uint32_t) * in_struct->subpassCount); + } + + if (in_struct->pViewOffsets) { + pViewOffsets = new int32_t[in_struct->dependencyCount]; + memcpy((void*)pViewOffsets, (void*)in_struct->pViewOffsets, sizeof(int32_t) * in_struct->dependencyCount); + } + + if (in_struct->pCorrelationMasks) { + pCorrelationMasks = new uint32_t[in_struct->correlationMaskCount]; + memcpy((void*)pCorrelationMasks, (void*)in_struct->pCorrelationMasks, sizeof(uint32_t) * in_struct->correlationMaskCount); + } +} + +void safe_VkRenderPassMultiviewCreateInfo::initialize(const safe_VkRenderPassMultiviewCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + subpassCount = copy_src->subpassCount; + pViewMasks = nullptr; + dependencyCount = copy_src->dependencyCount; + pViewOffsets = nullptr; + correlationMaskCount = copy_src->correlationMaskCount; + pCorrelationMasks = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pViewMasks) { + pViewMasks = new uint32_t[copy_src->subpassCount]; + memcpy((void*)pViewMasks, (void*)copy_src->pViewMasks, sizeof(uint32_t) * copy_src->subpassCount); + } + + if (copy_src->pViewOffsets) { + pViewOffsets = new int32_t[copy_src->dependencyCount]; + memcpy((void*)pViewOffsets, (void*)copy_src->pViewOffsets, sizeof(int32_t) * copy_src->dependencyCount); + } + + if (copy_src->pCorrelationMasks) { + pCorrelationMasks = new uint32_t[copy_src->correlationMaskCount]; + memcpy((void*)pCorrelationMasks, (void*)copy_src->pCorrelationMasks, sizeof(uint32_t) * copy_src->correlationMaskCount); + } +} + +safe_VkPhysicalDeviceMultiviewFeatures::safe_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + multiview(in_struct->multiview), + multiviewGeometryShader(in_struct->multiviewGeometryShader), + multiviewTessellationShader(in_struct->multiviewTessellationShader) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMultiviewFeatures::safe_VkPhysicalDeviceMultiviewFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES), + pNext(nullptr), + multiview(), + multiviewGeometryShader(), + multiviewTessellationShader() {} + +safe_VkPhysicalDeviceMultiviewFeatures::safe_VkPhysicalDeviceMultiviewFeatures( + const safe_VkPhysicalDeviceMultiviewFeatures& copy_src) { + sType = copy_src.sType; + multiview = copy_src.multiview; + multiviewGeometryShader = copy_src.multiviewGeometryShader; + multiviewTessellationShader = copy_src.multiviewTessellationShader; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMultiviewFeatures& safe_VkPhysicalDeviceMultiviewFeatures::operator=( + const safe_VkPhysicalDeviceMultiviewFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + multiview = copy_src.multiview; + multiviewGeometryShader = copy_src.multiviewGeometryShader; + multiviewTessellationShader = copy_src.multiviewTessellationShader; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMultiviewFeatures::~safe_VkPhysicalDeviceMultiviewFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMultiviewFeatures::initialize(const VkPhysicalDeviceMultiviewFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + multiview = in_struct->multiview; + multiviewGeometryShader = in_struct->multiviewGeometryShader; + multiviewTessellationShader = in_struct->multiviewTessellationShader; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMultiviewFeatures::initialize(const safe_VkPhysicalDeviceMultiviewFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + multiview = copy_src->multiview; + multiviewGeometryShader = copy_src->multiviewGeometryShader; + multiviewTessellationShader = copy_src->multiviewTessellationShader; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMultiviewProperties::safe_VkPhysicalDeviceMultiviewProperties( + const VkPhysicalDeviceMultiviewProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + maxMultiviewViewCount(in_struct->maxMultiviewViewCount), + maxMultiviewInstanceIndex(in_struct->maxMultiviewInstanceIndex) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMultiviewProperties::safe_VkPhysicalDeviceMultiviewProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES), + pNext(nullptr), + maxMultiviewViewCount(), + maxMultiviewInstanceIndex() {} + +safe_VkPhysicalDeviceMultiviewProperties::safe_VkPhysicalDeviceMultiviewProperties( + const safe_VkPhysicalDeviceMultiviewProperties& copy_src) { + sType = copy_src.sType; + maxMultiviewViewCount = copy_src.maxMultiviewViewCount; + maxMultiviewInstanceIndex = copy_src.maxMultiviewInstanceIndex; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMultiviewProperties& safe_VkPhysicalDeviceMultiviewProperties::operator=( + const safe_VkPhysicalDeviceMultiviewProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxMultiviewViewCount = copy_src.maxMultiviewViewCount; + maxMultiviewInstanceIndex = copy_src.maxMultiviewInstanceIndex; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMultiviewProperties::~safe_VkPhysicalDeviceMultiviewProperties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMultiviewProperties::initialize(const VkPhysicalDeviceMultiviewProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxMultiviewViewCount = in_struct->maxMultiviewViewCount; + maxMultiviewInstanceIndex = in_struct->maxMultiviewInstanceIndex; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMultiviewProperties::initialize(const safe_VkPhysicalDeviceMultiviewProperties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxMultiviewViewCount = copy_src->maxMultiviewViewCount; + maxMultiviewInstanceIndex = copy_src->maxMultiviewInstanceIndex; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceVariablePointersFeatures::safe_VkPhysicalDeviceVariablePointersFeatures( + const VkPhysicalDeviceVariablePointersFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + variablePointersStorageBuffer(in_struct->variablePointersStorageBuffer), + variablePointers(in_struct->variablePointers) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceVariablePointersFeatures::safe_VkPhysicalDeviceVariablePointersFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES), + pNext(nullptr), + variablePointersStorageBuffer(), + variablePointers() {} + +safe_VkPhysicalDeviceVariablePointersFeatures::safe_VkPhysicalDeviceVariablePointersFeatures( + const safe_VkPhysicalDeviceVariablePointersFeatures& copy_src) { + sType = copy_src.sType; + variablePointersStorageBuffer = copy_src.variablePointersStorageBuffer; + variablePointers = copy_src.variablePointers; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceVariablePointersFeatures& safe_VkPhysicalDeviceVariablePointersFeatures::operator=( + const safe_VkPhysicalDeviceVariablePointersFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + variablePointersStorageBuffer = copy_src.variablePointersStorageBuffer; + variablePointers = copy_src.variablePointers; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceVariablePointersFeatures::~safe_VkPhysicalDeviceVariablePointersFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceVariablePointersFeatures::initialize(const VkPhysicalDeviceVariablePointersFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + variablePointersStorageBuffer = in_struct->variablePointersStorageBuffer; + variablePointers = in_struct->variablePointers; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceVariablePointersFeatures::initialize(const safe_VkPhysicalDeviceVariablePointersFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + variablePointersStorageBuffer = copy_src->variablePointersStorageBuffer; + variablePointers = copy_src->variablePointers; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceProtectedMemoryFeatures::safe_VkPhysicalDeviceProtectedMemoryFeatures( + const VkPhysicalDeviceProtectedMemoryFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), protectedMemory(in_struct->protectedMemory) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceProtectedMemoryFeatures::safe_VkPhysicalDeviceProtectedMemoryFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES), pNext(nullptr), protectedMemory() {} + +safe_VkPhysicalDeviceProtectedMemoryFeatures::safe_VkPhysicalDeviceProtectedMemoryFeatures( + const safe_VkPhysicalDeviceProtectedMemoryFeatures& copy_src) { + sType = copy_src.sType; + protectedMemory = copy_src.protectedMemory; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceProtectedMemoryFeatures& safe_VkPhysicalDeviceProtectedMemoryFeatures::operator=( + const safe_VkPhysicalDeviceProtectedMemoryFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + protectedMemory = copy_src.protectedMemory; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceProtectedMemoryFeatures::~safe_VkPhysicalDeviceProtectedMemoryFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceProtectedMemoryFeatures::initialize(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + protectedMemory = in_struct->protectedMemory; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceProtectedMemoryFeatures::initialize(const safe_VkPhysicalDeviceProtectedMemoryFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + protectedMemory = copy_src->protectedMemory; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceProtectedMemoryProperties::safe_VkPhysicalDeviceProtectedMemoryProperties( + const VkPhysicalDeviceProtectedMemoryProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), protectedNoFault(in_struct->protectedNoFault) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceProtectedMemoryProperties::safe_VkPhysicalDeviceProtectedMemoryProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES), pNext(nullptr), protectedNoFault() {} + +safe_VkPhysicalDeviceProtectedMemoryProperties::safe_VkPhysicalDeviceProtectedMemoryProperties( + const safe_VkPhysicalDeviceProtectedMemoryProperties& copy_src) { + sType = copy_src.sType; + protectedNoFault = copy_src.protectedNoFault; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceProtectedMemoryProperties& safe_VkPhysicalDeviceProtectedMemoryProperties::operator=( + const safe_VkPhysicalDeviceProtectedMemoryProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + protectedNoFault = copy_src.protectedNoFault; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceProtectedMemoryProperties::~safe_VkPhysicalDeviceProtectedMemoryProperties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceProtectedMemoryProperties::initialize(const VkPhysicalDeviceProtectedMemoryProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + protectedNoFault = in_struct->protectedNoFault; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceProtectedMemoryProperties::initialize(const safe_VkPhysicalDeviceProtectedMemoryProperties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + protectedNoFault = copy_src->protectedNoFault; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDeviceQueueInfo2::safe_VkDeviceQueueInfo2(const VkDeviceQueueInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + queueFamilyIndex(in_struct->queueFamilyIndex), + queueIndex(in_struct->queueIndex) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDeviceQueueInfo2::safe_VkDeviceQueueInfo2() + : sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2), pNext(nullptr), flags(), queueFamilyIndex(), queueIndex() {} + +safe_VkDeviceQueueInfo2::safe_VkDeviceQueueInfo2(const safe_VkDeviceQueueInfo2& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + queueFamilyIndex = copy_src.queueFamilyIndex; + queueIndex = copy_src.queueIndex; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDeviceQueueInfo2& safe_VkDeviceQueueInfo2::operator=(const safe_VkDeviceQueueInfo2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + queueFamilyIndex = copy_src.queueFamilyIndex; + queueIndex = copy_src.queueIndex; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDeviceQueueInfo2::~safe_VkDeviceQueueInfo2() { FreePnextChain(pNext); } + +void safe_VkDeviceQueueInfo2::initialize(const VkDeviceQueueInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + queueFamilyIndex = in_struct->queueFamilyIndex; + queueIndex = in_struct->queueIndex; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDeviceQueueInfo2::initialize(const safe_VkDeviceQueueInfo2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + queueFamilyIndex = copy_src->queueFamilyIndex; + queueIndex = copy_src->queueIndex; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkProtectedSubmitInfo::safe_VkProtectedSubmitInfo(const VkProtectedSubmitInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), protectedSubmit(in_struct->protectedSubmit) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkProtectedSubmitInfo::safe_VkProtectedSubmitInfo() + : sType(VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO), pNext(nullptr), protectedSubmit() {} + +safe_VkProtectedSubmitInfo::safe_VkProtectedSubmitInfo(const safe_VkProtectedSubmitInfo& copy_src) { + sType = copy_src.sType; + protectedSubmit = copy_src.protectedSubmit; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkProtectedSubmitInfo& safe_VkProtectedSubmitInfo::operator=(const safe_VkProtectedSubmitInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + protectedSubmit = copy_src.protectedSubmit; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkProtectedSubmitInfo::~safe_VkProtectedSubmitInfo() { FreePnextChain(pNext); } + +void safe_VkProtectedSubmitInfo::initialize(const VkProtectedSubmitInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + protectedSubmit = in_struct->protectedSubmit; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkProtectedSubmitInfo::initialize(const safe_VkProtectedSubmitInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + protectedSubmit = copy_src->protectedSubmit; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSamplerYcbcrConversionCreateInfo::safe_VkSamplerYcbcrConversionCreateInfo( + const VkSamplerYcbcrConversionCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + format(in_struct->format), + ycbcrModel(in_struct->ycbcrModel), + ycbcrRange(in_struct->ycbcrRange), + components(in_struct->components), + xChromaOffset(in_struct->xChromaOffset), + yChromaOffset(in_struct->yChromaOffset), + chromaFilter(in_struct->chromaFilter), + forceExplicitReconstruction(in_struct->forceExplicitReconstruction) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSamplerYcbcrConversionCreateInfo::safe_VkSamplerYcbcrConversionCreateInfo() + : sType(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO), + pNext(nullptr), + format(), + ycbcrModel(), + ycbcrRange(), + components(), + xChromaOffset(), + yChromaOffset(), + chromaFilter(), + forceExplicitReconstruction() {} + +safe_VkSamplerYcbcrConversionCreateInfo::safe_VkSamplerYcbcrConversionCreateInfo( + const safe_VkSamplerYcbcrConversionCreateInfo& copy_src) { + sType = copy_src.sType; + format = copy_src.format; + ycbcrModel = copy_src.ycbcrModel; + ycbcrRange = copy_src.ycbcrRange; + components = copy_src.components; + xChromaOffset = copy_src.xChromaOffset; + yChromaOffset = copy_src.yChromaOffset; + chromaFilter = copy_src.chromaFilter; + forceExplicitReconstruction = copy_src.forceExplicitReconstruction; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSamplerYcbcrConversionCreateInfo& safe_VkSamplerYcbcrConversionCreateInfo::operator=( + const safe_VkSamplerYcbcrConversionCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + format = copy_src.format; + ycbcrModel = copy_src.ycbcrModel; + ycbcrRange = copy_src.ycbcrRange; + components = copy_src.components; + xChromaOffset = copy_src.xChromaOffset; + yChromaOffset = copy_src.yChromaOffset; + chromaFilter = copy_src.chromaFilter; + forceExplicitReconstruction = copy_src.forceExplicitReconstruction; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSamplerYcbcrConversionCreateInfo::~safe_VkSamplerYcbcrConversionCreateInfo() { FreePnextChain(pNext); } + +void safe_VkSamplerYcbcrConversionCreateInfo::initialize(const VkSamplerYcbcrConversionCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + format = in_struct->format; + ycbcrModel = in_struct->ycbcrModel; + ycbcrRange = in_struct->ycbcrRange; + components = in_struct->components; + xChromaOffset = in_struct->xChromaOffset; + yChromaOffset = in_struct->yChromaOffset; + chromaFilter = in_struct->chromaFilter; + forceExplicitReconstruction = in_struct->forceExplicitReconstruction; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSamplerYcbcrConversionCreateInfo::initialize(const safe_VkSamplerYcbcrConversionCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + format = copy_src->format; + ycbcrModel = copy_src->ycbcrModel; + ycbcrRange = copy_src->ycbcrRange; + components = copy_src->components; + xChromaOffset = copy_src->xChromaOffset; + yChromaOffset = copy_src->yChromaOffset; + chromaFilter = copy_src->chromaFilter; + forceExplicitReconstruction = copy_src->forceExplicitReconstruction; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSamplerYcbcrConversionInfo::safe_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), conversion(in_struct->conversion) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSamplerYcbcrConversionInfo::safe_VkSamplerYcbcrConversionInfo() + : sType(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO), pNext(nullptr), conversion() {} + +safe_VkSamplerYcbcrConversionInfo::safe_VkSamplerYcbcrConversionInfo(const safe_VkSamplerYcbcrConversionInfo& copy_src) { + sType = copy_src.sType; + conversion = copy_src.conversion; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSamplerYcbcrConversionInfo& safe_VkSamplerYcbcrConversionInfo::operator=(const safe_VkSamplerYcbcrConversionInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + conversion = copy_src.conversion; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSamplerYcbcrConversionInfo::~safe_VkSamplerYcbcrConversionInfo() { FreePnextChain(pNext); } + +void safe_VkSamplerYcbcrConversionInfo::initialize(const VkSamplerYcbcrConversionInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + conversion = in_struct->conversion; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSamplerYcbcrConversionInfo::initialize(const safe_VkSamplerYcbcrConversionInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + conversion = copy_src->conversion; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBindImagePlaneMemoryInfo::safe_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), planeAspect(in_struct->planeAspect) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBindImagePlaneMemoryInfo::safe_VkBindImagePlaneMemoryInfo() + : sType(VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO), pNext(nullptr), planeAspect() {} + +safe_VkBindImagePlaneMemoryInfo::safe_VkBindImagePlaneMemoryInfo(const safe_VkBindImagePlaneMemoryInfo& copy_src) { + sType = copy_src.sType; + planeAspect = copy_src.planeAspect; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBindImagePlaneMemoryInfo& safe_VkBindImagePlaneMemoryInfo::operator=(const safe_VkBindImagePlaneMemoryInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + planeAspect = copy_src.planeAspect; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBindImagePlaneMemoryInfo::~safe_VkBindImagePlaneMemoryInfo() { FreePnextChain(pNext); } + +void safe_VkBindImagePlaneMemoryInfo::initialize(const VkBindImagePlaneMemoryInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + planeAspect = in_struct->planeAspect; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBindImagePlaneMemoryInfo::initialize(const safe_VkBindImagePlaneMemoryInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + planeAspect = copy_src->planeAspect; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImagePlaneMemoryRequirementsInfo::safe_VkImagePlaneMemoryRequirementsInfo( + const VkImagePlaneMemoryRequirementsInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), planeAspect(in_struct->planeAspect) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImagePlaneMemoryRequirementsInfo::safe_VkImagePlaneMemoryRequirementsInfo() + : sType(VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO), pNext(nullptr), planeAspect() {} + +safe_VkImagePlaneMemoryRequirementsInfo::safe_VkImagePlaneMemoryRequirementsInfo( + const safe_VkImagePlaneMemoryRequirementsInfo& copy_src) { + sType = copy_src.sType; + planeAspect = copy_src.planeAspect; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImagePlaneMemoryRequirementsInfo& safe_VkImagePlaneMemoryRequirementsInfo::operator=( + const safe_VkImagePlaneMemoryRequirementsInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + planeAspect = copy_src.planeAspect; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImagePlaneMemoryRequirementsInfo::~safe_VkImagePlaneMemoryRequirementsInfo() { FreePnextChain(pNext); } + +void safe_VkImagePlaneMemoryRequirementsInfo::initialize(const VkImagePlaneMemoryRequirementsInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + planeAspect = in_struct->planeAspect; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImagePlaneMemoryRequirementsInfo::initialize(const safe_VkImagePlaneMemoryRequirementsInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + planeAspect = copy_src->planeAspect; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures( + const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), samplerYcbcrConversion(in_struct->samplerYcbcrConversion) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES), pNext(nullptr), samplerYcbcrConversion() {} + +safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures( + const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& copy_src) { + sType = copy_src.sType; + samplerYcbcrConversion = copy_src.samplerYcbcrConversion; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::operator=( + const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + samplerYcbcrConversion = copy_src.samplerYcbcrConversion; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::~safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::initialize( + const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + samplerYcbcrConversion = in_struct->samplerYcbcrConversion; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::initialize( + const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + samplerYcbcrConversion = copy_src->samplerYcbcrConversion; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSamplerYcbcrConversionImageFormatProperties::safe_VkSamplerYcbcrConversionImageFormatProperties( + const VkSamplerYcbcrConversionImageFormatProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), combinedImageSamplerDescriptorCount(in_struct->combinedImageSamplerDescriptorCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSamplerYcbcrConversionImageFormatProperties::safe_VkSamplerYcbcrConversionImageFormatProperties() + : sType(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES), + pNext(nullptr), + combinedImageSamplerDescriptorCount() {} + +safe_VkSamplerYcbcrConversionImageFormatProperties::safe_VkSamplerYcbcrConversionImageFormatProperties( + const safe_VkSamplerYcbcrConversionImageFormatProperties& copy_src) { + sType = copy_src.sType; + combinedImageSamplerDescriptorCount = copy_src.combinedImageSamplerDescriptorCount; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSamplerYcbcrConversionImageFormatProperties& safe_VkSamplerYcbcrConversionImageFormatProperties::operator=( + const safe_VkSamplerYcbcrConversionImageFormatProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + combinedImageSamplerDescriptorCount = copy_src.combinedImageSamplerDescriptorCount; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSamplerYcbcrConversionImageFormatProperties::~safe_VkSamplerYcbcrConversionImageFormatProperties() { FreePnextChain(pNext); } + +void safe_VkSamplerYcbcrConversionImageFormatProperties::initialize(const VkSamplerYcbcrConversionImageFormatProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + combinedImageSamplerDescriptorCount = in_struct->combinedImageSamplerDescriptorCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSamplerYcbcrConversionImageFormatProperties::initialize( + const safe_VkSamplerYcbcrConversionImageFormatProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + combinedImageSamplerDescriptorCount = copy_src->combinedImageSamplerDescriptorCount; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDescriptorUpdateTemplateCreateInfo::safe_VkDescriptorUpdateTemplateCreateInfo( + const VkDescriptorUpdateTemplateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + descriptorUpdateEntryCount(in_struct->descriptorUpdateEntryCount), + pDescriptorUpdateEntries(nullptr), + templateType(in_struct->templateType), + descriptorSetLayout(in_struct->descriptorSetLayout), + pipelineBindPoint(in_struct->pipelineBindPoint), + pipelineLayout(in_struct->pipelineLayout), + set(in_struct->set) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pDescriptorUpdateEntries) { + pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[in_struct->descriptorUpdateEntryCount]; + memcpy((void*)pDescriptorUpdateEntries, (void*)in_struct->pDescriptorUpdateEntries, + sizeof(VkDescriptorUpdateTemplateEntry) * in_struct->descriptorUpdateEntryCount); + } +} + +safe_VkDescriptorUpdateTemplateCreateInfo::safe_VkDescriptorUpdateTemplateCreateInfo() + : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO), + pNext(nullptr), + flags(), + descriptorUpdateEntryCount(), + pDescriptorUpdateEntries(nullptr), + templateType(), + descriptorSetLayout(), + pipelineBindPoint(), + pipelineLayout(), + set() {} + +safe_VkDescriptorUpdateTemplateCreateInfo::safe_VkDescriptorUpdateTemplateCreateInfo( + const safe_VkDescriptorUpdateTemplateCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + descriptorUpdateEntryCount = copy_src.descriptorUpdateEntryCount; + pDescriptorUpdateEntries = nullptr; + templateType = copy_src.templateType; + descriptorSetLayout = copy_src.descriptorSetLayout; + pipelineBindPoint = copy_src.pipelineBindPoint; + pipelineLayout = copy_src.pipelineLayout; + set = copy_src.set; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDescriptorUpdateEntries) { + pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[copy_src.descriptorUpdateEntryCount]; + memcpy((void*)pDescriptorUpdateEntries, (void*)copy_src.pDescriptorUpdateEntries, + sizeof(VkDescriptorUpdateTemplateEntry) * copy_src.descriptorUpdateEntryCount); + } +} + +safe_VkDescriptorUpdateTemplateCreateInfo& safe_VkDescriptorUpdateTemplateCreateInfo::operator=( + const safe_VkDescriptorUpdateTemplateCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pDescriptorUpdateEntries) delete[] pDescriptorUpdateEntries; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + descriptorUpdateEntryCount = copy_src.descriptorUpdateEntryCount; + pDescriptorUpdateEntries = nullptr; + templateType = copy_src.templateType; + descriptorSetLayout = copy_src.descriptorSetLayout; + pipelineBindPoint = copy_src.pipelineBindPoint; + pipelineLayout = copy_src.pipelineLayout; + set = copy_src.set; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDescriptorUpdateEntries) { + pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[copy_src.descriptorUpdateEntryCount]; + memcpy((void*)pDescriptorUpdateEntries, (void*)copy_src.pDescriptorUpdateEntries, + sizeof(VkDescriptorUpdateTemplateEntry) * copy_src.descriptorUpdateEntryCount); + } + + return *this; +} + +safe_VkDescriptorUpdateTemplateCreateInfo::~safe_VkDescriptorUpdateTemplateCreateInfo() { + if (pDescriptorUpdateEntries) delete[] pDescriptorUpdateEntries; + FreePnextChain(pNext); +} + +void safe_VkDescriptorUpdateTemplateCreateInfo::initialize(const VkDescriptorUpdateTemplateCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDescriptorUpdateEntries) delete[] pDescriptorUpdateEntries; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + descriptorUpdateEntryCount = in_struct->descriptorUpdateEntryCount; + pDescriptorUpdateEntries = nullptr; + templateType = in_struct->templateType; + descriptorSetLayout = in_struct->descriptorSetLayout; + pipelineBindPoint = in_struct->pipelineBindPoint; + pipelineLayout = in_struct->pipelineLayout; + set = in_struct->set; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pDescriptorUpdateEntries) { + pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[in_struct->descriptorUpdateEntryCount]; + memcpy((void*)pDescriptorUpdateEntries, (void*)in_struct->pDescriptorUpdateEntries, + sizeof(VkDescriptorUpdateTemplateEntry) * in_struct->descriptorUpdateEntryCount); + } +} + +void safe_VkDescriptorUpdateTemplateCreateInfo::initialize(const safe_VkDescriptorUpdateTemplateCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + descriptorUpdateEntryCount = copy_src->descriptorUpdateEntryCount; + pDescriptorUpdateEntries = nullptr; + templateType = copy_src->templateType; + descriptorSetLayout = copy_src->descriptorSetLayout; + pipelineBindPoint = copy_src->pipelineBindPoint; + pipelineLayout = copy_src->pipelineLayout; + set = copy_src->set; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pDescriptorUpdateEntries) { + pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[copy_src->descriptorUpdateEntryCount]; + memcpy((void*)pDescriptorUpdateEntries, (void*)copy_src->pDescriptorUpdateEntries, + sizeof(VkDescriptorUpdateTemplateEntry) * copy_src->descriptorUpdateEntryCount); + } +} + +safe_VkPhysicalDeviceExternalImageFormatInfo::safe_VkPhysicalDeviceExternalImageFormatInfo( + const VkPhysicalDeviceExternalImageFormatInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), handleType(in_struct->handleType) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceExternalImageFormatInfo::safe_VkPhysicalDeviceExternalImageFormatInfo() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO), pNext(nullptr), handleType() {} + +safe_VkPhysicalDeviceExternalImageFormatInfo::safe_VkPhysicalDeviceExternalImageFormatInfo( + const safe_VkPhysicalDeviceExternalImageFormatInfo& copy_src) { + sType = copy_src.sType; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceExternalImageFormatInfo& safe_VkPhysicalDeviceExternalImageFormatInfo::operator=( + const safe_VkPhysicalDeviceExternalImageFormatInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceExternalImageFormatInfo::~safe_VkPhysicalDeviceExternalImageFormatInfo() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceExternalImageFormatInfo::initialize(const VkPhysicalDeviceExternalImageFormatInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + handleType = in_struct->handleType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceExternalImageFormatInfo::initialize(const safe_VkPhysicalDeviceExternalImageFormatInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + handleType = copy_src->handleType; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExternalImageFormatProperties::safe_VkExternalImageFormatProperties(const VkExternalImageFormatProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), externalMemoryProperties(in_struct->externalMemoryProperties) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExternalImageFormatProperties::safe_VkExternalImageFormatProperties() + : sType(VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES), pNext(nullptr), externalMemoryProperties() {} + +safe_VkExternalImageFormatProperties::safe_VkExternalImageFormatProperties(const safe_VkExternalImageFormatProperties& copy_src) { + sType = copy_src.sType; + externalMemoryProperties = copy_src.externalMemoryProperties; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExternalImageFormatProperties& safe_VkExternalImageFormatProperties::operator=( + const safe_VkExternalImageFormatProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + externalMemoryProperties = copy_src.externalMemoryProperties; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExternalImageFormatProperties::~safe_VkExternalImageFormatProperties() { FreePnextChain(pNext); } + +void safe_VkExternalImageFormatProperties::initialize(const VkExternalImageFormatProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + externalMemoryProperties = in_struct->externalMemoryProperties; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExternalImageFormatProperties::initialize(const safe_VkExternalImageFormatProperties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + externalMemoryProperties = copy_src->externalMemoryProperties; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceExternalBufferInfo::safe_VkPhysicalDeviceExternalBufferInfo( + const VkPhysicalDeviceExternalBufferInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), usage(in_struct->usage), handleType(in_struct->handleType) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceExternalBufferInfo::safe_VkPhysicalDeviceExternalBufferInfo() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO), pNext(nullptr), flags(), usage(), handleType() {} + +safe_VkPhysicalDeviceExternalBufferInfo::safe_VkPhysicalDeviceExternalBufferInfo( + const safe_VkPhysicalDeviceExternalBufferInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + usage = copy_src.usage; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceExternalBufferInfo& safe_VkPhysicalDeviceExternalBufferInfo::operator=( + const safe_VkPhysicalDeviceExternalBufferInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + usage = copy_src.usage; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceExternalBufferInfo::~safe_VkPhysicalDeviceExternalBufferInfo() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceExternalBufferInfo::initialize(const VkPhysicalDeviceExternalBufferInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + usage = in_struct->usage; + handleType = in_struct->handleType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceExternalBufferInfo::initialize(const safe_VkPhysicalDeviceExternalBufferInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + usage = copy_src->usage; + handleType = copy_src->handleType; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExternalBufferProperties::safe_VkExternalBufferProperties(const VkExternalBufferProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), externalMemoryProperties(in_struct->externalMemoryProperties) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExternalBufferProperties::safe_VkExternalBufferProperties() + : sType(VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES), pNext(nullptr), externalMemoryProperties() {} + +safe_VkExternalBufferProperties::safe_VkExternalBufferProperties(const safe_VkExternalBufferProperties& copy_src) { + sType = copy_src.sType; + externalMemoryProperties = copy_src.externalMemoryProperties; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExternalBufferProperties& safe_VkExternalBufferProperties::operator=(const safe_VkExternalBufferProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + externalMemoryProperties = copy_src.externalMemoryProperties; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExternalBufferProperties::~safe_VkExternalBufferProperties() { FreePnextChain(pNext); } + +void safe_VkExternalBufferProperties::initialize(const VkExternalBufferProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + externalMemoryProperties = in_struct->externalMemoryProperties; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExternalBufferProperties::initialize(const safe_VkExternalBufferProperties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + externalMemoryProperties = copy_src->externalMemoryProperties; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceIDProperties::safe_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), deviceNodeMask(in_struct->deviceNodeMask), deviceLUIDValid(in_struct->deviceLUIDValid) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + deviceUUID[i] = in_struct->deviceUUID[i]; + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + driverUUID[i] = in_struct->driverUUID[i]; + } + + for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) { + deviceLUID[i] = in_struct->deviceLUID[i]; + } +} + +safe_VkPhysicalDeviceIDProperties::safe_VkPhysicalDeviceIDProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES), pNext(nullptr), deviceNodeMask(), deviceLUIDValid() {} + +safe_VkPhysicalDeviceIDProperties::safe_VkPhysicalDeviceIDProperties(const safe_VkPhysicalDeviceIDProperties& copy_src) { + sType = copy_src.sType; + deviceNodeMask = copy_src.deviceNodeMask; + deviceLUIDValid = copy_src.deviceLUIDValid; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + deviceUUID[i] = copy_src.deviceUUID[i]; + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + driverUUID[i] = copy_src.driverUUID[i]; + } + + for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) { + deviceLUID[i] = copy_src.deviceLUID[i]; + } +} + +safe_VkPhysicalDeviceIDProperties& safe_VkPhysicalDeviceIDProperties::operator=(const safe_VkPhysicalDeviceIDProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + deviceNodeMask = copy_src.deviceNodeMask; + deviceLUIDValid = copy_src.deviceLUIDValid; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + deviceUUID[i] = copy_src.deviceUUID[i]; + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + driverUUID[i] = copy_src.driverUUID[i]; + } + + for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) { + deviceLUID[i] = copy_src.deviceLUID[i]; + } + + return *this; +} + +safe_VkPhysicalDeviceIDProperties::~safe_VkPhysicalDeviceIDProperties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceIDProperties::initialize(const VkPhysicalDeviceIDProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + deviceNodeMask = in_struct->deviceNodeMask; + deviceLUIDValid = in_struct->deviceLUIDValid; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + deviceUUID[i] = in_struct->deviceUUID[i]; + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + driverUUID[i] = in_struct->driverUUID[i]; + } + + for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) { + deviceLUID[i] = in_struct->deviceLUID[i]; + } +} + +void safe_VkPhysicalDeviceIDProperties::initialize(const safe_VkPhysicalDeviceIDProperties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + deviceNodeMask = copy_src->deviceNodeMask; + deviceLUIDValid = copy_src->deviceLUIDValid; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + deviceUUID[i] = copy_src->deviceUUID[i]; + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + driverUUID[i] = copy_src->driverUUID[i]; + } + + for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) { + deviceLUID[i] = copy_src->deviceLUID[i]; + } +} + +safe_VkExternalMemoryImageCreateInfo::safe_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), handleTypes(in_struct->handleTypes) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExternalMemoryImageCreateInfo::safe_VkExternalMemoryImageCreateInfo() + : sType(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO), pNext(nullptr), handleTypes() {} + +safe_VkExternalMemoryImageCreateInfo::safe_VkExternalMemoryImageCreateInfo(const safe_VkExternalMemoryImageCreateInfo& copy_src) { + sType = copy_src.sType; + handleTypes = copy_src.handleTypes; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExternalMemoryImageCreateInfo& safe_VkExternalMemoryImageCreateInfo::operator=( + const safe_VkExternalMemoryImageCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + handleTypes = copy_src.handleTypes; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExternalMemoryImageCreateInfo::~safe_VkExternalMemoryImageCreateInfo() { FreePnextChain(pNext); } + +void safe_VkExternalMemoryImageCreateInfo::initialize(const VkExternalMemoryImageCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + handleTypes = in_struct->handleTypes; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExternalMemoryImageCreateInfo::initialize(const safe_VkExternalMemoryImageCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + handleTypes = copy_src->handleTypes; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExternalMemoryBufferCreateInfo::safe_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), handleTypes(in_struct->handleTypes) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExternalMemoryBufferCreateInfo::safe_VkExternalMemoryBufferCreateInfo() + : sType(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO), pNext(nullptr), handleTypes() {} + +safe_VkExternalMemoryBufferCreateInfo::safe_VkExternalMemoryBufferCreateInfo( + const safe_VkExternalMemoryBufferCreateInfo& copy_src) { + sType = copy_src.sType; + handleTypes = copy_src.handleTypes; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExternalMemoryBufferCreateInfo& safe_VkExternalMemoryBufferCreateInfo::operator=( + const safe_VkExternalMemoryBufferCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + handleTypes = copy_src.handleTypes; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExternalMemoryBufferCreateInfo::~safe_VkExternalMemoryBufferCreateInfo() { FreePnextChain(pNext); } + +void safe_VkExternalMemoryBufferCreateInfo::initialize(const VkExternalMemoryBufferCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + handleTypes = in_struct->handleTypes; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExternalMemoryBufferCreateInfo::initialize(const safe_VkExternalMemoryBufferCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + handleTypes = copy_src->handleTypes; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExportMemoryAllocateInfo::safe_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), handleTypes(in_struct->handleTypes) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExportMemoryAllocateInfo::safe_VkExportMemoryAllocateInfo() + : sType(VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO), pNext(nullptr), handleTypes() {} + +safe_VkExportMemoryAllocateInfo::safe_VkExportMemoryAllocateInfo(const safe_VkExportMemoryAllocateInfo& copy_src) { + sType = copy_src.sType; + handleTypes = copy_src.handleTypes; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExportMemoryAllocateInfo& safe_VkExportMemoryAllocateInfo::operator=(const safe_VkExportMemoryAllocateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + handleTypes = copy_src.handleTypes; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExportMemoryAllocateInfo::~safe_VkExportMemoryAllocateInfo() { FreePnextChain(pNext); } + +void safe_VkExportMemoryAllocateInfo::initialize(const VkExportMemoryAllocateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + handleTypes = in_struct->handleTypes; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExportMemoryAllocateInfo::initialize(const safe_VkExportMemoryAllocateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + handleTypes = copy_src->handleTypes; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceExternalFenceInfo::safe_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), handleType(in_struct->handleType) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceExternalFenceInfo::safe_VkPhysicalDeviceExternalFenceInfo() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO), pNext(nullptr), handleType() {} + +safe_VkPhysicalDeviceExternalFenceInfo::safe_VkPhysicalDeviceExternalFenceInfo( + const safe_VkPhysicalDeviceExternalFenceInfo& copy_src) { + sType = copy_src.sType; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceExternalFenceInfo& safe_VkPhysicalDeviceExternalFenceInfo::operator=( + const safe_VkPhysicalDeviceExternalFenceInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceExternalFenceInfo::~safe_VkPhysicalDeviceExternalFenceInfo() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceExternalFenceInfo::initialize(const VkPhysicalDeviceExternalFenceInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + handleType = in_struct->handleType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceExternalFenceInfo::initialize(const safe_VkPhysicalDeviceExternalFenceInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + handleType = copy_src->handleType; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExternalFenceProperties::safe_VkExternalFenceProperties(const VkExternalFenceProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + exportFromImportedHandleTypes(in_struct->exportFromImportedHandleTypes), + compatibleHandleTypes(in_struct->compatibleHandleTypes), + externalFenceFeatures(in_struct->externalFenceFeatures) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExternalFenceProperties::safe_VkExternalFenceProperties() + : sType(VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES), + pNext(nullptr), + exportFromImportedHandleTypes(), + compatibleHandleTypes(), + externalFenceFeatures() {} + +safe_VkExternalFenceProperties::safe_VkExternalFenceProperties(const safe_VkExternalFenceProperties& copy_src) { + sType = copy_src.sType; + exportFromImportedHandleTypes = copy_src.exportFromImportedHandleTypes; + compatibleHandleTypes = copy_src.compatibleHandleTypes; + externalFenceFeatures = copy_src.externalFenceFeatures; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExternalFenceProperties& safe_VkExternalFenceProperties::operator=(const safe_VkExternalFenceProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + exportFromImportedHandleTypes = copy_src.exportFromImportedHandleTypes; + compatibleHandleTypes = copy_src.compatibleHandleTypes; + externalFenceFeatures = copy_src.externalFenceFeatures; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExternalFenceProperties::~safe_VkExternalFenceProperties() { FreePnextChain(pNext); } + +void safe_VkExternalFenceProperties::initialize(const VkExternalFenceProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + exportFromImportedHandleTypes = in_struct->exportFromImportedHandleTypes; + compatibleHandleTypes = in_struct->compatibleHandleTypes; + externalFenceFeatures = in_struct->externalFenceFeatures; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExternalFenceProperties::initialize(const safe_VkExternalFenceProperties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + exportFromImportedHandleTypes = copy_src->exportFromImportedHandleTypes; + compatibleHandleTypes = copy_src->compatibleHandleTypes; + externalFenceFeatures = copy_src->externalFenceFeatures; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExportFenceCreateInfo::safe_VkExportFenceCreateInfo(const VkExportFenceCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), handleTypes(in_struct->handleTypes) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExportFenceCreateInfo::safe_VkExportFenceCreateInfo() + : sType(VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO), pNext(nullptr), handleTypes() {} + +safe_VkExportFenceCreateInfo::safe_VkExportFenceCreateInfo(const safe_VkExportFenceCreateInfo& copy_src) { + sType = copy_src.sType; + handleTypes = copy_src.handleTypes; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExportFenceCreateInfo& safe_VkExportFenceCreateInfo::operator=(const safe_VkExportFenceCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + handleTypes = copy_src.handleTypes; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExportFenceCreateInfo::~safe_VkExportFenceCreateInfo() { FreePnextChain(pNext); } + +void safe_VkExportFenceCreateInfo::initialize(const VkExportFenceCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + handleTypes = in_struct->handleTypes; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExportFenceCreateInfo::initialize(const safe_VkExportFenceCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + handleTypes = copy_src->handleTypes; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExportSemaphoreCreateInfo::safe_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), handleTypes(in_struct->handleTypes) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExportSemaphoreCreateInfo::safe_VkExportSemaphoreCreateInfo() + : sType(VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO), pNext(nullptr), handleTypes() {} + +safe_VkExportSemaphoreCreateInfo::safe_VkExportSemaphoreCreateInfo(const safe_VkExportSemaphoreCreateInfo& copy_src) { + sType = copy_src.sType; + handleTypes = copy_src.handleTypes; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExportSemaphoreCreateInfo& safe_VkExportSemaphoreCreateInfo::operator=(const safe_VkExportSemaphoreCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + handleTypes = copy_src.handleTypes; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExportSemaphoreCreateInfo::~safe_VkExportSemaphoreCreateInfo() { FreePnextChain(pNext); } + +void safe_VkExportSemaphoreCreateInfo::initialize(const VkExportSemaphoreCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + handleTypes = in_struct->handleTypes; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExportSemaphoreCreateInfo::initialize(const safe_VkExportSemaphoreCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + handleTypes = copy_src->handleTypes; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceExternalSemaphoreInfo::safe_VkPhysicalDeviceExternalSemaphoreInfo( + const VkPhysicalDeviceExternalSemaphoreInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), handleType(in_struct->handleType) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceExternalSemaphoreInfo::safe_VkPhysicalDeviceExternalSemaphoreInfo() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO), pNext(nullptr), handleType() {} + +safe_VkPhysicalDeviceExternalSemaphoreInfo::safe_VkPhysicalDeviceExternalSemaphoreInfo( + const safe_VkPhysicalDeviceExternalSemaphoreInfo& copy_src) { + sType = copy_src.sType; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceExternalSemaphoreInfo& safe_VkPhysicalDeviceExternalSemaphoreInfo::operator=( + const safe_VkPhysicalDeviceExternalSemaphoreInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceExternalSemaphoreInfo::~safe_VkPhysicalDeviceExternalSemaphoreInfo() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceExternalSemaphoreInfo::initialize(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + handleType = in_struct->handleType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceExternalSemaphoreInfo::initialize(const safe_VkPhysicalDeviceExternalSemaphoreInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + handleType = copy_src->handleType; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExternalSemaphoreProperties::safe_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + exportFromImportedHandleTypes(in_struct->exportFromImportedHandleTypes), + compatibleHandleTypes(in_struct->compatibleHandleTypes), + externalSemaphoreFeatures(in_struct->externalSemaphoreFeatures) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExternalSemaphoreProperties::safe_VkExternalSemaphoreProperties() + : sType(VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES), + pNext(nullptr), + exportFromImportedHandleTypes(), + compatibleHandleTypes(), + externalSemaphoreFeatures() {} + +safe_VkExternalSemaphoreProperties::safe_VkExternalSemaphoreProperties(const safe_VkExternalSemaphoreProperties& copy_src) { + sType = copy_src.sType; + exportFromImportedHandleTypes = copy_src.exportFromImportedHandleTypes; + compatibleHandleTypes = copy_src.compatibleHandleTypes; + externalSemaphoreFeatures = copy_src.externalSemaphoreFeatures; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExternalSemaphoreProperties& safe_VkExternalSemaphoreProperties::operator=( + const safe_VkExternalSemaphoreProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + exportFromImportedHandleTypes = copy_src.exportFromImportedHandleTypes; + compatibleHandleTypes = copy_src.compatibleHandleTypes; + externalSemaphoreFeatures = copy_src.externalSemaphoreFeatures; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExternalSemaphoreProperties::~safe_VkExternalSemaphoreProperties() { FreePnextChain(pNext); } + +void safe_VkExternalSemaphoreProperties::initialize(const VkExternalSemaphoreProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + exportFromImportedHandleTypes = in_struct->exportFromImportedHandleTypes; + compatibleHandleTypes = in_struct->compatibleHandleTypes; + externalSemaphoreFeatures = in_struct->externalSemaphoreFeatures; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExternalSemaphoreProperties::initialize(const safe_VkExternalSemaphoreProperties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + exportFromImportedHandleTypes = copy_src->exportFromImportedHandleTypes; + compatibleHandleTypes = copy_src->compatibleHandleTypes; + externalSemaphoreFeatures = copy_src->externalSemaphoreFeatures; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMaintenance3Properties::safe_VkPhysicalDeviceMaintenance3Properties( + const VkPhysicalDeviceMaintenance3Properties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + maxPerSetDescriptors(in_struct->maxPerSetDescriptors), + maxMemoryAllocationSize(in_struct->maxMemoryAllocationSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMaintenance3Properties::safe_VkPhysicalDeviceMaintenance3Properties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES), + pNext(nullptr), + maxPerSetDescriptors(), + maxMemoryAllocationSize() {} + +safe_VkPhysicalDeviceMaintenance3Properties::safe_VkPhysicalDeviceMaintenance3Properties( + const safe_VkPhysicalDeviceMaintenance3Properties& copy_src) { + sType = copy_src.sType; + maxPerSetDescriptors = copy_src.maxPerSetDescriptors; + maxMemoryAllocationSize = copy_src.maxMemoryAllocationSize; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMaintenance3Properties& safe_VkPhysicalDeviceMaintenance3Properties::operator=( + const safe_VkPhysicalDeviceMaintenance3Properties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxPerSetDescriptors = copy_src.maxPerSetDescriptors; + maxMemoryAllocationSize = copy_src.maxMemoryAllocationSize; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMaintenance3Properties::~safe_VkPhysicalDeviceMaintenance3Properties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMaintenance3Properties::initialize(const VkPhysicalDeviceMaintenance3Properties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxPerSetDescriptors = in_struct->maxPerSetDescriptors; + maxMemoryAllocationSize = in_struct->maxMemoryAllocationSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMaintenance3Properties::initialize(const safe_VkPhysicalDeviceMaintenance3Properties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxPerSetDescriptors = copy_src->maxPerSetDescriptors; + maxMemoryAllocationSize = copy_src->maxMemoryAllocationSize; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDescriptorSetLayoutSupport::safe_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), supported(in_struct->supported) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDescriptorSetLayoutSupport::safe_VkDescriptorSetLayoutSupport() + : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT), pNext(nullptr), supported() {} + +safe_VkDescriptorSetLayoutSupport::safe_VkDescriptorSetLayoutSupport(const safe_VkDescriptorSetLayoutSupport& copy_src) { + sType = copy_src.sType; + supported = copy_src.supported; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDescriptorSetLayoutSupport& safe_VkDescriptorSetLayoutSupport::operator=(const safe_VkDescriptorSetLayoutSupport& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + supported = copy_src.supported; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDescriptorSetLayoutSupport::~safe_VkDescriptorSetLayoutSupport() { FreePnextChain(pNext); } + +void safe_VkDescriptorSetLayoutSupport::initialize(const VkDescriptorSetLayoutSupport* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + supported = in_struct->supported; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDescriptorSetLayoutSupport::initialize(const safe_VkDescriptorSetLayoutSupport* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + supported = copy_src->supported; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderDrawParametersFeatures::safe_VkPhysicalDeviceShaderDrawParametersFeatures( + const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), shaderDrawParameters(in_struct->shaderDrawParameters) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderDrawParametersFeatures::safe_VkPhysicalDeviceShaderDrawParametersFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES), pNext(nullptr), shaderDrawParameters() {} + +safe_VkPhysicalDeviceShaderDrawParametersFeatures::safe_VkPhysicalDeviceShaderDrawParametersFeatures( + const safe_VkPhysicalDeviceShaderDrawParametersFeatures& copy_src) { + sType = copy_src.sType; + shaderDrawParameters = copy_src.shaderDrawParameters; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderDrawParametersFeatures& safe_VkPhysicalDeviceShaderDrawParametersFeatures::operator=( + const safe_VkPhysicalDeviceShaderDrawParametersFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderDrawParameters = copy_src.shaderDrawParameters; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderDrawParametersFeatures::~safe_VkPhysicalDeviceShaderDrawParametersFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderDrawParametersFeatures::initialize(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderDrawParameters = in_struct->shaderDrawParameters; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderDrawParametersFeatures::initialize( + const safe_VkPhysicalDeviceShaderDrawParametersFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderDrawParameters = copy_src->shaderDrawParameters; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceVulkan11Features::safe_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + storageBuffer16BitAccess(in_struct->storageBuffer16BitAccess), + uniformAndStorageBuffer16BitAccess(in_struct->uniformAndStorageBuffer16BitAccess), + storagePushConstant16(in_struct->storagePushConstant16), + storageInputOutput16(in_struct->storageInputOutput16), + multiview(in_struct->multiview), + multiviewGeometryShader(in_struct->multiviewGeometryShader), + multiviewTessellationShader(in_struct->multiviewTessellationShader), + variablePointersStorageBuffer(in_struct->variablePointersStorageBuffer), + variablePointers(in_struct->variablePointers), + protectedMemory(in_struct->protectedMemory), + samplerYcbcrConversion(in_struct->samplerYcbcrConversion), + shaderDrawParameters(in_struct->shaderDrawParameters) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceVulkan11Features::safe_VkPhysicalDeviceVulkan11Features() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES), + pNext(nullptr), + storageBuffer16BitAccess(), + uniformAndStorageBuffer16BitAccess(), + storagePushConstant16(), + storageInputOutput16(), + multiview(), + multiviewGeometryShader(), + multiviewTessellationShader(), + variablePointersStorageBuffer(), + variablePointers(), + protectedMemory(), + samplerYcbcrConversion(), + shaderDrawParameters() {} + +safe_VkPhysicalDeviceVulkan11Features::safe_VkPhysicalDeviceVulkan11Features( + const safe_VkPhysicalDeviceVulkan11Features& copy_src) { + sType = copy_src.sType; + storageBuffer16BitAccess = copy_src.storageBuffer16BitAccess; + uniformAndStorageBuffer16BitAccess = copy_src.uniformAndStorageBuffer16BitAccess; + storagePushConstant16 = copy_src.storagePushConstant16; + storageInputOutput16 = copy_src.storageInputOutput16; + multiview = copy_src.multiview; + multiviewGeometryShader = copy_src.multiviewGeometryShader; + multiviewTessellationShader = copy_src.multiviewTessellationShader; + variablePointersStorageBuffer = copy_src.variablePointersStorageBuffer; + variablePointers = copy_src.variablePointers; + protectedMemory = copy_src.protectedMemory; + samplerYcbcrConversion = copy_src.samplerYcbcrConversion; + shaderDrawParameters = copy_src.shaderDrawParameters; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceVulkan11Features& safe_VkPhysicalDeviceVulkan11Features::operator=( + const safe_VkPhysicalDeviceVulkan11Features& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + storageBuffer16BitAccess = copy_src.storageBuffer16BitAccess; + uniformAndStorageBuffer16BitAccess = copy_src.uniformAndStorageBuffer16BitAccess; + storagePushConstant16 = copy_src.storagePushConstant16; + storageInputOutput16 = copy_src.storageInputOutput16; + multiview = copy_src.multiview; + multiviewGeometryShader = copy_src.multiviewGeometryShader; + multiviewTessellationShader = copy_src.multiviewTessellationShader; + variablePointersStorageBuffer = copy_src.variablePointersStorageBuffer; + variablePointers = copy_src.variablePointers; + protectedMemory = copy_src.protectedMemory; + samplerYcbcrConversion = copy_src.samplerYcbcrConversion; + shaderDrawParameters = copy_src.shaderDrawParameters; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceVulkan11Features::~safe_VkPhysicalDeviceVulkan11Features() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceVulkan11Features::initialize(const VkPhysicalDeviceVulkan11Features* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + storageBuffer16BitAccess = in_struct->storageBuffer16BitAccess; + uniformAndStorageBuffer16BitAccess = in_struct->uniformAndStorageBuffer16BitAccess; + storagePushConstant16 = in_struct->storagePushConstant16; + storageInputOutput16 = in_struct->storageInputOutput16; + multiview = in_struct->multiview; + multiviewGeometryShader = in_struct->multiviewGeometryShader; + multiviewTessellationShader = in_struct->multiviewTessellationShader; + variablePointersStorageBuffer = in_struct->variablePointersStorageBuffer; + variablePointers = in_struct->variablePointers; + protectedMemory = in_struct->protectedMemory; + samplerYcbcrConversion = in_struct->samplerYcbcrConversion; + shaderDrawParameters = in_struct->shaderDrawParameters; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceVulkan11Features::initialize(const safe_VkPhysicalDeviceVulkan11Features* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + storageBuffer16BitAccess = copy_src->storageBuffer16BitAccess; + uniformAndStorageBuffer16BitAccess = copy_src->uniformAndStorageBuffer16BitAccess; + storagePushConstant16 = copy_src->storagePushConstant16; + storageInputOutput16 = copy_src->storageInputOutput16; + multiview = copy_src->multiview; + multiviewGeometryShader = copy_src->multiviewGeometryShader; + multiviewTessellationShader = copy_src->multiviewTessellationShader; + variablePointersStorageBuffer = copy_src->variablePointersStorageBuffer; + variablePointers = copy_src->variablePointers; + protectedMemory = copy_src->protectedMemory; + samplerYcbcrConversion = copy_src->samplerYcbcrConversion; + shaderDrawParameters = copy_src->shaderDrawParameters; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceVulkan11Properties::safe_VkPhysicalDeviceVulkan11Properties( + const VkPhysicalDeviceVulkan11Properties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + deviceNodeMask(in_struct->deviceNodeMask), + deviceLUIDValid(in_struct->deviceLUIDValid), + subgroupSize(in_struct->subgroupSize), + subgroupSupportedStages(in_struct->subgroupSupportedStages), + subgroupSupportedOperations(in_struct->subgroupSupportedOperations), + subgroupQuadOperationsInAllStages(in_struct->subgroupQuadOperationsInAllStages), + pointClippingBehavior(in_struct->pointClippingBehavior), + maxMultiviewViewCount(in_struct->maxMultiviewViewCount), + maxMultiviewInstanceIndex(in_struct->maxMultiviewInstanceIndex), + protectedNoFault(in_struct->protectedNoFault), + maxPerSetDescriptors(in_struct->maxPerSetDescriptors), + maxMemoryAllocationSize(in_struct->maxMemoryAllocationSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + deviceUUID[i] = in_struct->deviceUUID[i]; + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + driverUUID[i] = in_struct->driverUUID[i]; + } + + for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) { + deviceLUID[i] = in_struct->deviceLUID[i]; + } +} + +safe_VkPhysicalDeviceVulkan11Properties::safe_VkPhysicalDeviceVulkan11Properties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES), + pNext(nullptr), + deviceNodeMask(), + deviceLUIDValid(), + subgroupSize(), + subgroupSupportedStages(), + subgroupSupportedOperations(), + subgroupQuadOperationsInAllStages(), + pointClippingBehavior(), + maxMultiviewViewCount(), + maxMultiviewInstanceIndex(), + protectedNoFault(), + maxPerSetDescriptors(), + maxMemoryAllocationSize() {} + +safe_VkPhysicalDeviceVulkan11Properties::safe_VkPhysicalDeviceVulkan11Properties( + const safe_VkPhysicalDeviceVulkan11Properties& copy_src) { + sType = copy_src.sType; + deviceNodeMask = copy_src.deviceNodeMask; + deviceLUIDValid = copy_src.deviceLUIDValid; + subgroupSize = copy_src.subgroupSize; + subgroupSupportedStages = copy_src.subgroupSupportedStages; + subgroupSupportedOperations = copy_src.subgroupSupportedOperations; + subgroupQuadOperationsInAllStages = copy_src.subgroupQuadOperationsInAllStages; + pointClippingBehavior = copy_src.pointClippingBehavior; + maxMultiviewViewCount = copy_src.maxMultiviewViewCount; + maxMultiviewInstanceIndex = copy_src.maxMultiviewInstanceIndex; + protectedNoFault = copy_src.protectedNoFault; + maxPerSetDescriptors = copy_src.maxPerSetDescriptors; + maxMemoryAllocationSize = copy_src.maxMemoryAllocationSize; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + deviceUUID[i] = copy_src.deviceUUID[i]; + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + driverUUID[i] = copy_src.driverUUID[i]; + } + + for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) { + deviceLUID[i] = copy_src.deviceLUID[i]; + } +} + +safe_VkPhysicalDeviceVulkan11Properties& safe_VkPhysicalDeviceVulkan11Properties::operator=( + const safe_VkPhysicalDeviceVulkan11Properties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + deviceNodeMask = copy_src.deviceNodeMask; + deviceLUIDValid = copy_src.deviceLUIDValid; + subgroupSize = copy_src.subgroupSize; + subgroupSupportedStages = copy_src.subgroupSupportedStages; + subgroupSupportedOperations = copy_src.subgroupSupportedOperations; + subgroupQuadOperationsInAllStages = copy_src.subgroupQuadOperationsInAllStages; + pointClippingBehavior = copy_src.pointClippingBehavior; + maxMultiviewViewCount = copy_src.maxMultiviewViewCount; + maxMultiviewInstanceIndex = copy_src.maxMultiviewInstanceIndex; + protectedNoFault = copy_src.protectedNoFault; + maxPerSetDescriptors = copy_src.maxPerSetDescriptors; + maxMemoryAllocationSize = copy_src.maxMemoryAllocationSize; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + deviceUUID[i] = copy_src.deviceUUID[i]; + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + driverUUID[i] = copy_src.driverUUID[i]; + } + + for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) { + deviceLUID[i] = copy_src.deviceLUID[i]; + } + + return *this; +} + +safe_VkPhysicalDeviceVulkan11Properties::~safe_VkPhysicalDeviceVulkan11Properties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceVulkan11Properties::initialize(const VkPhysicalDeviceVulkan11Properties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + deviceNodeMask = in_struct->deviceNodeMask; + deviceLUIDValid = in_struct->deviceLUIDValid; + subgroupSize = in_struct->subgroupSize; + subgroupSupportedStages = in_struct->subgroupSupportedStages; + subgroupSupportedOperations = in_struct->subgroupSupportedOperations; + subgroupQuadOperationsInAllStages = in_struct->subgroupQuadOperationsInAllStages; + pointClippingBehavior = in_struct->pointClippingBehavior; + maxMultiviewViewCount = in_struct->maxMultiviewViewCount; + maxMultiviewInstanceIndex = in_struct->maxMultiviewInstanceIndex; + protectedNoFault = in_struct->protectedNoFault; + maxPerSetDescriptors = in_struct->maxPerSetDescriptors; + maxMemoryAllocationSize = in_struct->maxMemoryAllocationSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + deviceUUID[i] = in_struct->deviceUUID[i]; + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + driverUUID[i] = in_struct->driverUUID[i]; + } + + for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) { + deviceLUID[i] = in_struct->deviceLUID[i]; + } +} + +void safe_VkPhysicalDeviceVulkan11Properties::initialize(const safe_VkPhysicalDeviceVulkan11Properties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + deviceNodeMask = copy_src->deviceNodeMask; + deviceLUIDValid = copy_src->deviceLUIDValid; + subgroupSize = copy_src->subgroupSize; + subgroupSupportedStages = copy_src->subgroupSupportedStages; + subgroupSupportedOperations = copy_src->subgroupSupportedOperations; + subgroupQuadOperationsInAllStages = copy_src->subgroupQuadOperationsInAllStages; + pointClippingBehavior = copy_src->pointClippingBehavior; + maxMultiviewViewCount = copy_src->maxMultiviewViewCount; + maxMultiviewInstanceIndex = copy_src->maxMultiviewInstanceIndex; + protectedNoFault = copy_src->protectedNoFault; + maxPerSetDescriptors = copy_src->maxPerSetDescriptors; + maxMemoryAllocationSize = copy_src->maxMemoryAllocationSize; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + deviceUUID[i] = copy_src->deviceUUID[i]; + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + driverUUID[i] = copy_src->driverUUID[i]; + } + + for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) { + deviceLUID[i] = copy_src->deviceLUID[i]; + } +} + +safe_VkPhysicalDeviceVulkan12Features::safe_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + samplerMirrorClampToEdge(in_struct->samplerMirrorClampToEdge), + drawIndirectCount(in_struct->drawIndirectCount), + storageBuffer8BitAccess(in_struct->storageBuffer8BitAccess), + uniformAndStorageBuffer8BitAccess(in_struct->uniformAndStorageBuffer8BitAccess), + storagePushConstant8(in_struct->storagePushConstant8), + shaderBufferInt64Atomics(in_struct->shaderBufferInt64Atomics), + shaderSharedInt64Atomics(in_struct->shaderSharedInt64Atomics), + shaderFloat16(in_struct->shaderFloat16), + shaderInt8(in_struct->shaderInt8), + descriptorIndexing(in_struct->descriptorIndexing), + shaderInputAttachmentArrayDynamicIndexing(in_struct->shaderInputAttachmentArrayDynamicIndexing), + shaderUniformTexelBufferArrayDynamicIndexing(in_struct->shaderUniformTexelBufferArrayDynamicIndexing), + shaderStorageTexelBufferArrayDynamicIndexing(in_struct->shaderStorageTexelBufferArrayDynamicIndexing), + shaderUniformBufferArrayNonUniformIndexing(in_struct->shaderUniformBufferArrayNonUniformIndexing), + shaderSampledImageArrayNonUniformIndexing(in_struct->shaderSampledImageArrayNonUniformIndexing), + shaderStorageBufferArrayNonUniformIndexing(in_struct->shaderStorageBufferArrayNonUniformIndexing), + shaderStorageImageArrayNonUniformIndexing(in_struct->shaderStorageImageArrayNonUniformIndexing), + shaderInputAttachmentArrayNonUniformIndexing(in_struct->shaderInputAttachmentArrayNonUniformIndexing), + shaderUniformTexelBufferArrayNonUniformIndexing(in_struct->shaderUniformTexelBufferArrayNonUniformIndexing), + shaderStorageTexelBufferArrayNonUniformIndexing(in_struct->shaderStorageTexelBufferArrayNonUniformIndexing), + descriptorBindingUniformBufferUpdateAfterBind(in_struct->descriptorBindingUniformBufferUpdateAfterBind), + descriptorBindingSampledImageUpdateAfterBind(in_struct->descriptorBindingSampledImageUpdateAfterBind), + descriptorBindingStorageImageUpdateAfterBind(in_struct->descriptorBindingStorageImageUpdateAfterBind), + descriptorBindingStorageBufferUpdateAfterBind(in_struct->descriptorBindingStorageBufferUpdateAfterBind), + descriptorBindingUniformTexelBufferUpdateAfterBind(in_struct->descriptorBindingUniformTexelBufferUpdateAfterBind), + descriptorBindingStorageTexelBufferUpdateAfterBind(in_struct->descriptorBindingStorageTexelBufferUpdateAfterBind), + descriptorBindingUpdateUnusedWhilePending(in_struct->descriptorBindingUpdateUnusedWhilePending), + descriptorBindingPartiallyBound(in_struct->descriptorBindingPartiallyBound), + descriptorBindingVariableDescriptorCount(in_struct->descriptorBindingVariableDescriptorCount), + runtimeDescriptorArray(in_struct->runtimeDescriptorArray), + samplerFilterMinmax(in_struct->samplerFilterMinmax), + scalarBlockLayout(in_struct->scalarBlockLayout), + imagelessFramebuffer(in_struct->imagelessFramebuffer), + uniformBufferStandardLayout(in_struct->uniformBufferStandardLayout), + shaderSubgroupExtendedTypes(in_struct->shaderSubgroupExtendedTypes), + separateDepthStencilLayouts(in_struct->separateDepthStencilLayouts), + hostQueryReset(in_struct->hostQueryReset), + timelineSemaphore(in_struct->timelineSemaphore), + bufferDeviceAddress(in_struct->bufferDeviceAddress), + bufferDeviceAddressCaptureReplay(in_struct->bufferDeviceAddressCaptureReplay), + bufferDeviceAddressMultiDevice(in_struct->bufferDeviceAddressMultiDevice), + vulkanMemoryModel(in_struct->vulkanMemoryModel), + vulkanMemoryModelDeviceScope(in_struct->vulkanMemoryModelDeviceScope), + vulkanMemoryModelAvailabilityVisibilityChains(in_struct->vulkanMemoryModelAvailabilityVisibilityChains), + shaderOutputViewportIndex(in_struct->shaderOutputViewportIndex), + shaderOutputLayer(in_struct->shaderOutputLayer), + subgroupBroadcastDynamicId(in_struct->subgroupBroadcastDynamicId) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceVulkan12Features::safe_VkPhysicalDeviceVulkan12Features() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES), + pNext(nullptr), + samplerMirrorClampToEdge(), + drawIndirectCount(), + storageBuffer8BitAccess(), + uniformAndStorageBuffer8BitAccess(), + storagePushConstant8(), + shaderBufferInt64Atomics(), + shaderSharedInt64Atomics(), + shaderFloat16(), + shaderInt8(), + descriptorIndexing(), + shaderInputAttachmentArrayDynamicIndexing(), + shaderUniformTexelBufferArrayDynamicIndexing(), + shaderStorageTexelBufferArrayDynamicIndexing(), + shaderUniformBufferArrayNonUniformIndexing(), + shaderSampledImageArrayNonUniformIndexing(), + shaderStorageBufferArrayNonUniformIndexing(), + shaderStorageImageArrayNonUniformIndexing(), + shaderInputAttachmentArrayNonUniformIndexing(), + shaderUniformTexelBufferArrayNonUniformIndexing(), + shaderStorageTexelBufferArrayNonUniformIndexing(), + descriptorBindingUniformBufferUpdateAfterBind(), + descriptorBindingSampledImageUpdateAfterBind(), + descriptorBindingStorageImageUpdateAfterBind(), + descriptorBindingStorageBufferUpdateAfterBind(), + descriptorBindingUniformTexelBufferUpdateAfterBind(), + descriptorBindingStorageTexelBufferUpdateAfterBind(), + descriptorBindingUpdateUnusedWhilePending(), + descriptorBindingPartiallyBound(), + descriptorBindingVariableDescriptorCount(), + runtimeDescriptorArray(), + samplerFilterMinmax(), + scalarBlockLayout(), + imagelessFramebuffer(), + uniformBufferStandardLayout(), + shaderSubgroupExtendedTypes(), + separateDepthStencilLayouts(), + hostQueryReset(), + timelineSemaphore(), + bufferDeviceAddress(), + bufferDeviceAddressCaptureReplay(), + bufferDeviceAddressMultiDevice(), + vulkanMemoryModel(), + vulkanMemoryModelDeviceScope(), + vulkanMemoryModelAvailabilityVisibilityChains(), + shaderOutputViewportIndex(), + shaderOutputLayer(), + subgroupBroadcastDynamicId() {} + +safe_VkPhysicalDeviceVulkan12Features::safe_VkPhysicalDeviceVulkan12Features( + const safe_VkPhysicalDeviceVulkan12Features& copy_src) { + sType = copy_src.sType; + samplerMirrorClampToEdge = copy_src.samplerMirrorClampToEdge; + drawIndirectCount = copy_src.drawIndirectCount; + storageBuffer8BitAccess = copy_src.storageBuffer8BitAccess; + uniformAndStorageBuffer8BitAccess = copy_src.uniformAndStorageBuffer8BitAccess; + storagePushConstant8 = copy_src.storagePushConstant8; + shaderBufferInt64Atomics = copy_src.shaderBufferInt64Atomics; + shaderSharedInt64Atomics = copy_src.shaderSharedInt64Atomics; + shaderFloat16 = copy_src.shaderFloat16; + shaderInt8 = copy_src.shaderInt8; + descriptorIndexing = copy_src.descriptorIndexing; + shaderInputAttachmentArrayDynamicIndexing = copy_src.shaderInputAttachmentArrayDynamicIndexing; + shaderUniformTexelBufferArrayDynamicIndexing = copy_src.shaderUniformTexelBufferArrayDynamicIndexing; + shaderStorageTexelBufferArrayDynamicIndexing = copy_src.shaderStorageTexelBufferArrayDynamicIndexing; + shaderUniformBufferArrayNonUniformIndexing = copy_src.shaderUniformBufferArrayNonUniformIndexing; + shaderSampledImageArrayNonUniformIndexing = copy_src.shaderSampledImageArrayNonUniformIndexing; + shaderStorageBufferArrayNonUniformIndexing = copy_src.shaderStorageBufferArrayNonUniformIndexing; + shaderStorageImageArrayNonUniformIndexing = copy_src.shaderStorageImageArrayNonUniformIndexing; + shaderInputAttachmentArrayNonUniformIndexing = copy_src.shaderInputAttachmentArrayNonUniformIndexing; + shaderUniformTexelBufferArrayNonUniformIndexing = copy_src.shaderUniformTexelBufferArrayNonUniformIndexing; + shaderStorageTexelBufferArrayNonUniformIndexing = copy_src.shaderStorageTexelBufferArrayNonUniformIndexing; + descriptorBindingUniformBufferUpdateAfterBind = copy_src.descriptorBindingUniformBufferUpdateAfterBind; + descriptorBindingSampledImageUpdateAfterBind = copy_src.descriptorBindingSampledImageUpdateAfterBind; + descriptorBindingStorageImageUpdateAfterBind = copy_src.descriptorBindingStorageImageUpdateAfterBind; + descriptorBindingStorageBufferUpdateAfterBind = copy_src.descriptorBindingStorageBufferUpdateAfterBind; + descriptorBindingUniformTexelBufferUpdateAfterBind = copy_src.descriptorBindingUniformTexelBufferUpdateAfterBind; + descriptorBindingStorageTexelBufferUpdateAfterBind = copy_src.descriptorBindingStorageTexelBufferUpdateAfterBind; + descriptorBindingUpdateUnusedWhilePending = copy_src.descriptorBindingUpdateUnusedWhilePending; + descriptorBindingPartiallyBound = copy_src.descriptorBindingPartiallyBound; + descriptorBindingVariableDescriptorCount = copy_src.descriptorBindingVariableDescriptorCount; + runtimeDescriptorArray = copy_src.runtimeDescriptorArray; + samplerFilterMinmax = copy_src.samplerFilterMinmax; + scalarBlockLayout = copy_src.scalarBlockLayout; + imagelessFramebuffer = copy_src.imagelessFramebuffer; + uniformBufferStandardLayout = copy_src.uniformBufferStandardLayout; + shaderSubgroupExtendedTypes = copy_src.shaderSubgroupExtendedTypes; + separateDepthStencilLayouts = copy_src.separateDepthStencilLayouts; + hostQueryReset = copy_src.hostQueryReset; + timelineSemaphore = copy_src.timelineSemaphore; + bufferDeviceAddress = copy_src.bufferDeviceAddress; + bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay; + bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice; + vulkanMemoryModel = copy_src.vulkanMemoryModel; + vulkanMemoryModelDeviceScope = copy_src.vulkanMemoryModelDeviceScope; + vulkanMemoryModelAvailabilityVisibilityChains = copy_src.vulkanMemoryModelAvailabilityVisibilityChains; + shaderOutputViewportIndex = copy_src.shaderOutputViewportIndex; + shaderOutputLayer = copy_src.shaderOutputLayer; + subgroupBroadcastDynamicId = copy_src.subgroupBroadcastDynamicId; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceVulkan12Features& safe_VkPhysicalDeviceVulkan12Features::operator=( + const safe_VkPhysicalDeviceVulkan12Features& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + samplerMirrorClampToEdge = copy_src.samplerMirrorClampToEdge; + drawIndirectCount = copy_src.drawIndirectCount; + storageBuffer8BitAccess = copy_src.storageBuffer8BitAccess; + uniformAndStorageBuffer8BitAccess = copy_src.uniformAndStorageBuffer8BitAccess; + storagePushConstant8 = copy_src.storagePushConstant8; + shaderBufferInt64Atomics = copy_src.shaderBufferInt64Atomics; + shaderSharedInt64Atomics = copy_src.shaderSharedInt64Atomics; + shaderFloat16 = copy_src.shaderFloat16; + shaderInt8 = copy_src.shaderInt8; + descriptorIndexing = copy_src.descriptorIndexing; + shaderInputAttachmentArrayDynamicIndexing = copy_src.shaderInputAttachmentArrayDynamicIndexing; + shaderUniformTexelBufferArrayDynamicIndexing = copy_src.shaderUniformTexelBufferArrayDynamicIndexing; + shaderStorageTexelBufferArrayDynamicIndexing = copy_src.shaderStorageTexelBufferArrayDynamicIndexing; + shaderUniformBufferArrayNonUniformIndexing = copy_src.shaderUniformBufferArrayNonUniformIndexing; + shaderSampledImageArrayNonUniformIndexing = copy_src.shaderSampledImageArrayNonUniformIndexing; + shaderStorageBufferArrayNonUniformIndexing = copy_src.shaderStorageBufferArrayNonUniformIndexing; + shaderStorageImageArrayNonUniformIndexing = copy_src.shaderStorageImageArrayNonUniformIndexing; + shaderInputAttachmentArrayNonUniformIndexing = copy_src.shaderInputAttachmentArrayNonUniformIndexing; + shaderUniformTexelBufferArrayNonUniformIndexing = copy_src.shaderUniformTexelBufferArrayNonUniformIndexing; + shaderStorageTexelBufferArrayNonUniformIndexing = copy_src.shaderStorageTexelBufferArrayNonUniformIndexing; + descriptorBindingUniformBufferUpdateAfterBind = copy_src.descriptorBindingUniformBufferUpdateAfterBind; + descriptorBindingSampledImageUpdateAfterBind = copy_src.descriptorBindingSampledImageUpdateAfterBind; + descriptorBindingStorageImageUpdateAfterBind = copy_src.descriptorBindingStorageImageUpdateAfterBind; + descriptorBindingStorageBufferUpdateAfterBind = copy_src.descriptorBindingStorageBufferUpdateAfterBind; + descriptorBindingUniformTexelBufferUpdateAfterBind = copy_src.descriptorBindingUniformTexelBufferUpdateAfterBind; + descriptorBindingStorageTexelBufferUpdateAfterBind = copy_src.descriptorBindingStorageTexelBufferUpdateAfterBind; + descriptorBindingUpdateUnusedWhilePending = copy_src.descriptorBindingUpdateUnusedWhilePending; + descriptorBindingPartiallyBound = copy_src.descriptorBindingPartiallyBound; + descriptorBindingVariableDescriptorCount = copy_src.descriptorBindingVariableDescriptorCount; + runtimeDescriptorArray = copy_src.runtimeDescriptorArray; + samplerFilterMinmax = copy_src.samplerFilterMinmax; + scalarBlockLayout = copy_src.scalarBlockLayout; + imagelessFramebuffer = copy_src.imagelessFramebuffer; + uniformBufferStandardLayout = copy_src.uniformBufferStandardLayout; + shaderSubgroupExtendedTypes = copy_src.shaderSubgroupExtendedTypes; + separateDepthStencilLayouts = copy_src.separateDepthStencilLayouts; + hostQueryReset = copy_src.hostQueryReset; + timelineSemaphore = copy_src.timelineSemaphore; + bufferDeviceAddress = copy_src.bufferDeviceAddress; + bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay; + bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice; + vulkanMemoryModel = copy_src.vulkanMemoryModel; + vulkanMemoryModelDeviceScope = copy_src.vulkanMemoryModelDeviceScope; + vulkanMemoryModelAvailabilityVisibilityChains = copy_src.vulkanMemoryModelAvailabilityVisibilityChains; + shaderOutputViewportIndex = copy_src.shaderOutputViewportIndex; + shaderOutputLayer = copy_src.shaderOutputLayer; + subgroupBroadcastDynamicId = copy_src.subgroupBroadcastDynamicId; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceVulkan12Features::~safe_VkPhysicalDeviceVulkan12Features() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceVulkan12Features::initialize(const VkPhysicalDeviceVulkan12Features* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + samplerMirrorClampToEdge = in_struct->samplerMirrorClampToEdge; + drawIndirectCount = in_struct->drawIndirectCount; + storageBuffer8BitAccess = in_struct->storageBuffer8BitAccess; + uniformAndStorageBuffer8BitAccess = in_struct->uniformAndStorageBuffer8BitAccess; + storagePushConstant8 = in_struct->storagePushConstant8; + shaderBufferInt64Atomics = in_struct->shaderBufferInt64Atomics; + shaderSharedInt64Atomics = in_struct->shaderSharedInt64Atomics; + shaderFloat16 = in_struct->shaderFloat16; + shaderInt8 = in_struct->shaderInt8; + descriptorIndexing = in_struct->descriptorIndexing; + shaderInputAttachmentArrayDynamicIndexing = in_struct->shaderInputAttachmentArrayDynamicIndexing; + shaderUniformTexelBufferArrayDynamicIndexing = in_struct->shaderUniformTexelBufferArrayDynamicIndexing; + shaderStorageTexelBufferArrayDynamicIndexing = in_struct->shaderStorageTexelBufferArrayDynamicIndexing; + shaderUniformBufferArrayNonUniformIndexing = in_struct->shaderUniformBufferArrayNonUniformIndexing; + shaderSampledImageArrayNonUniformIndexing = in_struct->shaderSampledImageArrayNonUniformIndexing; + shaderStorageBufferArrayNonUniformIndexing = in_struct->shaderStorageBufferArrayNonUniformIndexing; + shaderStorageImageArrayNonUniformIndexing = in_struct->shaderStorageImageArrayNonUniformIndexing; + shaderInputAttachmentArrayNonUniformIndexing = in_struct->shaderInputAttachmentArrayNonUniformIndexing; + shaderUniformTexelBufferArrayNonUniformIndexing = in_struct->shaderUniformTexelBufferArrayNonUniformIndexing; + shaderStorageTexelBufferArrayNonUniformIndexing = in_struct->shaderStorageTexelBufferArrayNonUniformIndexing; + descriptorBindingUniformBufferUpdateAfterBind = in_struct->descriptorBindingUniformBufferUpdateAfterBind; + descriptorBindingSampledImageUpdateAfterBind = in_struct->descriptorBindingSampledImageUpdateAfterBind; + descriptorBindingStorageImageUpdateAfterBind = in_struct->descriptorBindingStorageImageUpdateAfterBind; + descriptorBindingStorageBufferUpdateAfterBind = in_struct->descriptorBindingStorageBufferUpdateAfterBind; + descriptorBindingUniformTexelBufferUpdateAfterBind = in_struct->descriptorBindingUniformTexelBufferUpdateAfterBind; + descriptorBindingStorageTexelBufferUpdateAfterBind = in_struct->descriptorBindingStorageTexelBufferUpdateAfterBind; + descriptorBindingUpdateUnusedWhilePending = in_struct->descriptorBindingUpdateUnusedWhilePending; + descriptorBindingPartiallyBound = in_struct->descriptorBindingPartiallyBound; + descriptorBindingVariableDescriptorCount = in_struct->descriptorBindingVariableDescriptorCount; + runtimeDescriptorArray = in_struct->runtimeDescriptorArray; + samplerFilterMinmax = in_struct->samplerFilterMinmax; + scalarBlockLayout = in_struct->scalarBlockLayout; + imagelessFramebuffer = in_struct->imagelessFramebuffer; + uniformBufferStandardLayout = in_struct->uniformBufferStandardLayout; + shaderSubgroupExtendedTypes = in_struct->shaderSubgroupExtendedTypes; + separateDepthStencilLayouts = in_struct->separateDepthStencilLayouts; + hostQueryReset = in_struct->hostQueryReset; + timelineSemaphore = in_struct->timelineSemaphore; + bufferDeviceAddress = in_struct->bufferDeviceAddress; + bufferDeviceAddressCaptureReplay = in_struct->bufferDeviceAddressCaptureReplay; + bufferDeviceAddressMultiDevice = in_struct->bufferDeviceAddressMultiDevice; + vulkanMemoryModel = in_struct->vulkanMemoryModel; + vulkanMemoryModelDeviceScope = in_struct->vulkanMemoryModelDeviceScope; + vulkanMemoryModelAvailabilityVisibilityChains = in_struct->vulkanMemoryModelAvailabilityVisibilityChains; + shaderOutputViewportIndex = in_struct->shaderOutputViewportIndex; + shaderOutputLayer = in_struct->shaderOutputLayer; + subgroupBroadcastDynamicId = in_struct->subgroupBroadcastDynamicId; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceVulkan12Features::initialize(const safe_VkPhysicalDeviceVulkan12Features* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + samplerMirrorClampToEdge = copy_src->samplerMirrorClampToEdge; + drawIndirectCount = copy_src->drawIndirectCount; + storageBuffer8BitAccess = copy_src->storageBuffer8BitAccess; + uniformAndStorageBuffer8BitAccess = copy_src->uniformAndStorageBuffer8BitAccess; + storagePushConstant8 = copy_src->storagePushConstant8; + shaderBufferInt64Atomics = copy_src->shaderBufferInt64Atomics; + shaderSharedInt64Atomics = copy_src->shaderSharedInt64Atomics; + shaderFloat16 = copy_src->shaderFloat16; + shaderInt8 = copy_src->shaderInt8; + descriptorIndexing = copy_src->descriptorIndexing; + shaderInputAttachmentArrayDynamicIndexing = copy_src->shaderInputAttachmentArrayDynamicIndexing; + shaderUniformTexelBufferArrayDynamicIndexing = copy_src->shaderUniformTexelBufferArrayDynamicIndexing; + shaderStorageTexelBufferArrayDynamicIndexing = copy_src->shaderStorageTexelBufferArrayDynamicIndexing; + shaderUniformBufferArrayNonUniformIndexing = copy_src->shaderUniformBufferArrayNonUniformIndexing; + shaderSampledImageArrayNonUniformIndexing = copy_src->shaderSampledImageArrayNonUniformIndexing; + shaderStorageBufferArrayNonUniformIndexing = copy_src->shaderStorageBufferArrayNonUniformIndexing; + shaderStorageImageArrayNonUniformIndexing = copy_src->shaderStorageImageArrayNonUniformIndexing; + shaderInputAttachmentArrayNonUniformIndexing = copy_src->shaderInputAttachmentArrayNonUniformIndexing; + shaderUniformTexelBufferArrayNonUniformIndexing = copy_src->shaderUniformTexelBufferArrayNonUniformIndexing; + shaderStorageTexelBufferArrayNonUniformIndexing = copy_src->shaderStorageTexelBufferArrayNonUniformIndexing; + descriptorBindingUniformBufferUpdateAfterBind = copy_src->descriptorBindingUniformBufferUpdateAfterBind; + descriptorBindingSampledImageUpdateAfterBind = copy_src->descriptorBindingSampledImageUpdateAfterBind; + descriptorBindingStorageImageUpdateAfterBind = copy_src->descriptorBindingStorageImageUpdateAfterBind; + descriptorBindingStorageBufferUpdateAfterBind = copy_src->descriptorBindingStorageBufferUpdateAfterBind; + descriptorBindingUniformTexelBufferUpdateAfterBind = copy_src->descriptorBindingUniformTexelBufferUpdateAfterBind; + descriptorBindingStorageTexelBufferUpdateAfterBind = copy_src->descriptorBindingStorageTexelBufferUpdateAfterBind; + descriptorBindingUpdateUnusedWhilePending = copy_src->descriptorBindingUpdateUnusedWhilePending; + descriptorBindingPartiallyBound = copy_src->descriptorBindingPartiallyBound; + descriptorBindingVariableDescriptorCount = copy_src->descriptorBindingVariableDescriptorCount; + runtimeDescriptorArray = copy_src->runtimeDescriptorArray; + samplerFilterMinmax = copy_src->samplerFilterMinmax; + scalarBlockLayout = copy_src->scalarBlockLayout; + imagelessFramebuffer = copy_src->imagelessFramebuffer; + uniformBufferStandardLayout = copy_src->uniformBufferStandardLayout; + shaderSubgroupExtendedTypes = copy_src->shaderSubgroupExtendedTypes; + separateDepthStencilLayouts = copy_src->separateDepthStencilLayouts; + hostQueryReset = copy_src->hostQueryReset; + timelineSemaphore = copy_src->timelineSemaphore; + bufferDeviceAddress = copy_src->bufferDeviceAddress; + bufferDeviceAddressCaptureReplay = copy_src->bufferDeviceAddressCaptureReplay; + bufferDeviceAddressMultiDevice = copy_src->bufferDeviceAddressMultiDevice; + vulkanMemoryModel = copy_src->vulkanMemoryModel; + vulkanMemoryModelDeviceScope = copy_src->vulkanMemoryModelDeviceScope; + vulkanMemoryModelAvailabilityVisibilityChains = copy_src->vulkanMemoryModelAvailabilityVisibilityChains; + shaderOutputViewportIndex = copy_src->shaderOutputViewportIndex; + shaderOutputLayer = copy_src->shaderOutputLayer; + subgroupBroadcastDynamicId = copy_src->subgroupBroadcastDynamicId; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceVulkan12Properties::safe_VkPhysicalDeviceVulkan12Properties( + const VkPhysicalDeviceVulkan12Properties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + driverID(in_struct->driverID), + conformanceVersion(in_struct->conformanceVersion), + denormBehaviorIndependence(in_struct->denormBehaviorIndependence), + roundingModeIndependence(in_struct->roundingModeIndependence), + shaderSignedZeroInfNanPreserveFloat16(in_struct->shaderSignedZeroInfNanPreserveFloat16), + shaderSignedZeroInfNanPreserveFloat32(in_struct->shaderSignedZeroInfNanPreserveFloat32), + shaderSignedZeroInfNanPreserveFloat64(in_struct->shaderSignedZeroInfNanPreserveFloat64), + shaderDenormPreserveFloat16(in_struct->shaderDenormPreserveFloat16), + shaderDenormPreserveFloat32(in_struct->shaderDenormPreserveFloat32), + shaderDenormPreserveFloat64(in_struct->shaderDenormPreserveFloat64), + shaderDenormFlushToZeroFloat16(in_struct->shaderDenormFlushToZeroFloat16), + shaderDenormFlushToZeroFloat32(in_struct->shaderDenormFlushToZeroFloat32), + shaderDenormFlushToZeroFloat64(in_struct->shaderDenormFlushToZeroFloat64), + shaderRoundingModeRTEFloat16(in_struct->shaderRoundingModeRTEFloat16), + shaderRoundingModeRTEFloat32(in_struct->shaderRoundingModeRTEFloat32), + shaderRoundingModeRTEFloat64(in_struct->shaderRoundingModeRTEFloat64), + shaderRoundingModeRTZFloat16(in_struct->shaderRoundingModeRTZFloat16), + shaderRoundingModeRTZFloat32(in_struct->shaderRoundingModeRTZFloat32), + shaderRoundingModeRTZFloat64(in_struct->shaderRoundingModeRTZFloat64), + maxUpdateAfterBindDescriptorsInAllPools(in_struct->maxUpdateAfterBindDescriptorsInAllPools), + shaderUniformBufferArrayNonUniformIndexingNative(in_struct->shaderUniformBufferArrayNonUniformIndexingNative), + shaderSampledImageArrayNonUniformIndexingNative(in_struct->shaderSampledImageArrayNonUniformIndexingNative), + shaderStorageBufferArrayNonUniformIndexingNative(in_struct->shaderStorageBufferArrayNonUniformIndexingNative), + shaderStorageImageArrayNonUniformIndexingNative(in_struct->shaderStorageImageArrayNonUniformIndexingNative), + shaderInputAttachmentArrayNonUniformIndexingNative(in_struct->shaderInputAttachmentArrayNonUniformIndexingNative), + robustBufferAccessUpdateAfterBind(in_struct->robustBufferAccessUpdateAfterBind), + quadDivergentImplicitLod(in_struct->quadDivergentImplicitLod), + maxPerStageDescriptorUpdateAfterBindSamplers(in_struct->maxPerStageDescriptorUpdateAfterBindSamplers), + maxPerStageDescriptorUpdateAfterBindUniformBuffers(in_struct->maxPerStageDescriptorUpdateAfterBindUniformBuffers), + maxPerStageDescriptorUpdateAfterBindStorageBuffers(in_struct->maxPerStageDescriptorUpdateAfterBindStorageBuffers), + maxPerStageDescriptorUpdateAfterBindSampledImages(in_struct->maxPerStageDescriptorUpdateAfterBindSampledImages), + maxPerStageDescriptorUpdateAfterBindStorageImages(in_struct->maxPerStageDescriptorUpdateAfterBindStorageImages), + maxPerStageDescriptorUpdateAfterBindInputAttachments(in_struct->maxPerStageDescriptorUpdateAfterBindInputAttachments), + maxPerStageUpdateAfterBindResources(in_struct->maxPerStageUpdateAfterBindResources), + maxDescriptorSetUpdateAfterBindSamplers(in_struct->maxDescriptorSetUpdateAfterBindSamplers), + maxDescriptorSetUpdateAfterBindUniformBuffers(in_struct->maxDescriptorSetUpdateAfterBindUniformBuffers), + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic(in_struct->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic), + maxDescriptorSetUpdateAfterBindStorageBuffers(in_struct->maxDescriptorSetUpdateAfterBindStorageBuffers), + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic(in_struct->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic), + maxDescriptorSetUpdateAfterBindSampledImages(in_struct->maxDescriptorSetUpdateAfterBindSampledImages), + maxDescriptorSetUpdateAfterBindStorageImages(in_struct->maxDescriptorSetUpdateAfterBindStorageImages), + maxDescriptorSetUpdateAfterBindInputAttachments(in_struct->maxDescriptorSetUpdateAfterBindInputAttachments), + supportedDepthResolveModes(in_struct->supportedDepthResolveModes), + supportedStencilResolveModes(in_struct->supportedStencilResolveModes), + independentResolveNone(in_struct->independentResolveNone), + independentResolve(in_struct->independentResolve), + filterMinmaxSingleComponentFormats(in_struct->filterMinmaxSingleComponentFormats), + filterMinmaxImageComponentMapping(in_struct->filterMinmaxImageComponentMapping), + maxTimelineSemaphoreValueDifference(in_struct->maxTimelineSemaphoreValueDifference), + framebufferIntegerColorSampleCounts(in_struct->framebufferIntegerColorSampleCounts) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) { + driverName[i] = in_struct->driverName[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) { + driverInfo[i] = in_struct->driverInfo[i]; + } +} + +safe_VkPhysicalDeviceVulkan12Properties::safe_VkPhysicalDeviceVulkan12Properties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES), + pNext(nullptr), + driverID(), + conformanceVersion(), + denormBehaviorIndependence(), + roundingModeIndependence(), + shaderSignedZeroInfNanPreserveFloat16(), + shaderSignedZeroInfNanPreserveFloat32(), + shaderSignedZeroInfNanPreserveFloat64(), + shaderDenormPreserveFloat16(), + shaderDenormPreserveFloat32(), + shaderDenormPreserveFloat64(), + shaderDenormFlushToZeroFloat16(), + shaderDenormFlushToZeroFloat32(), + shaderDenormFlushToZeroFloat64(), + shaderRoundingModeRTEFloat16(), + shaderRoundingModeRTEFloat32(), + shaderRoundingModeRTEFloat64(), + shaderRoundingModeRTZFloat16(), + shaderRoundingModeRTZFloat32(), + shaderRoundingModeRTZFloat64(), + maxUpdateAfterBindDescriptorsInAllPools(), + shaderUniformBufferArrayNonUniformIndexingNative(), + shaderSampledImageArrayNonUniformIndexingNative(), + shaderStorageBufferArrayNonUniformIndexingNative(), + shaderStorageImageArrayNonUniformIndexingNative(), + shaderInputAttachmentArrayNonUniformIndexingNative(), + robustBufferAccessUpdateAfterBind(), + quadDivergentImplicitLod(), + maxPerStageDescriptorUpdateAfterBindSamplers(), + maxPerStageDescriptorUpdateAfterBindUniformBuffers(), + maxPerStageDescriptorUpdateAfterBindStorageBuffers(), + maxPerStageDescriptorUpdateAfterBindSampledImages(), + maxPerStageDescriptorUpdateAfterBindStorageImages(), + maxPerStageDescriptorUpdateAfterBindInputAttachments(), + maxPerStageUpdateAfterBindResources(), + maxDescriptorSetUpdateAfterBindSamplers(), + maxDescriptorSetUpdateAfterBindUniformBuffers(), + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic(), + maxDescriptorSetUpdateAfterBindStorageBuffers(), + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic(), + maxDescriptorSetUpdateAfterBindSampledImages(), + maxDescriptorSetUpdateAfterBindStorageImages(), + maxDescriptorSetUpdateAfterBindInputAttachments(), + supportedDepthResolveModes(), + supportedStencilResolveModes(), + independentResolveNone(), + independentResolve(), + filterMinmaxSingleComponentFormats(), + filterMinmaxImageComponentMapping(), + maxTimelineSemaphoreValueDifference(), + framebufferIntegerColorSampleCounts() {} + +safe_VkPhysicalDeviceVulkan12Properties::safe_VkPhysicalDeviceVulkan12Properties( + const safe_VkPhysicalDeviceVulkan12Properties& copy_src) { + sType = copy_src.sType; + driverID = copy_src.driverID; + conformanceVersion = copy_src.conformanceVersion; + denormBehaviorIndependence = copy_src.denormBehaviorIndependence; + roundingModeIndependence = copy_src.roundingModeIndependence; + shaderSignedZeroInfNanPreserveFloat16 = copy_src.shaderSignedZeroInfNanPreserveFloat16; + shaderSignedZeroInfNanPreserveFloat32 = copy_src.shaderSignedZeroInfNanPreserveFloat32; + shaderSignedZeroInfNanPreserveFloat64 = copy_src.shaderSignedZeroInfNanPreserveFloat64; + shaderDenormPreserveFloat16 = copy_src.shaderDenormPreserveFloat16; + shaderDenormPreserveFloat32 = copy_src.shaderDenormPreserveFloat32; + shaderDenormPreserveFloat64 = copy_src.shaderDenormPreserveFloat64; + shaderDenormFlushToZeroFloat16 = copy_src.shaderDenormFlushToZeroFloat16; + shaderDenormFlushToZeroFloat32 = copy_src.shaderDenormFlushToZeroFloat32; + shaderDenormFlushToZeroFloat64 = copy_src.shaderDenormFlushToZeroFloat64; + shaderRoundingModeRTEFloat16 = copy_src.shaderRoundingModeRTEFloat16; + shaderRoundingModeRTEFloat32 = copy_src.shaderRoundingModeRTEFloat32; + shaderRoundingModeRTEFloat64 = copy_src.shaderRoundingModeRTEFloat64; + shaderRoundingModeRTZFloat16 = copy_src.shaderRoundingModeRTZFloat16; + shaderRoundingModeRTZFloat32 = copy_src.shaderRoundingModeRTZFloat32; + shaderRoundingModeRTZFloat64 = copy_src.shaderRoundingModeRTZFloat64; + maxUpdateAfterBindDescriptorsInAllPools = copy_src.maxUpdateAfterBindDescriptorsInAllPools; + shaderUniformBufferArrayNonUniformIndexingNative = copy_src.shaderUniformBufferArrayNonUniformIndexingNative; + shaderSampledImageArrayNonUniformIndexingNative = copy_src.shaderSampledImageArrayNonUniformIndexingNative; + shaderStorageBufferArrayNonUniformIndexingNative = copy_src.shaderStorageBufferArrayNonUniformIndexingNative; + shaderStorageImageArrayNonUniformIndexingNative = copy_src.shaderStorageImageArrayNonUniformIndexingNative; + shaderInputAttachmentArrayNonUniformIndexingNative = copy_src.shaderInputAttachmentArrayNonUniformIndexingNative; + robustBufferAccessUpdateAfterBind = copy_src.robustBufferAccessUpdateAfterBind; + quadDivergentImplicitLod = copy_src.quadDivergentImplicitLod; + maxPerStageDescriptorUpdateAfterBindSamplers = copy_src.maxPerStageDescriptorUpdateAfterBindSamplers; + maxPerStageDescriptorUpdateAfterBindUniformBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindUniformBuffers; + maxPerStageDescriptorUpdateAfterBindStorageBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindStorageBuffers; + maxPerStageDescriptorUpdateAfterBindSampledImages = copy_src.maxPerStageDescriptorUpdateAfterBindSampledImages; + maxPerStageDescriptorUpdateAfterBindStorageImages = copy_src.maxPerStageDescriptorUpdateAfterBindStorageImages; + maxPerStageDescriptorUpdateAfterBindInputAttachments = copy_src.maxPerStageDescriptorUpdateAfterBindInputAttachments; + maxPerStageUpdateAfterBindResources = copy_src.maxPerStageUpdateAfterBindResources; + maxDescriptorSetUpdateAfterBindSamplers = copy_src.maxDescriptorSetUpdateAfterBindSamplers; + maxDescriptorSetUpdateAfterBindUniformBuffers = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffers; + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + maxDescriptorSetUpdateAfterBindStorageBuffers = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffers; + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + maxDescriptorSetUpdateAfterBindSampledImages = copy_src.maxDescriptorSetUpdateAfterBindSampledImages; + maxDescriptorSetUpdateAfterBindStorageImages = copy_src.maxDescriptorSetUpdateAfterBindStorageImages; + maxDescriptorSetUpdateAfterBindInputAttachments = copy_src.maxDescriptorSetUpdateAfterBindInputAttachments; + supportedDepthResolveModes = copy_src.supportedDepthResolveModes; + supportedStencilResolveModes = copy_src.supportedStencilResolveModes; + independentResolveNone = copy_src.independentResolveNone; + independentResolve = copy_src.independentResolve; + filterMinmaxSingleComponentFormats = copy_src.filterMinmaxSingleComponentFormats; + filterMinmaxImageComponentMapping = copy_src.filterMinmaxImageComponentMapping; + maxTimelineSemaphoreValueDifference = copy_src.maxTimelineSemaphoreValueDifference; + framebufferIntegerColorSampleCounts = copy_src.framebufferIntegerColorSampleCounts; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) { + driverName[i] = copy_src.driverName[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) { + driverInfo[i] = copy_src.driverInfo[i]; + } +} + +safe_VkPhysicalDeviceVulkan12Properties& safe_VkPhysicalDeviceVulkan12Properties::operator=( + const safe_VkPhysicalDeviceVulkan12Properties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + driverID = copy_src.driverID; + conformanceVersion = copy_src.conformanceVersion; + denormBehaviorIndependence = copy_src.denormBehaviorIndependence; + roundingModeIndependence = copy_src.roundingModeIndependence; + shaderSignedZeroInfNanPreserveFloat16 = copy_src.shaderSignedZeroInfNanPreserveFloat16; + shaderSignedZeroInfNanPreserveFloat32 = copy_src.shaderSignedZeroInfNanPreserveFloat32; + shaderSignedZeroInfNanPreserveFloat64 = copy_src.shaderSignedZeroInfNanPreserveFloat64; + shaderDenormPreserveFloat16 = copy_src.shaderDenormPreserveFloat16; + shaderDenormPreserveFloat32 = copy_src.shaderDenormPreserveFloat32; + shaderDenormPreserveFloat64 = copy_src.shaderDenormPreserveFloat64; + shaderDenormFlushToZeroFloat16 = copy_src.shaderDenormFlushToZeroFloat16; + shaderDenormFlushToZeroFloat32 = copy_src.shaderDenormFlushToZeroFloat32; + shaderDenormFlushToZeroFloat64 = copy_src.shaderDenormFlushToZeroFloat64; + shaderRoundingModeRTEFloat16 = copy_src.shaderRoundingModeRTEFloat16; + shaderRoundingModeRTEFloat32 = copy_src.shaderRoundingModeRTEFloat32; + shaderRoundingModeRTEFloat64 = copy_src.shaderRoundingModeRTEFloat64; + shaderRoundingModeRTZFloat16 = copy_src.shaderRoundingModeRTZFloat16; + shaderRoundingModeRTZFloat32 = copy_src.shaderRoundingModeRTZFloat32; + shaderRoundingModeRTZFloat64 = copy_src.shaderRoundingModeRTZFloat64; + maxUpdateAfterBindDescriptorsInAllPools = copy_src.maxUpdateAfterBindDescriptorsInAllPools; + shaderUniformBufferArrayNonUniformIndexingNative = copy_src.shaderUniformBufferArrayNonUniformIndexingNative; + shaderSampledImageArrayNonUniformIndexingNative = copy_src.shaderSampledImageArrayNonUniformIndexingNative; + shaderStorageBufferArrayNonUniformIndexingNative = copy_src.shaderStorageBufferArrayNonUniformIndexingNative; + shaderStorageImageArrayNonUniformIndexingNative = copy_src.shaderStorageImageArrayNonUniformIndexingNative; + shaderInputAttachmentArrayNonUniformIndexingNative = copy_src.shaderInputAttachmentArrayNonUniformIndexingNative; + robustBufferAccessUpdateAfterBind = copy_src.robustBufferAccessUpdateAfterBind; + quadDivergentImplicitLod = copy_src.quadDivergentImplicitLod; + maxPerStageDescriptorUpdateAfterBindSamplers = copy_src.maxPerStageDescriptorUpdateAfterBindSamplers; + maxPerStageDescriptorUpdateAfterBindUniformBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindUniformBuffers; + maxPerStageDescriptorUpdateAfterBindStorageBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindStorageBuffers; + maxPerStageDescriptorUpdateAfterBindSampledImages = copy_src.maxPerStageDescriptorUpdateAfterBindSampledImages; + maxPerStageDescriptorUpdateAfterBindStorageImages = copy_src.maxPerStageDescriptorUpdateAfterBindStorageImages; + maxPerStageDescriptorUpdateAfterBindInputAttachments = copy_src.maxPerStageDescriptorUpdateAfterBindInputAttachments; + maxPerStageUpdateAfterBindResources = copy_src.maxPerStageUpdateAfterBindResources; + maxDescriptorSetUpdateAfterBindSamplers = copy_src.maxDescriptorSetUpdateAfterBindSamplers; + maxDescriptorSetUpdateAfterBindUniformBuffers = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffers; + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + maxDescriptorSetUpdateAfterBindStorageBuffers = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffers; + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + maxDescriptorSetUpdateAfterBindSampledImages = copy_src.maxDescriptorSetUpdateAfterBindSampledImages; + maxDescriptorSetUpdateAfterBindStorageImages = copy_src.maxDescriptorSetUpdateAfterBindStorageImages; + maxDescriptorSetUpdateAfterBindInputAttachments = copy_src.maxDescriptorSetUpdateAfterBindInputAttachments; + supportedDepthResolveModes = copy_src.supportedDepthResolveModes; + supportedStencilResolveModes = copy_src.supportedStencilResolveModes; + independentResolveNone = copy_src.independentResolveNone; + independentResolve = copy_src.independentResolve; + filterMinmaxSingleComponentFormats = copy_src.filterMinmaxSingleComponentFormats; + filterMinmaxImageComponentMapping = copy_src.filterMinmaxImageComponentMapping; + maxTimelineSemaphoreValueDifference = copy_src.maxTimelineSemaphoreValueDifference; + framebufferIntegerColorSampleCounts = copy_src.framebufferIntegerColorSampleCounts; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) { + driverName[i] = copy_src.driverName[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) { + driverInfo[i] = copy_src.driverInfo[i]; + } + + return *this; +} + +safe_VkPhysicalDeviceVulkan12Properties::~safe_VkPhysicalDeviceVulkan12Properties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceVulkan12Properties::initialize(const VkPhysicalDeviceVulkan12Properties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + driverID = in_struct->driverID; + conformanceVersion = in_struct->conformanceVersion; + denormBehaviorIndependence = in_struct->denormBehaviorIndependence; + roundingModeIndependence = in_struct->roundingModeIndependence; + shaderSignedZeroInfNanPreserveFloat16 = in_struct->shaderSignedZeroInfNanPreserveFloat16; + shaderSignedZeroInfNanPreserveFloat32 = in_struct->shaderSignedZeroInfNanPreserveFloat32; + shaderSignedZeroInfNanPreserveFloat64 = in_struct->shaderSignedZeroInfNanPreserveFloat64; + shaderDenormPreserveFloat16 = in_struct->shaderDenormPreserveFloat16; + shaderDenormPreserveFloat32 = in_struct->shaderDenormPreserveFloat32; + shaderDenormPreserveFloat64 = in_struct->shaderDenormPreserveFloat64; + shaderDenormFlushToZeroFloat16 = in_struct->shaderDenormFlushToZeroFloat16; + shaderDenormFlushToZeroFloat32 = in_struct->shaderDenormFlushToZeroFloat32; + shaderDenormFlushToZeroFloat64 = in_struct->shaderDenormFlushToZeroFloat64; + shaderRoundingModeRTEFloat16 = in_struct->shaderRoundingModeRTEFloat16; + shaderRoundingModeRTEFloat32 = in_struct->shaderRoundingModeRTEFloat32; + shaderRoundingModeRTEFloat64 = in_struct->shaderRoundingModeRTEFloat64; + shaderRoundingModeRTZFloat16 = in_struct->shaderRoundingModeRTZFloat16; + shaderRoundingModeRTZFloat32 = in_struct->shaderRoundingModeRTZFloat32; + shaderRoundingModeRTZFloat64 = in_struct->shaderRoundingModeRTZFloat64; + maxUpdateAfterBindDescriptorsInAllPools = in_struct->maxUpdateAfterBindDescriptorsInAllPools; + shaderUniformBufferArrayNonUniformIndexingNative = in_struct->shaderUniformBufferArrayNonUniformIndexingNative; + shaderSampledImageArrayNonUniformIndexingNative = in_struct->shaderSampledImageArrayNonUniformIndexingNative; + shaderStorageBufferArrayNonUniformIndexingNative = in_struct->shaderStorageBufferArrayNonUniformIndexingNative; + shaderStorageImageArrayNonUniformIndexingNative = in_struct->shaderStorageImageArrayNonUniformIndexingNative; + shaderInputAttachmentArrayNonUniformIndexingNative = in_struct->shaderInputAttachmentArrayNonUniformIndexingNative; + robustBufferAccessUpdateAfterBind = in_struct->robustBufferAccessUpdateAfterBind; + quadDivergentImplicitLod = in_struct->quadDivergentImplicitLod; + maxPerStageDescriptorUpdateAfterBindSamplers = in_struct->maxPerStageDescriptorUpdateAfterBindSamplers; + maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_struct->maxPerStageDescriptorUpdateAfterBindUniformBuffers; + maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_struct->maxPerStageDescriptorUpdateAfterBindStorageBuffers; + maxPerStageDescriptorUpdateAfterBindSampledImages = in_struct->maxPerStageDescriptorUpdateAfterBindSampledImages; + maxPerStageDescriptorUpdateAfterBindStorageImages = in_struct->maxPerStageDescriptorUpdateAfterBindStorageImages; + maxPerStageDescriptorUpdateAfterBindInputAttachments = in_struct->maxPerStageDescriptorUpdateAfterBindInputAttachments; + maxPerStageUpdateAfterBindResources = in_struct->maxPerStageUpdateAfterBindResources; + maxDescriptorSetUpdateAfterBindSamplers = in_struct->maxDescriptorSetUpdateAfterBindSamplers; + maxDescriptorSetUpdateAfterBindUniformBuffers = in_struct->maxDescriptorSetUpdateAfterBindUniformBuffers; + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_struct->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + maxDescriptorSetUpdateAfterBindStorageBuffers = in_struct->maxDescriptorSetUpdateAfterBindStorageBuffers; + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_struct->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + maxDescriptorSetUpdateAfterBindSampledImages = in_struct->maxDescriptorSetUpdateAfterBindSampledImages; + maxDescriptorSetUpdateAfterBindStorageImages = in_struct->maxDescriptorSetUpdateAfterBindStorageImages; + maxDescriptorSetUpdateAfterBindInputAttachments = in_struct->maxDescriptorSetUpdateAfterBindInputAttachments; + supportedDepthResolveModes = in_struct->supportedDepthResolveModes; + supportedStencilResolveModes = in_struct->supportedStencilResolveModes; + independentResolveNone = in_struct->independentResolveNone; + independentResolve = in_struct->independentResolve; + filterMinmaxSingleComponentFormats = in_struct->filterMinmaxSingleComponentFormats; + filterMinmaxImageComponentMapping = in_struct->filterMinmaxImageComponentMapping; + maxTimelineSemaphoreValueDifference = in_struct->maxTimelineSemaphoreValueDifference; + framebufferIntegerColorSampleCounts = in_struct->framebufferIntegerColorSampleCounts; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) { + driverName[i] = in_struct->driverName[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) { + driverInfo[i] = in_struct->driverInfo[i]; + } +} + +void safe_VkPhysicalDeviceVulkan12Properties::initialize(const safe_VkPhysicalDeviceVulkan12Properties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + driverID = copy_src->driverID; + conformanceVersion = copy_src->conformanceVersion; + denormBehaviorIndependence = copy_src->denormBehaviorIndependence; + roundingModeIndependence = copy_src->roundingModeIndependence; + shaderSignedZeroInfNanPreserveFloat16 = copy_src->shaderSignedZeroInfNanPreserveFloat16; + shaderSignedZeroInfNanPreserveFloat32 = copy_src->shaderSignedZeroInfNanPreserveFloat32; + shaderSignedZeroInfNanPreserveFloat64 = copy_src->shaderSignedZeroInfNanPreserveFloat64; + shaderDenormPreserveFloat16 = copy_src->shaderDenormPreserveFloat16; + shaderDenormPreserveFloat32 = copy_src->shaderDenormPreserveFloat32; + shaderDenormPreserveFloat64 = copy_src->shaderDenormPreserveFloat64; + shaderDenormFlushToZeroFloat16 = copy_src->shaderDenormFlushToZeroFloat16; + shaderDenormFlushToZeroFloat32 = copy_src->shaderDenormFlushToZeroFloat32; + shaderDenormFlushToZeroFloat64 = copy_src->shaderDenormFlushToZeroFloat64; + shaderRoundingModeRTEFloat16 = copy_src->shaderRoundingModeRTEFloat16; + shaderRoundingModeRTEFloat32 = copy_src->shaderRoundingModeRTEFloat32; + shaderRoundingModeRTEFloat64 = copy_src->shaderRoundingModeRTEFloat64; + shaderRoundingModeRTZFloat16 = copy_src->shaderRoundingModeRTZFloat16; + shaderRoundingModeRTZFloat32 = copy_src->shaderRoundingModeRTZFloat32; + shaderRoundingModeRTZFloat64 = copy_src->shaderRoundingModeRTZFloat64; + maxUpdateAfterBindDescriptorsInAllPools = copy_src->maxUpdateAfterBindDescriptorsInAllPools; + shaderUniformBufferArrayNonUniformIndexingNative = copy_src->shaderUniformBufferArrayNonUniformIndexingNative; + shaderSampledImageArrayNonUniformIndexingNative = copy_src->shaderSampledImageArrayNonUniformIndexingNative; + shaderStorageBufferArrayNonUniformIndexingNative = copy_src->shaderStorageBufferArrayNonUniformIndexingNative; + shaderStorageImageArrayNonUniformIndexingNative = copy_src->shaderStorageImageArrayNonUniformIndexingNative; + shaderInputAttachmentArrayNonUniformIndexingNative = copy_src->shaderInputAttachmentArrayNonUniformIndexingNative; + robustBufferAccessUpdateAfterBind = copy_src->robustBufferAccessUpdateAfterBind; + quadDivergentImplicitLod = copy_src->quadDivergentImplicitLod; + maxPerStageDescriptorUpdateAfterBindSamplers = copy_src->maxPerStageDescriptorUpdateAfterBindSamplers; + maxPerStageDescriptorUpdateAfterBindUniformBuffers = copy_src->maxPerStageDescriptorUpdateAfterBindUniformBuffers; + maxPerStageDescriptorUpdateAfterBindStorageBuffers = copy_src->maxPerStageDescriptorUpdateAfterBindStorageBuffers; + maxPerStageDescriptorUpdateAfterBindSampledImages = copy_src->maxPerStageDescriptorUpdateAfterBindSampledImages; + maxPerStageDescriptorUpdateAfterBindStorageImages = copy_src->maxPerStageDescriptorUpdateAfterBindStorageImages; + maxPerStageDescriptorUpdateAfterBindInputAttachments = copy_src->maxPerStageDescriptorUpdateAfterBindInputAttachments; + maxPerStageUpdateAfterBindResources = copy_src->maxPerStageUpdateAfterBindResources; + maxDescriptorSetUpdateAfterBindSamplers = copy_src->maxDescriptorSetUpdateAfterBindSamplers; + maxDescriptorSetUpdateAfterBindUniformBuffers = copy_src->maxDescriptorSetUpdateAfterBindUniformBuffers; + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = copy_src->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + maxDescriptorSetUpdateAfterBindStorageBuffers = copy_src->maxDescriptorSetUpdateAfterBindStorageBuffers; + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = copy_src->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + maxDescriptorSetUpdateAfterBindSampledImages = copy_src->maxDescriptorSetUpdateAfterBindSampledImages; + maxDescriptorSetUpdateAfterBindStorageImages = copy_src->maxDescriptorSetUpdateAfterBindStorageImages; + maxDescriptorSetUpdateAfterBindInputAttachments = copy_src->maxDescriptorSetUpdateAfterBindInputAttachments; + supportedDepthResolveModes = copy_src->supportedDepthResolveModes; + supportedStencilResolveModes = copy_src->supportedStencilResolveModes; + independentResolveNone = copy_src->independentResolveNone; + independentResolve = copy_src->independentResolve; + filterMinmaxSingleComponentFormats = copy_src->filterMinmaxSingleComponentFormats; + filterMinmaxImageComponentMapping = copy_src->filterMinmaxImageComponentMapping; + maxTimelineSemaphoreValueDifference = copy_src->maxTimelineSemaphoreValueDifference; + framebufferIntegerColorSampleCounts = copy_src->framebufferIntegerColorSampleCounts; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) { + driverName[i] = copy_src->driverName[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) { + driverInfo[i] = copy_src->driverInfo[i]; + } +} + +safe_VkImageFormatListCreateInfo::safe_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), viewFormatCount(in_struct->viewFormatCount), pViewFormats(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pViewFormats) { + pViewFormats = new VkFormat[in_struct->viewFormatCount]; + memcpy((void*)pViewFormats, (void*)in_struct->pViewFormats, sizeof(VkFormat) * in_struct->viewFormatCount); + } +} + +safe_VkImageFormatListCreateInfo::safe_VkImageFormatListCreateInfo() + : sType(VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO), pNext(nullptr), viewFormatCount(), pViewFormats(nullptr) {} + +safe_VkImageFormatListCreateInfo::safe_VkImageFormatListCreateInfo(const safe_VkImageFormatListCreateInfo& copy_src) { + sType = copy_src.sType; + viewFormatCount = copy_src.viewFormatCount; + pViewFormats = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pViewFormats) { + pViewFormats = new VkFormat[copy_src.viewFormatCount]; + memcpy((void*)pViewFormats, (void*)copy_src.pViewFormats, sizeof(VkFormat) * copy_src.viewFormatCount); + } +} + +safe_VkImageFormatListCreateInfo& safe_VkImageFormatListCreateInfo::operator=(const safe_VkImageFormatListCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pViewFormats) delete[] pViewFormats; + FreePnextChain(pNext); + + sType = copy_src.sType; + viewFormatCount = copy_src.viewFormatCount; + pViewFormats = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pViewFormats) { + pViewFormats = new VkFormat[copy_src.viewFormatCount]; + memcpy((void*)pViewFormats, (void*)copy_src.pViewFormats, sizeof(VkFormat) * copy_src.viewFormatCount); + } + + return *this; +} + +safe_VkImageFormatListCreateInfo::~safe_VkImageFormatListCreateInfo() { + if (pViewFormats) delete[] pViewFormats; + FreePnextChain(pNext); +} + +void safe_VkImageFormatListCreateInfo::initialize(const VkImageFormatListCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pViewFormats) delete[] pViewFormats; + FreePnextChain(pNext); + sType = in_struct->sType; + viewFormatCount = in_struct->viewFormatCount; + pViewFormats = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pViewFormats) { + pViewFormats = new VkFormat[in_struct->viewFormatCount]; + memcpy((void*)pViewFormats, (void*)in_struct->pViewFormats, sizeof(VkFormat) * in_struct->viewFormatCount); + } +} + +void safe_VkImageFormatListCreateInfo::initialize(const safe_VkImageFormatListCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + viewFormatCount = copy_src->viewFormatCount; + pViewFormats = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pViewFormats) { + pViewFormats = new VkFormat[copy_src->viewFormatCount]; + memcpy((void*)pViewFormats, (void*)copy_src->pViewFormats, sizeof(VkFormat) * copy_src->viewFormatCount); + } +} + +safe_VkAttachmentDescription2::safe_VkAttachmentDescription2(const VkAttachmentDescription2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + format(in_struct->format), + samples(in_struct->samples), + loadOp(in_struct->loadOp), + storeOp(in_struct->storeOp), + stencilLoadOp(in_struct->stencilLoadOp), + stencilStoreOp(in_struct->stencilStoreOp), + initialLayout(in_struct->initialLayout), + finalLayout(in_struct->finalLayout) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAttachmentDescription2::safe_VkAttachmentDescription2() + : sType(VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2), + pNext(nullptr), + flags(), + format(), + samples(), + loadOp(), + storeOp(), + stencilLoadOp(), + stencilStoreOp(), + initialLayout(), + finalLayout() {} + +safe_VkAttachmentDescription2::safe_VkAttachmentDescription2(const safe_VkAttachmentDescription2& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + format = copy_src.format; + samples = copy_src.samples; + loadOp = copy_src.loadOp; + storeOp = copy_src.storeOp; + stencilLoadOp = copy_src.stencilLoadOp; + stencilStoreOp = copy_src.stencilStoreOp; + initialLayout = copy_src.initialLayout; + finalLayout = copy_src.finalLayout; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAttachmentDescription2& safe_VkAttachmentDescription2::operator=(const safe_VkAttachmentDescription2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + format = copy_src.format; + samples = copy_src.samples; + loadOp = copy_src.loadOp; + storeOp = copy_src.storeOp; + stencilLoadOp = copy_src.stencilLoadOp; + stencilStoreOp = copy_src.stencilStoreOp; + initialLayout = copy_src.initialLayout; + finalLayout = copy_src.finalLayout; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAttachmentDescription2::~safe_VkAttachmentDescription2() { FreePnextChain(pNext); } + +void safe_VkAttachmentDescription2::initialize(const VkAttachmentDescription2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + format = in_struct->format; + samples = in_struct->samples; + loadOp = in_struct->loadOp; + storeOp = in_struct->storeOp; + stencilLoadOp = in_struct->stencilLoadOp; + stencilStoreOp = in_struct->stencilStoreOp; + initialLayout = in_struct->initialLayout; + finalLayout = in_struct->finalLayout; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAttachmentDescription2::initialize(const safe_VkAttachmentDescription2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + format = copy_src->format; + samples = copy_src->samples; + loadOp = copy_src->loadOp; + storeOp = copy_src->storeOp; + stencilLoadOp = copy_src->stencilLoadOp; + stencilStoreOp = copy_src->stencilStoreOp; + initialLayout = copy_src->initialLayout; + finalLayout = copy_src->finalLayout; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAttachmentReference2::safe_VkAttachmentReference2(const VkAttachmentReference2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), attachment(in_struct->attachment), layout(in_struct->layout), aspectMask(in_struct->aspectMask) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAttachmentReference2::safe_VkAttachmentReference2() + : sType(VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2), pNext(nullptr), attachment(), layout(), aspectMask() {} + +safe_VkAttachmentReference2::safe_VkAttachmentReference2(const safe_VkAttachmentReference2& copy_src) { + sType = copy_src.sType; + attachment = copy_src.attachment; + layout = copy_src.layout; + aspectMask = copy_src.aspectMask; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAttachmentReference2& safe_VkAttachmentReference2::operator=(const safe_VkAttachmentReference2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + attachment = copy_src.attachment; + layout = copy_src.layout; + aspectMask = copy_src.aspectMask; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAttachmentReference2::~safe_VkAttachmentReference2() { FreePnextChain(pNext); } + +void safe_VkAttachmentReference2::initialize(const VkAttachmentReference2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + attachment = in_struct->attachment; + layout = in_struct->layout; + aspectMask = in_struct->aspectMask; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAttachmentReference2::initialize(const safe_VkAttachmentReference2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + attachment = copy_src->attachment; + layout = copy_src->layout; + aspectMask = copy_src->aspectMask; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSubpassDescription2::safe_VkSubpassDescription2(const VkSubpassDescription2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + pipelineBindPoint(in_struct->pipelineBindPoint), + viewMask(in_struct->viewMask), + inputAttachmentCount(in_struct->inputAttachmentCount), + pInputAttachments(nullptr), + colorAttachmentCount(in_struct->colorAttachmentCount), + pColorAttachments(nullptr), + pResolveAttachments(nullptr), + pDepthStencilAttachment(nullptr), + preserveAttachmentCount(in_struct->preserveAttachmentCount), + pPreserveAttachments(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (inputAttachmentCount && in_struct->pInputAttachments) { + pInputAttachments = new safe_VkAttachmentReference2[inputAttachmentCount]; + for (uint32_t i = 0; i < inputAttachmentCount; ++i) { + pInputAttachments[i].initialize(&in_struct->pInputAttachments[i]); + } + } + if (colorAttachmentCount && in_struct->pColorAttachments) { + pColorAttachments = new safe_VkAttachmentReference2[colorAttachmentCount]; + for (uint32_t i = 0; i < colorAttachmentCount; ++i) { + pColorAttachments[i].initialize(&in_struct->pColorAttachments[i]); + } + } + if (colorAttachmentCount && in_struct->pResolveAttachments) { + pResolveAttachments = new safe_VkAttachmentReference2[colorAttachmentCount]; + for (uint32_t i = 0; i < colorAttachmentCount; ++i) { + pResolveAttachments[i].initialize(&in_struct->pResolveAttachments[i]); + } + } + if (in_struct->pDepthStencilAttachment) + pDepthStencilAttachment = new safe_VkAttachmentReference2(in_struct->pDepthStencilAttachment); + + if (in_struct->pPreserveAttachments) { + pPreserveAttachments = new uint32_t[in_struct->preserveAttachmentCount]; + memcpy((void*)pPreserveAttachments, (void*)in_struct->pPreserveAttachments, + sizeof(uint32_t) * in_struct->preserveAttachmentCount); + } +} + +safe_VkSubpassDescription2::safe_VkSubpassDescription2() + : sType(VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2), + pNext(nullptr), + flags(), + pipelineBindPoint(), + viewMask(), + inputAttachmentCount(), + pInputAttachments(nullptr), + colorAttachmentCount(), + pColorAttachments(nullptr), + pResolveAttachments(nullptr), + pDepthStencilAttachment(nullptr), + preserveAttachmentCount(), + pPreserveAttachments(nullptr) {} + +safe_VkSubpassDescription2::safe_VkSubpassDescription2(const safe_VkSubpassDescription2& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pipelineBindPoint = copy_src.pipelineBindPoint; + viewMask = copy_src.viewMask; + inputAttachmentCount = copy_src.inputAttachmentCount; + pInputAttachments = nullptr; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachments = nullptr; + pResolveAttachments = nullptr; + pDepthStencilAttachment = nullptr; + preserveAttachmentCount = copy_src.preserveAttachmentCount; + pPreserveAttachments = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (inputAttachmentCount && copy_src.pInputAttachments) { + pInputAttachments = new safe_VkAttachmentReference2[inputAttachmentCount]; + for (uint32_t i = 0; i < inputAttachmentCount; ++i) { + pInputAttachments[i].initialize(©_src.pInputAttachments[i]); + } + } + if (colorAttachmentCount && copy_src.pColorAttachments) { + pColorAttachments = new safe_VkAttachmentReference2[colorAttachmentCount]; + for (uint32_t i = 0; i < colorAttachmentCount; ++i) { + pColorAttachments[i].initialize(©_src.pColorAttachments[i]); + } + } + if (colorAttachmentCount && copy_src.pResolveAttachments) { + pResolveAttachments = new safe_VkAttachmentReference2[colorAttachmentCount]; + for (uint32_t i = 0; i < colorAttachmentCount; ++i) { + pResolveAttachments[i].initialize(©_src.pResolveAttachments[i]); + } + } + if (copy_src.pDepthStencilAttachment) + pDepthStencilAttachment = new safe_VkAttachmentReference2(*copy_src.pDepthStencilAttachment); + + if (copy_src.pPreserveAttachments) { + pPreserveAttachments = new uint32_t[copy_src.preserveAttachmentCount]; + memcpy((void*)pPreserveAttachments, (void*)copy_src.pPreserveAttachments, + sizeof(uint32_t) * copy_src.preserveAttachmentCount); + } +} + +safe_VkSubpassDescription2& safe_VkSubpassDescription2::operator=(const safe_VkSubpassDescription2& copy_src) { + if (©_src == this) return *this; + + if (pInputAttachments) delete[] pInputAttachments; + if (pColorAttachments) delete[] pColorAttachments; + if (pResolveAttachments) delete[] pResolveAttachments; + if (pDepthStencilAttachment) delete pDepthStencilAttachment; + if (pPreserveAttachments) delete[] pPreserveAttachments; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pipelineBindPoint = copy_src.pipelineBindPoint; + viewMask = copy_src.viewMask; + inputAttachmentCount = copy_src.inputAttachmentCount; + pInputAttachments = nullptr; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachments = nullptr; + pResolveAttachments = nullptr; + pDepthStencilAttachment = nullptr; + preserveAttachmentCount = copy_src.preserveAttachmentCount; + pPreserveAttachments = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (inputAttachmentCount && copy_src.pInputAttachments) { + pInputAttachments = new safe_VkAttachmentReference2[inputAttachmentCount]; + for (uint32_t i = 0; i < inputAttachmentCount; ++i) { + pInputAttachments[i].initialize(©_src.pInputAttachments[i]); + } + } + if (colorAttachmentCount && copy_src.pColorAttachments) { + pColorAttachments = new safe_VkAttachmentReference2[colorAttachmentCount]; + for (uint32_t i = 0; i < colorAttachmentCount; ++i) { + pColorAttachments[i].initialize(©_src.pColorAttachments[i]); + } + } + if (colorAttachmentCount && copy_src.pResolveAttachments) { + pResolveAttachments = new safe_VkAttachmentReference2[colorAttachmentCount]; + for (uint32_t i = 0; i < colorAttachmentCount; ++i) { + pResolveAttachments[i].initialize(©_src.pResolveAttachments[i]); + } + } + if (copy_src.pDepthStencilAttachment) + pDepthStencilAttachment = new safe_VkAttachmentReference2(*copy_src.pDepthStencilAttachment); + + if (copy_src.pPreserveAttachments) { + pPreserveAttachments = new uint32_t[copy_src.preserveAttachmentCount]; + memcpy((void*)pPreserveAttachments, (void*)copy_src.pPreserveAttachments, + sizeof(uint32_t) * copy_src.preserveAttachmentCount); + } + + return *this; +} + +safe_VkSubpassDescription2::~safe_VkSubpassDescription2() { + if (pInputAttachments) delete[] pInputAttachments; + if (pColorAttachments) delete[] pColorAttachments; + if (pResolveAttachments) delete[] pResolveAttachments; + if (pDepthStencilAttachment) delete pDepthStencilAttachment; + if (pPreserveAttachments) delete[] pPreserveAttachments; + FreePnextChain(pNext); +} + +void safe_VkSubpassDescription2::initialize(const VkSubpassDescription2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pInputAttachments) delete[] pInputAttachments; + if (pColorAttachments) delete[] pColorAttachments; + if (pResolveAttachments) delete[] pResolveAttachments; + if (pDepthStencilAttachment) delete pDepthStencilAttachment; + if (pPreserveAttachments) delete[] pPreserveAttachments; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pipelineBindPoint = in_struct->pipelineBindPoint; + viewMask = in_struct->viewMask; + inputAttachmentCount = in_struct->inputAttachmentCount; + pInputAttachments = nullptr; + colorAttachmentCount = in_struct->colorAttachmentCount; + pColorAttachments = nullptr; + pResolveAttachments = nullptr; + pDepthStencilAttachment = nullptr; + preserveAttachmentCount = in_struct->preserveAttachmentCount; + pPreserveAttachments = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (inputAttachmentCount && in_struct->pInputAttachments) { + pInputAttachments = new safe_VkAttachmentReference2[inputAttachmentCount]; + for (uint32_t i = 0; i < inputAttachmentCount; ++i) { + pInputAttachments[i].initialize(&in_struct->pInputAttachments[i]); + } + } + if (colorAttachmentCount && in_struct->pColorAttachments) { + pColorAttachments = new safe_VkAttachmentReference2[colorAttachmentCount]; + for (uint32_t i = 0; i < colorAttachmentCount; ++i) { + pColorAttachments[i].initialize(&in_struct->pColorAttachments[i]); + } + } + if (colorAttachmentCount && in_struct->pResolveAttachments) { + pResolveAttachments = new safe_VkAttachmentReference2[colorAttachmentCount]; + for (uint32_t i = 0; i < colorAttachmentCount; ++i) { + pResolveAttachments[i].initialize(&in_struct->pResolveAttachments[i]); + } + } + if (in_struct->pDepthStencilAttachment) + pDepthStencilAttachment = new safe_VkAttachmentReference2(in_struct->pDepthStencilAttachment); + + if (in_struct->pPreserveAttachments) { + pPreserveAttachments = new uint32_t[in_struct->preserveAttachmentCount]; + memcpy((void*)pPreserveAttachments, (void*)in_struct->pPreserveAttachments, + sizeof(uint32_t) * in_struct->preserveAttachmentCount); + } +} + +void safe_VkSubpassDescription2::initialize(const safe_VkSubpassDescription2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pipelineBindPoint = copy_src->pipelineBindPoint; + viewMask = copy_src->viewMask; + inputAttachmentCount = copy_src->inputAttachmentCount; + pInputAttachments = nullptr; + colorAttachmentCount = copy_src->colorAttachmentCount; + pColorAttachments = nullptr; + pResolveAttachments = nullptr; + pDepthStencilAttachment = nullptr; + preserveAttachmentCount = copy_src->preserveAttachmentCount; + pPreserveAttachments = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (inputAttachmentCount && copy_src->pInputAttachments) { + pInputAttachments = new safe_VkAttachmentReference2[inputAttachmentCount]; + for (uint32_t i = 0; i < inputAttachmentCount; ++i) { + pInputAttachments[i].initialize(©_src->pInputAttachments[i]); + } + } + if (colorAttachmentCount && copy_src->pColorAttachments) { + pColorAttachments = new safe_VkAttachmentReference2[colorAttachmentCount]; + for (uint32_t i = 0; i < colorAttachmentCount; ++i) { + pColorAttachments[i].initialize(©_src->pColorAttachments[i]); + } + } + if (colorAttachmentCount && copy_src->pResolveAttachments) { + pResolveAttachments = new safe_VkAttachmentReference2[colorAttachmentCount]; + for (uint32_t i = 0; i < colorAttachmentCount; ++i) { + pResolveAttachments[i].initialize(©_src->pResolveAttachments[i]); + } + } + if (copy_src->pDepthStencilAttachment) + pDepthStencilAttachment = new safe_VkAttachmentReference2(*copy_src->pDepthStencilAttachment); + + if (copy_src->pPreserveAttachments) { + pPreserveAttachments = new uint32_t[copy_src->preserveAttachmentCount]; + memcpy((void*)pPreserveAttachments, (void*)copy_src->pPreserveAttachments, + sizeof(uint32_t) * copy_src->preserveAttachmentCount); + } +} + +safe_VkSubpassDependency2::safe_VkSubpassDependency2(const VkSubpassDependency2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + srcSubpass(in_struct->srcSubpass), + dstSubpass(in_struct->dstSubpass), + srcStageMask(in_struct->srcStageMask), + dstStageMask(in_struct->dstStageMask), + srcAccessMask(in_struct->srcAccessMask), + dstAccessMask(in_struct->dstAccessMask), + dependencyFlags(in_struct->dependencyFlags), + viewOffset(in_struct->viewOffset) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSubpassDependency2::safe_VkSubpassDependency2() + : sType(VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2), + pNext(nullptr), + srcSubpass(), + dstSubpass(), + srcStageMask(), + dstStageMask(), + srcAccessMask(), + dstAccessMask(), + dependencyFlags(), + viewOffset() {} + +safe_VkSubpassDependency2::safe_VkSubpassDependency2(const safe_VkSubpassDependency2& copy_src) { + sType = copy_src.sType; + srcSubpass = copy_src.srcSubpass; + dstSubpass = copy_src.dstSubpass; + srcStageMask = copy_src.srcStageMask; + dstStageMask = copy_src.dstStageMask; + srcAccessMask = copy_src.srcAccessMask; + dstAccessMask = copy_src.dstAccessMask; + dependencyFlags = copy_src.dependencyFlags; + viewOffset = copy_src.viewOffset; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSubpassDependency2& safe_VkSubpassDependency2::operator=(const safe_VkSubpassDependency2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + srcSubpass = copy_src.srcSubpass; + dstSubpass = copy_src.dstSubpass; + srcStageMask = copy_src.srcStageMask; + dstStageMask = copy_src.dstStageMask; + srcAccessMask = copy_src.srcAccessMask; + dstAccessMask = copy_src.dstAccessMask; + dependencyFlags = copy_src.dependencyFlags; + viewOffset = copy_src.viewOffset; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSubpassDependency2::~safe_VkSubpassDependency2() { FreePnextChain(pNext); } + +void safe_VkSubpassDependency2::initialize(const VkSubpassDependency2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + srcSubpass = in_struct->srcSubpass; + dstSubpass = in_struct->dstSubpass; + srcStageMask = in_struct->srcStageMask; + dstStageMask = in_struct->dstStageMask; + srcAccessMask = in_struct->srcAccessMask; + dstAccessMask = in_struct->dstAccessMask; + dependencyFlags = in_struct->dependencyFlags; + viewOffset = in_struct->viewOffset; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSubpassDependency2::initialize(const safe_VkSubpassDependency2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcSubpass = copy_src->srcSubpass; + dstSubpass = copy_src->dstSubpass; + srcStageMask = copy_src->srcStageMask; + dstStageMask = copy_src->dstStageMask; + srcAccessMask = copy_src->srcAccessMask; + dstAccessMask = copy_src->dstAccessMask; + dependencyFlags = copy_src->dependencyFlags; + viewOffset = copy_src->viewOffset; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkRenderPassCreateInfo2::safe_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + attachmentCount(in_struct->attachmentCount), + pAttachments(nullptr), + subpassCount(in_struct->subpassCount), + pSubpasses(nullptr), + dependencyCount(in_struct->dependencyCount), + pDependencies(nullptr), + correlatedViewMaskCount(in_struct->correlatedViewMaskCount), + pCorrelatedViewMasks(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (attachmentCount && in_struct->pAttachments) { + pAttachments = new safe_VkAttachmentDescription2[attachmentCount]; + for (uint32_t i = 0; i < attachmentCount; ++i) { + pAttachments[i].initialize(&in_struct->pAttachments[i]); + } + } + if (subpassCount && in_struct->pSubpasses) { + pSubpasses = new safe_VkSubpassDescription2[subpassCount]; + for (uint32_t i = 0; i < subpassCount; ++i) { + pSubpasses[i].initialize(&in_struct->pSubpasses[i]); + } + } + if (dependencyCount && in_struct->pDependencies) { + pDependencies = new safe_VkSubpassDependency2[dependencyCount]; + for (uint32_t i = 0; i < dependencyCount; ++i) { + pDependencies[i].initialize(&in_struct->pDependencies[i]); + } + } + + if (in_struct->pCorrelatedViewMasks) { + pCorrelatedViewMasks = new uint32_t[in_struct->correlatedViewMaskCount]; + memcpy((void*)pCorrelatedViewMasks, (void*)in_struct->pCorrelatedViewMasks, + sizeof(uint32_t) * in_struct->correlatedViewMaskCount); + } +} + +safe_VkRenderPassCreateInfo2::safe_VkRenderPassCreateInfo2() + : sType(VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2), + pNext(nullptr), + flags(), + attachmentCount(), + pAttachments(nullptr), + subpassCount(), + pSubpasses(nullptr), + dependencyCount(), + pDependencies(nullptr), + correlatedViewMaskCount(), + pCorrelatedViewMasks(nullptr) {} + +safe_VkRenderPassCreateInfo2::safe_VkRenderPassCreateInfo2(const safe_VkRenderPassCreateInfo2& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + attachmentCount = copy_src.attachmentCount; + pAttachments = nullptr; + subpassCount = copy_src.subpassCount; + pSubpasses = nullptr; + dependencyCount = copy_src.dependencyCount; + pDependencies = nullptr; + correlatedViewMaskCount = copy_src.correlatedViewMaskCount; + pCorrelatedViewMasks = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (attachmentCount && copy_src.pAttachments) { + pAttachments = new safe_VkAttachmentDescription2[attachmentCount]; + for (uint32_t i = 0; i < attachmentCount; ++i) { + pAttachments[i].initialize(©_src.pAttachments[i]); + } + } + if (subpassCount && copy_src.pSubpasses) { + pSubpasses = new safe_VkSubpassDescription2[subpassCount]; + for (uint32_t i = 0; i < subpassCount; ++i) { + pSubpasses[i].initialize(©_src.pSubpasses[i]); + } + } + if (dependencyCount && copy_src.pDependencies) { + pDependencies = new safe_VkSubpassDependency2[dependencyCount]; + for (uint32_t i = 0; i < dependencyCount; ++i) { + pDependencies[i].initialize(©_src.pDependencies[i]); + } + } + + if (copy_src.pCorrelatedViewMasks) { + pCorrelatedViewMasks = new uint32_t[copy_src.correlatedViewMaskCount]; + memcpy((void*)pCorrelatedViewMasks, (void*)copy_src.pCorrelatedViewMasks, + sizeof(uint32_t) * copy_src.correlatedViewMaskCount); + } +} + +safe_VkRenderPassCreateInfo2& safe_VkRenderPassCreateInfo2::operator=(const safe_VkRenderPassCreateInfo2& copy_src) { + if (©_src == this) return *this; + + if (pAttachments) delete[] pAttachments; + if (pSubpasses) delete[] pSubpasses; + if (pDependencies) delete[] pDependencies; + if (pCorrelatedViewMasks) delete[] pCorrelatedViewMasks; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + attachmentCount = copy_src.attachmentCount; + pAttachments = nullptr; + subpassCount = copy_src.subpassCount; + pSubpasses = nullptr; + dependencyCount = copy_src.dependencyCount; + pDependencies = nullptr; + correlatedViewMaskCount = copy_src.correlatedViewMaskCount; + pCorrelatedViewMasks = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (attachmentCount && copy_src.pAttachments) { + pAttachments = new safe_VkAttachmentDescription2[attachmentCount]; + for (uint32_t i = 0; i < attachmentCount; ++i) { + pAttachments[i].initialize(©_src.pAttachments[i]); + } + } + if (subpassCount && copy_src.pSubpasses) { + pSubpasses = new safe_VkSubpassDescription2[subpassCount]; + for (uint32_t i = 0; i < subpassCount; ++i) { + pSubpasses[i].initialize(©_src.pSubpasses[i]); + } + } + if (dependencyCount && copy_src.pDependencies) { + pDependencies = new safe_VkSubpassDependency2[dependencyCount]; + for (uint32_t i = 0; i < dependencyCount; ++i) { + pDependencies[i].initialize(©_src.pDependencies[i]); + } + } + + if (copy_src.pCorrelatedViewMasks) { + pCorrelatedViewMasks = new uint32_t[copy_src.correlatedViewMaskCount]; + memcpy((void*)pCorrelatedViewMasks, (void*)copy_src.pCorrelatedViewMasks, + sizeof(uint32_t) * copy_src.correlatedViewMaskCount); + } + + return *this; +} + +safe_VkRenderPassCreateInfo2::~safe_VkRenderPassCreateInfo2() { + if (pAttachments) delete[] pAttachments; + if (pSubpasses) delete[] pSubpasses; + if (pDependencies) delete[] pDependencies; + if (pCorrelatedViewMasks) delete[] pCorrelatedViewMasks; + FreePnextChain(pNext); +} + +void safe_VkRenderPassCreateInfo2::initialize(const VkRenderPassCreateInfo2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pAttachments) delete[] pAttachments; + if (pSubpasses) delete[] pSubpasses; + if (pDependencies) delete[] pDependencies; + if (pCorrelatedViewMasks) delete[] pCorrelatedViewMasks; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + attachmentCount = in_struct->attachmentCount; + pAttachments = nullptr; + subpassCount = in_struct->subpassCount; + pSubpasses = nullptr; + dependencyCount = in_struct->dependencyCount; + pDependencies = nullptr; + correlatedViewMaskCount = in_struct->correlatedViewMaskCount; + pCorrelatedViewMasks = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (attachmentCount && in_struct->pAttachments) { + pAttachments = new safe_VkAttachmentDescription2[attachmentCount]; + for (uint32_t i = 0; i < attachmentCount; ++i) { + pAttachments[i].initialize(&in_struct->pAttachments[i]); + } + } + if (subpassCount && in_struct->pSubpasses) { + pSubpasses = new safe_VkSubpassDescription2[subpassCount]; + for (uint32_t i = 0; i < subpassCount; ++i) { + pSubpasses[i].initialize(&in_struct->pSubpasses[i]); + } + } + if (dependencyCount && in_struct->pDependencies) { + pDependencies = new safe_VkSubpassDependency2[dependencyCount]; + for (uint32_t i = 0; i < dependencyCount; ++i) { + pDependencies[i].initialize(&in_struct->pDependencies[i]); + } + } + + if (in_struct->pCorrelatedViewMasks) { + pCorrelatedViewMasks = new uint32_t[in_struct->correlatedViewMaskCount]; + memcpy((void*)pCorrelatedViewMasks, (void*)in_struct->pCorrelatedViewMasks, + sizeof(uint32_t) * in_struct->correlatedViewMaskCount); + } +} + +void safe_VkRenderPassCreateInfo2::initialize(const safe_VkRenderPassCreateInfo2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + attachmentCount = copy_src->attachmentCount; + pAttachments = nullptr; + subpassCount = copy_src->subpassCount; + pSubpasses = nullptr; + dependencyCount = copy_src->dependencyCount; + pDependencies = nullptr; + correlatedViewMaskCount = copy_src->correlatedViewMaskCount; + pCorrelatedViewMasks = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (attachmentCount && copy_src->pAttachments) { + pAttachments = new safe_VkAttachmentDescription2[attachmentCount]; + for (uint32_t i = 0; i < attachmentCount; ++i) { + pAttachments[i].initialize(©_src->pAttachments[i]); + } + } + if (subpassCount && copy_src->pSubpasses) { + pSubpasses = new safe_VkSubpassDescription2[subpassCount]; + for (uint32_t i = 0; i < subpassCount; ++i) { + pSubpasses[i].initialize(©_src->pSubpasses[i]); + } + } + if (dependencyCount && copy_src->pDependencies) { + pDependencies = new safe_VkSubpassDependency2[dependencyCount]; + for (uint32_t i = 0; i < dependencyCount; ++i) { + pDependencies[i].initialize(©_src->pDependencies[i]); + } + } + + if (copy_src->pCorrelatedViewMasks) { + pCorrelatedViewMasks = new uint32_t[copy_src->correlatedViewMaskCount]; + memcpy((void*)pCorrelatedViewMasks, (void*)copy_src->pCorrelatedViewMasks, + sizeof(uint32_t) * copy_src->correlatedViewMaskCount); + } +} + +safe_VkSubpassBeginInfo::safe_VkSubpassBeginInfo(const VkSubpassBeginInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), contents(in_struct->contents) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSubpassBeginInfo::safe_VkSubpassBeginInfo() : sType(VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO), pNext(nullptr), contents() {} + +safe_VkSubpassBeginInfo::safe_VkSubpassBeginInfo(const safe_VkSubpassBeginInfo& copy_src) { + sType = copy_src.sType; + contents = copy_src.contents; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSubpassBeginInfo& safe_VkSubpassBeginInfo::operator=(const safe_VkSubpassBeginInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + contents = copy_src.contents; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSubpassBeginInfo::~safe_VkSubpassBeginInfo() { FreePnextChain(pNext); } + +void safe_VkSubpassBeginInfo::initialize(const VkSubpassBeginInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + contents = in_struct->contents; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSubpassBeginInfo::initialize(const safe_VkSubpassBeginInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + contents = copy_src->contents; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSubpassEndInfo::safe_VkSubpassEndInfo(const VkSubpassEndInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSubpassEndInfo::safe_VkSubpassEndInfo() : sType(VK_STRUCTURE_TYPE_SUBPASS_END_INFO), pNext(nullptr) {} + +safe_VkSubpassEndInfo::safe_VkSubpassEndInfo(const safe_VkSubpassEndInfo& copy_src) { + sType = copy_src.sType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSubpassEndInfo& safe_VkSubpassEndInfo::operator=(const safe_VkSubpassEndInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSubpassEndInfo::~safe_VkSubpassEndInfo() { FreePnextChain(pNext); } + +void safe_VkSubpassEndInfo::initialize(const VkSubpassEndInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSubpassEndInfo::initialize(const safe_VkSubpassEndInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevice8BitStorageFeatures::safe_VkPhysicalDevice8BitStorageFeatures( + const VkPhysicalDevice8BitStorageFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + storageBuffer8BitAccess(in_struct->storageBuffer8BitAccess), + uniformAndStorageBuffer8BitAccess(in_struct->uniformAndStorageBuffer8BitAccess), + storagePushConstant8(in_struct->storagePushConstant8) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevice8BitStorageFeatures::safe_VkPhysicalDevice8BitStorageFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES), + pNext(nullptr), + storageBuffer8BitAccess(), + uniformAndStorageBuffer8BitAccess(), + storagePushConstant8() {} + +safe_VkPhysicalDevice8BitStorageFeatures::safe_VkPhysicalDevice8BitStorageFeatures( + const safe_VkPhysicalDevice8BitStorageFeatures& copy_src) { + sType = copy_src.sType; + storageBuffer8BitAccess = copy_src.storageBuffer8BitAccess; + uniformAndStorageBuffer8BitAccess = copy_src.uniformAndStorageBuffer8BitAccess; + storagePushConstant8 = copy_src.storagePushConstant8; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevice8BitStorageFeatures& safe_VkPhysicalDevice8BitStorageFeatures::operator=( + const safe_VkPhysicalDevice8BitStorageFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + storageBuffer8BitAccess = copy_src.storageBuffer8BitAccess; + uniformAndStorageBuffer8BitAccess = copy_src.uniformAndStorageBuffer8BitAccess; + storagePushConstant8 = copy_src.storagePushConstant8; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevice8BitStorageFeatures::~safe_VkPhysicalDevice8BitStorageFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevice8BitStorageFeatures::initialize(const VkPhysicalDevice8BitStorageFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + storageBuffer8BitAccess = in_struct->storageBuffer8BitAccess; + uniformAndStorageBuffer8BitAccess = in_struct->uniformAndStorageBuffer8BitAccess; + storagePushConstant8 = in_struct->storagePushConstant8; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevice8BitStorageFeatures::initialize(const safe_VkPhysicalDevice8BitStorageFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + storageBuffer8BitAccess = copy_src->storageBuffer8BitAccess; + uniformAndStorageBuffer8BitAccess = copy_src->uniformAndStorageBuffer8BitAccess; + storagePushConstant8 = copy_src->storagePushConstant8; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDriverProperties::safe_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), driverID(in_struct->driverID), conformanceVersion(in_struct->conformanceVersion) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) { + driverName[i] = in_struct->driverName[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) { + driverInfo[i] = in_struct->driverInfo[i]; + } +} + +safe_VkPhysicalDeviceDriverProperties::safe_VkPhysicalDeviceDriverProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES), pNext(nullptr), driverID(), conformanceVersion() {} + +safe_VkPhysicalDeviceDriverProperties::safe_VkPhysicalDeviceDriverProperties( + const safe_VkPhysicalDeviceDriverProperties& copy_src) { + sType = copy_src.sType; + driverID = copy_src.driverID; + conformanceVersion = copy_src.conformanceVersion; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) { + driverName[i] = copy_src.driverName[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) { + driverInfo[i] = copy_src.driverInfo[i]; + } +} + +safe_VkPhysicalDeviceDriverProperties& safe_VkPhysicalDeviceDriverProperties::operator=( + const safe_VkPhysicalDeviceDriverProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + driverID = copy_src.driverID; + conformanceVersion = copy_src.conformanceVersion; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) { + driverName[i] = copy_src.driverName[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) { + driverInfo[i] = copy_src.driverInfo[i]; + } + + return *this; +} + +safe_VkPhysicalDeviceDriverProperties::~safe_VkPhysicalDeviceDriverProperties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceDriverProperties::initialize(const VkPhysicalDeviceDriverProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + driverID = in_struct->driverID; + conformanceVersion = in_struct->conformanceVersion; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) { + driverName[i] = in_struct->driverName[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) { + driverInfo[i] = in_struct->driverInfo[i]; + } +} + +void safe_VkPhysicalDeviceDriverProperties::initialize(const safe_VkPhysicalDeviceDriverProperties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + driverID = copy_src->driverID; + conformanceVersion = copy_src->conformanceVersion; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) { + driverName[i] = copy_src->driverName[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) { + driverInfo[i] = copy_src->driverInfo[i]; + } +} + +safe_VkPhysicalDeviceShaderAtomicInt64Features::safe_VkPhysicalDeviceShaderAtomicInt64Features( + const VkPhysicalDeviceShaderAtomicInt64Features* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shaderBufferInt64Atomics(in_struct->shaderBufferInt64Atomics), + shaderSharedInt64Atomics(in_struct->shaderSharedInt64Atomics) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderAtomicInt64Features::safe_VkPhysicalDeviceShaderAtomicInt64Features() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES), + pNext(nullptr), + shaderBufferInt64Atomics(), + shaderSharedInt64Atomics() {} + +safe_VkPhysicalDeviceShaderAtomicInt64Features::safe_VkPhysicalDeviceShaderAtomicInt64Features( + const safe_VkPhysicalDeviceShaderAtomicInt64Features& copy_src) { + sType = copy_src.sType; + shaderBufferInt64Atomics = copy_src.shaderBufferInt64Atomics; + shaderSharedInt64Atomics = copy_src.shaderSharedInt64Atomics; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderAtomicInt64Features& safe_VkPhysicalDeviceShaderAtomicInt64Features::operator=( + const safe_VkPhysicalDeviceShaderAtomicInt64Features& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderBufferInt64Atomics = copy_src.shaderBufferInt64Atomics; + shaderSharedInt64Atomics = copy_src.shaderSharedInt64Atomics; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderAtomicInt64Features::~safe_VkPhysicalDeviceShaderAtomicInt64Features() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderAtomicInt64Features::initialize(const VkPhysicalDeviceShaderAtomicInt64Features* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderBufferInt64Atomics = in_struct->shaderBufferInt64Atomics; + shaderSharedInt64Atomics = in_struct->shaderSharedInt64Atomics; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderAtomicInt64Features::initialize(const safe_VkPhysicalDeviceShaderAtomicInt64Features* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderBufferInt64Atomics = copy_src->shaderBufferInt64Atomics; + shaderSharedInt64Atomics = copy_src->shaderSharedInt64Atomics; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderFloat16Int8Features::safe_VkPhysicalDeviceShaderFloat16Int8Features( + const VkPhysicalDeviceShaderFloat16Int8Features* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), shaderFloat16(in_struct->shaderFloat16), shaderInt8(in_struct->shaderInt8) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderFloat16Int8Features::safe_VkPhysicalDeviceShaderFloat16Int8Features() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES), pNext(nullptr), shaderFloat16(), shaderInt8() {} + +safe_VkPhysicalDeviceShaderFloat16Int8Features::safe_VkPhysicalDeviceShaderFloat16Int8Features( + const safe_VkPhysicalDeviceShaderFloat16Int8Features& copy_src) { + sType = copy_src.sType; + shaderFloat16 = copy_src.shaderFloat16; + shaderInt8 = copy_src.shaderInt8; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderFloat16Int8Features& safe_VkPhysicalDeviceShaderFloat16Int8Features::operator=( + const safe_VkPhysicalDeviceShaderFloat16Int8Features& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderFloat16 = copy_src.shaderFloat16; + shaderInt8 = copy_src.shaderInt8; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderFloat16Int8Features::~safe_VkPhysicalDeviceShaderFloat16Int8Features() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderFloat16Int8Features::initialize(const VkPhysicalDeviceShaderFloat16Int8Features* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderFloat16 = in_struct->shaderFloat16; + shaderInt8 = in_struct->shaderInt8; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderFloat16Int8Features::initialize(const safe_VkPhysicalDeviceShaderFloat16Int8Features* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderFloat16 = copy_src->shaderFloat16; + shaderInt8 = copy_src->shaderInt8; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceFloatControlsProperties::safe_VkPhysicalDeviceFloatControlsProperties( + const VkPhysicalDeviceFloatControlsProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + denormBehaviorIndependence(in_struct->denormBehaviorIndependence), + roundingModeIndependence(in_struct->roundingModeIndependence), + shaderSignedZeroInfNanPreserveFloat16(in_struct->shaderSignedZeroInfNanPreserveFloat16), + shaderSignedZeroInfNanPreserveFloat32(in_struct->shaderSignedZeroInfNanPreserveFloat32), + shaderSignedZeroInfNanPreserveFloat64(in_struct->shaderSignedZeroInfNanPreserveFloat64), + shaderDenormPreserveFloat16(in_struct->shaderDenormPreserveFloat16), + shaderDenormPreserveFloat32(in_struct->shaderDenormPreserveFloat32), + shaderDenormPreserveFloat64(in_struct->shaderDenormPreserveFloat64), + shaderDenormFlushToZeroFloat16(in_struct->shaderDenormFlushToZeroFloat16), + shaderDenormFlushToZeroFloat32(in_struct->shaderDenormFlushToZeroFloat32), + shaderDenormFlushToZeroFloat64(in_struct->shaderDenormFlushToZeroFloat64), + shaderRoundingModeRTEFloat16(in_struct->shaderRoundingModeRTEFloat16), + shaderRoundingModeRTEFloat32(in_struct->shaderRoundingModeRTEFloat32), + shaderRoundingModeRTEFloat64(in_struct->shaderRoundingModeRTEFloat64), + shaderRoundingModeRTZFloat16(in_struct->shaderRoundingModeRTZFloat16), + shaderRoundingModeRTZFloat32(in_struct->shaderRoundingModeRTZFloat32), + shaderRoundingModeRTZFloat64(in_struct->shaderRoundingModeRTZFloat64) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceFloatControlsProperties::safe_VkPhysicalDeviceFloatControlsProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES), + pNext(nullptr), + denormBehaviorIndependence(), + roundingModeIndependence(), + shaderSignedZeroInfNanPreserveFloat16(), + shaderSignedZeroInfNanPreserveFloat32(), + shaderSignedZeroInfNanPreserveFloat64(), + shaderDenormPreserveFloat16(), + shaderDenormPreserveFloat32(), + shaderDenormPreserveFloat64(), + shaderDenormFlushToZeroFloat16(), + shaderDenormFlushToZeroFloat32(), + shaderDenormFlushToZeroFloat64(), + shaderRoundingModeRTEFloat16(), + shaderRoundingModeRTEFloat32(), + shaderRoundingModeRTEFloat64(), + shaderRoundingModeRTZFloat16(), + shaderRoundingModeRTZFloat32(), + shaderRoundingModeRTZFloat64() {} + +safe_VkPhysicalDeviceFloatControlsProperties::safe_VkPhysicalDeviceFloatControlsProperties( + const safe_VkPhysicalDeviceFloatControlsProperties& copy_src) { + sType = copy_src.sType; + denormBehaviorIndependence = copy_src.denormBehaviorIndependence; + roundingModeIndependence = copy_src.roundingModeIndependence; + shaderSignedZeroInfNanPreserveFloat16 = copy_src.shaderSignedZeroInfNanPreserveFloat16; + shaderSignedZeroInfNanPreserveFloat32 = copy_src.shaderSignedZeroInfNanPreserveFloat32; + shaderSignedZeroInfNanPreserveFloat64 = copy_src.shaderSignedZeroInfNanPreserveFloat64; + shaderDenormPreserveFloat16 = copy_src.shaderDenormPreserveFloat16; + shaderDenormPreserveFloat32 = copy_src.shaderDenormPreserveFloat32; + shaderDenormPreserveFloat64 = copy_src.shaderDenormPreserveFloat64; + shaderDenormFlushToZeroFloat16 = copy_src.shaderDenormFlushToZeroFloat16; + shaderDenormFlushToZeroFloat32 = copy_src.shaderDenormFlushToZeroFloat32; + shaderDenormFlushToZeroFloat64 = copy_src.shaderDenormFlushToZeroFloat64; + shaderRoundingModeRTEFloat16 = copy_src.shaderRoundingModeRTEFloat16; + shaderRoundingModeRTEFloat32 = copy_src.shaderRoundingModeRTEFloat32; + shaderRoundingModeRTEFloat64 = copy_src.shaderRoundingModeRTEFloat64; + shaderRoundingModeRTZFloat16 = copy_src.shaderRoundingModeRTZFloat16; + shaderRoundingModeRTZFloat32 = copy_src.shaderRoundingModeRTZFloat32; + shaderRoundingModeRTZFloat64 = copy_src.shaderRoundingModeRTZFloat64; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceFloatControlsProperties& safe_VkPhysicalDeviceFloatControlsProperties::operator=( + const safe_VkPhysicalDeviceFloatControlsProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + denormBehaviorIndependence = copy_src.denormBehaviorIndependence; + roundingModeIndependence = copy_src.roundingModeIndependence; + shaderSignedZeroInfNanPreserveFloat16 = copy_src.shaderSignedZeroInfNanPreserveFloat16; + shaderSignedZeroInfNanPreserveFloat32 = copy_src.shaderSignedZeroInfNanPreserveFloat32; + shaderSignedZeroInfNanPreserveFloat64 = copy_src.shaderSignedZeroInfNanPreserveFloat64; + shaderDenormPreserveFloat16 = copy_src.shaderDenormPreserveFloat16; + shaderDenormPreserveFloat32 = copy_src.shaderDenormPreserveFloat32; + shaderDenormPreserveFloat64 = copy_src.shaderDenormPreserveFloat64; + shaderDenormFlushToZeroFloat16 = copy_src.shaderDenormFlushToZeroFloat16; + shaderDenormFlushToZeroFloat32 = copy_src.shaderDenormFlushToZeroFloat32; + shaderDenormFlushToZeroFloat64 = copy_src.shaderDenormFlushToZeroFloat64; + shaderRoundingModeRTEFloat16 = copy_src.shaderRoundingModeRTEFloat16; + shaderRoundingModeRTEFloat32 = copy_src.shaderRoundingModeRTEFloat32; + shaderRoundingModeRTEFloat64 = copy_src.shaderRoundingModeRTEFloat64; + shaderRoundingModeRTZFloat16 = copy_src.shaderRoundingModeRTZFloat16; + shaderRoundingModeRTZFloat32 = copy_src.shaderRoundingModeRTZFloat32; + shaderRoundingModeRTZFloat64 = copy_src.shaderRoundingModeRTZFloat64; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceFloatControlsProperties::~safe_VkPhysicalDeviceFloatControlsProperties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceFloatControlsProperties::initialize(const VkPhysicalDeviceFloatControlsProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + denormBehaviorIndependence = in_struct->denormBehaviorIndependence; + roundingModeIndependence = in_struct->roundingModeIndependence; + shaderSignedZeroInfNanPreserveFloat16 = in_struct->shaderSignedZeroInfNanPreserveFloat16; + shaderSignedZeroInfNanPreserveFloat32 = in_struct->shaderSignedZeroInfNanPreserveFloat32; + shaderSignedZeroInfNanPreserveFloat64 = in_struct->shaderSignedZeroInfNanPreserveFloat64; + shaderDenormPreserveFloat16 = in_struct->shaderDenormPreserveFloat16; + shaderDenormPreserveFloat32 = in_struct->shaderDenormPreserveFloat32; + shaderDenormPreserveFloat64 = in_struct->shaderDenormPreserveFloat64; + shaderDenormFlushToZeroFloat16 = in_struct->shaderDenormFlushToZeroFloat16; + shaderDenormFlushToZeroFloat32 = in_struct->shaderDenormFlushToZeroFloat32; + shaderDenormFlushToZeroFloat64 = in_struct->shaderDenormFlushToZeroFloat64; + shaderRoundingModeRTEFloat16 = in_struct->shaderRoundingModeRTEFloat16; + shaderRoundingModeRTEFloat32 = in_struct->shaderRoundingModeRTEFloat32; + shaderRoundingModeRTEFloat64 = in_struct->shaderRoundingModeRTEFloat64; + shaderRoundingModeRTZFloat16 = in_struct->shaderRoundingModeRTZFloat16; + shaderRoundingModeRTZFloat32 = in_struct->shaderRoundingModeRTZFloat32; + shaderRoundingModeRTZFloat64 = in_struct->shaderRoundingModeRTZFloat64; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceFloatControlsProperties::initialize(const safe_VkPhysicalDeviceFloatControlsProperties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + denormBehaviorIndependence = copy_src->denormBehaviorIndependence; + roundingModeIndependence = copy_src->roundingModeIndependence; + shaderSignedZeroInfNanPreserveFloat16 = copy_src->shaderSignedZeroInfNanPreserveFloat16; + shaderSignedZeroInfNanPreserveFloat32 = copy_src->shaderSignedZeroInfNanPreserveFloat32; + shaderSignedZeroInfNanPreserveFloat64 = copy_src->shaderSignedZeroInfNanPreserveFloat64; + shaderDenormPreserveFloat16 = copy_src->shaderDenormPreserveFloat16; + shaderDenormPreserveFloat32 = copy_src->shaderDenormPreserveFloat32; + shaderDenormPreserveFloat64 = copy_src->shaderDenormPreserveFloat64; + shaderDenormFlushToZeroFloat16 = copy_src->shaderDenormFlushToZeroFloat16; + shaderDenormFlushToZeroFloat32 = copy_src->shaderDenormFlushToZeroFloat32; + shaderDenormFlushToZeroFloat64 = copy_src->shaderDenormFlushToZeroFloat64; + shaderRoundingModeRTEFloat16 = copy_src->shaderRoundingModeRTEFloat16; + shaderRoundingModeRTEFloat32 = copy_src->shaderRoundingModeRTEFloat32; + shaderRoundingModeRTEFloat64 = copy_src->shaderRoundingModeRTEFloat64; + shaderRoundingModeRTZFloat16 = copy_src->shaderRoundingModeRTZFloat16; + shaderRoundingModeRTZFloat32 = copy_src->shaderRoundingModeRTZFloat32; + shaderRoundingModeRTZFloat64 = copy_src->shaderRoundingModeRTZFloat64; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::safe_VkDescriptorSetLayoutBindingFlagsCreateInfo( + const VkDescriptorSetLayoutBindingFlagsCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), bindingCount(in_struct->bindingCount), pBindingFlags(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pBindingFlags) { + pBindingFlags = new VkDescriptorBindingFlags[in_struct->bindingCount]; + memcpy((void*)pBindingFlags, (void*)in_struct->pBindingFlags, sizeof(VkDescriptorBindingFlags) * in_struct->bindingCount); + } +} + +safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::safe_VkDescriptorSetLayoutBindingFlagsCreateInfo() + : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO), + pNext(nullptr), + bindingCount(), + pBindingFlags(nullptr) {} + +safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::safe_VkDescriptorSetLayoutBindingFlagsCreateInfo( + const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& copy_src) { + sType = copy_src.sType; + bindingCount = copy_src.bindingCount; + pBindingFlags = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pBindingFlags) { + pBindingFlags = new VkDescriptorBindingFlags[copy_src.bindingCount]; + memcpy((void*)pBindingFlags, (void*)copy_src.pBindingFlags, sizeof(VkDescriptorBindingFlags) * copy_src.bindingCount); + } +} + +safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::operator=( + const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pBindingFlags) delete[] pBindingFlags; + FreePnextChain(pNext); + + sType = copy_src.sType; + bindingCount = copy_src.bindingCount; + pBindingFlags = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pBindingFlags) { + pBindingFlags = new VkDescriptorBindingFlags[copy_src.bindingCount]; + memcpy((void*)pBindingFlags, (void*)copy_src.pBindingFlags, sizeof(VkDescriptorBindingFlags) * copy_src.bindingCount); + } + + return *this; +} + +safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::~safe_VkDescriptorSetLayoutBindingFlagsCreateInfo() { + if (pBindingFlags) delete[] pBindingFlags; + FreePnextChain(pNext); +} + +void safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::initialize(const VkDescriptorSetLayoutBindingFlagsCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pBindingFlags) delete[] pBindingFlags; + FreePnextChain(pNext); + sType = in_struct->sType; + bindingCount = in_struct->bindingCount; + pBindingFlags = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pBindingFlags) { + pBindingFlags = new VkDescriptorBindingFlags[in_struct->bindingCount]; + memcpy((void*)pBindingFlags, (void*)in_struct->pBindingFlags, sizeof(VkDescriptorBindingFlags) * in_struct->bindingCount); + } +} + +void safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::initialize(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + bindingCount = copy_src->bindingCount; + pBindingFlags = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pBindingFlags) { + pBindingFlags = new VkDescriptorBindingFlags[copy_src->bindingCount]; + memcpy((void*)pBindingFlags, (void*)copy_src->pBindingFlags, sizeof(VkDescriptorBindingFlags) * copy_src->bindingCount); + } +} + +safe_VkPhysicalDeviceDescriptorIndexingFeatures::safe_VkPhysicalDeviceDescriptorIndexingFeatures( + const VkPhysicalDeviceDescriptorIndexingFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shaderInputAttachmentArrayDynamicIndexing(in_struct->shaderInputAttachmentArrayDynamicIndexing), + shaderUniformTexelBufferArrayDynamicIndexing(in_struct->shaderUniformTexelBufferArrayDynamicIndexing), + shaderStorageTexelBufferArrayDynamicIndexing(in_struct->shaderStorageTexelBufferArrayDynamicIndexing), + shaderUniformBufferArrayNonUniformIndexing(in_struct->shaderUniformBufferArrayNonUniformIndexing), + shaderSampledImageArrayNonUniformIndexing(in_struct->shaderSampledImageArrayNonUniformIndexing), + shaderStorageBufferArrayNonUniformIndexing(in_struct->shaderStorageBufferArrayNonUniformIndexing), + shaderStorageImageArrayNonUniformIndexing(in_struct->shaderStorageImageArrayNonUniformIndexing), + shaderInputAttachmentArrayNonUniformIndexing(in_struct->shaderInputAttachmentArrayNonUniformIndexing), + shaderUniformTexelBufferArrayNonUniformIndexing(in_struct->shaderUniformTexelBufferArrayNonUniformIndexing), + shaderStorageTexelBufferArrayNonUniformIndexing(in_struct->shaderStorageTexelBufferArrayNonUniformIndexing), + descriptorBindingUniformBufferUpdateAfterBind(in_struct->descriptorBindingUniformBufferUpdateAfterBind), + descriptorBindingSampledImageUpdateAfterBind(in_struct->descriptorBindingSampledImageUpdateAfterBind), + descriptorBindingStorageImageUpdateAfterBind(in_struct->descriptorBindingStorageImageUpdateAfterBind), + descriptorBindingStorageBufferUpdateAfterBind(in_struct->descriptorBindingStorageBufferUpdateAfterBind), + descriptorBindingUniformTexelBufferUpdateAfterBind(in_struct->descriptorBindingUniformTexelBufferUpdateAfterBind), + descriptorBindingStorageTexelBufferUpdateAfterBind(in_struct->descriptorBindingStorageTexelBufferUpdateAfterBind), + descriptorBindingUpdateUnusedWhilePending(in_struct->descriptorBindingUpdateUnusedWhilePending), + descriptorBindingPartiallyBound(in_struct->descriptorBindingPartiallyBound), + descriptorBindingVariableDescriptorCount(in_struct->descriptorBindingVariableDescriptorCount), + runtimeDescriptorArray(in_struct->runtimeDescriptorArray) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDescriptorIndexingFeatures::safe_VkPhysicalDeviceDescriptorIndexingFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES), + pNext(nullptr), + shaderInputAttachmentArrayDynamicIndexing(), + shaderUniformTexelBufferArrayDynamicIndexing(), + shaderStorageTexelBufferArrayDynamicIndexing(), + shaderUniformBufferArrayNonUniformIndexing(), + shaderSampledImageArrayNonUniformIndexing(), + shaderStorageBufferArrayNonUniformIndexing(), + shaderStorageImageArrayNonUniformIndexing(), + shaderInputAttachmentArrayNonUniformIndexing(), + shaderUniformTexelBufferArrayNonUniformIndexing(), + shaderStorageTexelBufferArrayNonUniformIndexing(), + descriptorBindingUniformBufferUpdateAfterBind(), + descriptorBindingSampledImageUpdateAfterBind(), + descriptorBindingStorageImageUpdateAfterBind(), + descriptorBindingStorageBufferUpdateAfterBind(), + descriptorBindingUniformTexelBufferUpdateAfterBind(), + descriptorBindingStorageTexelBufferUpdateAfterBind(), + descriptorBindingUpdateUnusedWhilePending(), + descriptorBindingPartiallyBound(), + descriptorBindingVariableDescriptorCount(), + runtimeDescriptorArray() {} + +safe_VkPhysicalDeviceDescriptorIndexingFeatures::safe_VkPhysicalDeviceDescriptorIndexingFeatures( + const safe_VkPhysicalDeviceDescriptorIndexingFeatures& copy_src) { + sType = copy_src.sType; + shaderInputAttachmentArrayDynamicIndexing = copy_src.shaderInputAttachmentArrayDynamicIndexing; + shaderUniformTexelBufferArrayDynamicIndexing = copy_src.shaderUniformTexelBufferArrayDynamicIndexing; + shaderStorageTexelBufferArrayDynamicIndexing = copy_src.shaderStorageTexelBufferArrayDynamicIndexing; + shaderUniformBufferArrayNonUniformIndexing = copy_src.shaderUniformBufferArrayNonUniformIndexing; + shaderSampledImageArrayNonUniformIndexing = copy_src.shaderSampledImageArrayNonUniformIndexing; + shaderStorageBufferArrayNonUniformIndexing = copy_src.shaderStorageBufferArrayNonUniformIndexing; + shaderStorageImageArrayNonUniformIndexing = copy_src.shaderStorageImageArrayNonUniformIndexing; + shaderInputAttachmentArrayNonUniformIndexing = copy_src.shaderInputAttachmentArrayNonUniformIndexing; + shaderUniformTexelBufferArrayNonUniformIndexing = copy_src.shaderUniformTexelBufferArrayNonUniformIndexing; + shaderStorageTexelBufferArrayNonUniformIndexing = copy_src.shaderStorageTexelBufferArrayNonUniformIndexing; + descriptorBindingUniformBufferUpdateAfterBind = copy_src.descriptorBindingUniformBufferUpdateAfterBind; + descriptorBindingSampledImageUpdateAfterBind = copy_src.descriptorBindingSampledImageUpdateAfterBind; + descriptorBindingStorageImageUpdateAfterBind = copy_src.descriptorBindingStorageImageUpdateAfterBind; + descriptorBindingStorageBufferUpdateAfterBind = copy_src.descriptorBindingStorageBufferUpdateAfterBind; + descriptorBindingUniformTexelBufferUpdateAfterBind = copy_src.descriptorBindingUniformTexelBufferUpdateAfterBind; + descriptorBindingStorageTexelBufferUpdateAfterBind = copy_src.descriptorBindingStorageTexelBufferUpdateAfterBind; + descriptorBindingUpdateUnusedWhilePending = copy_src.descriptorBindingUpdateUnusedWhilePending; + descriptorBindingPartiallyBound = copy_src.descriptorBindingPartiallyBound; + descriptorBindingVariableDescriptorCount = copy_src.descriptorBindingVariableDescriptorCount; + runtimeDescriptorArray = copy_src.runtimeDescriptorArray; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDescriptorIndexingFeatures& safe_VkPhysicalDeviceDescriptorIndexingFeatures::operator=( + const safe_VkPhysicalDeviceDescriptorIndexingFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderInputAttachmentArrayDynamicIndexing = copy_src.shaderInputAttachmentArrayDynamicIndexing; + shaderUniformTexelBufferArrayDynamicIndexing = copy_src.shaderUniformTexelBufferArrayDynamicIndexing; + shaderStorageTexelBufferArrayDynamicIndexing = copy_src.shaderStorageTexelBufferArrayDynamicIndexing; + shaderUniformBufferArrayNonUniformIndexing = copy_src.shaderUniformBufferArrayNonUniformIndexing; + shaderSampledImageArrayNonUniformIndexing = copy_src.shaderSampledImageArrayNonUniformIndexing; + shaderStorageBufferArrayNonUniformIndexing = copy_src.shaderStorageBufferArrayNonUniformIndexing; + shaderStorageImageArrayNonUniformIndexing = copy_src.shaderStorageImageArrayNonUniformIndexing; + shaderInputAttachmentArrayNonUniformIndexing = copy_src.shaderInputAttachmentArrayNonUniformIndexing; + shaderUniformTexelBufferArrayNonUniformIndexing = copy_src.shaderUniformTexelBufferArrayNonUniformIndexing; + shaderStorageTexelBufferArrayNonUniformIndexing = copy_src.shaderStorageTexelBufferArrayNonUniformIndexing; + descriptorBindingUniformBufferUpdateAfterBind = copy_src.descriptorBindingUniformBufferUpdateAfterBind; + descriptorBindingSampledImageUpdateAfterBind = copy_src.descriptorBindingSampledImageUpdateAfterBind; + descriptorBindingStorageImageUpdateAfterBind = copy_src.descriptorBindingStorageImageUpdateAfterBind; + descriptorBindingStorageBufferUpdateAfterBind = copy_src.descriptorBindingStorageBufferUpdateAfterBind; + descriptorBindingUniformTexelBufferUpdateAfterBind = copy_src.descriptorBindingUniformTexelBufferUpdateAfterBind; + descriptorBindingStorageTexelBufferUpdateAfterBind = copy_src.descriptorBindingStorageTexelBufferUpdateAfterBind; + descriptorBindingUpdateUnusedWhilePending = copy_src.descriptorBindingUpdateUnusedWhilePending; + descriptorBindingPartiallyBound = copy_src.descriptorBindingPartiallyBound; + descriptorBindingVariableDescriptorCount = copy_src.descriptorBindingVariableDescriptorCount; + runtimeDescriptorArray = copy_src.runtimeDescriptorArray; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDescriptorIndexingFeatures::~safe_VkPhysicalDeviceDescriptorIndexingFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceDescriptorIndexingFeatures::initialize(const VkPhysicalDeviceDescriptorIndexingFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderInputAttachmentArrayDynamicIndexing = in_struct->shaderInputAttachmentArrayDynamicIndexing; + shaderUniformTexelBufferArrayDynamicIndexing = in_struct->shaderUniformTexelBufferArrayDynamicIndexing; + shaderStorageTexelBufferArrayDynamicIndexing = in_struct->shaderStorageTexelBufferArrayDynamicIndexing; + shaderUniformBufferArrayNonUniformIndexing = in_struct->shaderUniformBufferArrayNonUniformIndexing; + shaderSampledImageArrayNonUniformIndexing = in_struct->shaderSampledImageArrayNonUniformIndexing; + shaderStorageBufferArrayNonUniformIndexing = in_struct->shaderStorageBufferArrayNonUniformIndexing; + shaderStorageImageArrayNonUniformIndexing = in_struct->shaderStorageImageArrayNonUniformIndexing; + shaderInputAttachmentArrayNonUniformIndexing = in_struct->shaderInputAttachmentArrayNonUniformIndexing; + shaderUniformTexelBufferArrayNonUniformIndexing = in_struct->shaderUniformTexelBufferArrayNonUniformIndexing; + shaderStorageTexelBufferArrayNonUniformIndexing = in_struct->shaderStorageTexelBufferArrayNonUniformIndexing; + descriptorBindingUniformBufferUpdateAfterBind = in_struct->descriptorBindingUniformBufferUpdateAfterBind; + descriptorBindingSampledImageUpdateAfterBind = in_struct->descriptorBindingSampledImageUpdateAfterBind; + descriptorBindingStorageImageUpdateAfterBind = in_struct->descriptorBindingStorageImageUpdateAfterBind; + descriptorBindingStorageBufferUpdateAfterBind = in_struct->descriptorBindingStorageBufferUpdateAfterBind; + descriptorBindingUniformTexelBufferUpdateAfterBind = in_struct->descriptorBindingUniformTexelBufferUpdateAfterBind; + descriptorBindingStorageTexelBufferUpdateAfterBind = in_struct->descriptorBindingStorageTexelBufferUpdateAfterBind; + descriptorBindingUpdateUnusedWhilePending = in_struct->descriptorBindingUpdateUnusedWhilePending; + descriptorBindingPartiallyBound = in_struct->descriptorBindingPartiallyBound; + descriptorBindingVariableDescriptorCount = in_struct->descriptorBindingVariableDescriptorCount; + runtimeDescriptorArray = in_struct->runtimeDescriptorArray; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDescriptorIndexingFeatures::initialize(const safe_VkPhysicalDeviceDescriptorIndexingFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderInputAttachmentArrayDynamicIndexing = copy_src->shaderInputAttachmentArrayDynamicIndexing; + shaderUniformTexelBufferArrayDynamicIndexing = copy_src->shaderUniformTexelBufferArrayDynamicIndexing; + shaderStorageTexelBufferArrayDynamicIndexing = copy_src->shaderStorageTexelBufferArrayDynamicIndexing; + shaderUniformBufferArrayNonUniformIndexing = copy_src->shaderUniformBufferArrayNonUniformIndexing; + shaderSampledImageArrayNonUniformIndexing = copy_src->shaderSampledImageArrayNonUniformIndexing; + shaderStorageBufferArrayNonUniformIndexing = copy_src->shaderStorageBufferArrayNonUniformIndexing; + shaderStorageImageArrayNonUniformIndexing = copy_src->shaderStorageImageArrayNonUniformIndexing; + shaderInputAttachmentArrayNonUniformIndexing = copy_src->shaderInputAttachmentArrayNonUniformIndexing; + shaderUniformTexelBufferArrayNonUniformIndexing = copy_src->shaderUniformTexelBufferArrayNonUniformIndexing; + shaderStorageTexelBufferArrayNonUniformIndexing = copy_src->shaderStorageTexelBufferArrayNonUniformIndexing; + descriptorBindingUniformBufferUpdateAfterBind = copy_src->descriptorBindingUniformBufferUpdateAfterBind; + descriptorBindingSampledImageUpdateAfterBind = copy_src->descriptorBindingSampledImageUpdateAfterBind; + descriptorBindingStorageImageUpdateAfterBind = copy_src->descriptorBindingStorageImageUpdateAfterBind; + descriptorBindingStorageBufferUpdateAfterBind = copy_src->descriptorBindingStorageBufferUpdateAfterBind; + descriptorBindingUniformTexelBufferUpdateAfterBind = copy_src->descriptorBindingUniformTexelBufferUpdateAfterBind; + descriptorBindingStorageTexelBufferUpdateAfterBind = copy_src->descriptorBindingStorageTexelBufferUpdateAfterBind; + descriptorBindingUpdateUnusedWhilePending = copy_src->descriptorBindingUpdateUnusedWhilePending; + descriptorBindingPartiallyBound = copy_src->descriptorBindingPartiallyBound; + descriptorBindingVariableDescriptorCount = copy_src->descriptorBindingVariableDescriptorCount; + runtimeDescriptorArray = copy_src->runtimeDescriptorArray; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDescriptorIndexingProperties::safe_VkPhysicalDeviceDescriptorIndexingProperties( + const VkPhysicalDeviceDescriptorIndexingProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + maxUpdateAfterBindDescriptorsInAllPools(in_struct->maxUpdateAfterBindDescriptorsInAllPools), + shaderUniformBufferArrayNonUniformIndexingNative(in_struct->shaderUniformBufferArrayNonUniformIndexingNative), + shaderSampledImageArrayNonUniformIndexingNative(in_struct->shaderSampledImageArrayNonUniformIndexingNative), + shaderStorageBufferArrayNonUniformIndexingNative(in_struct->shaderStorageBufferArrayNonUniformIndexingNative), + shaderStorageImageArrayNonUniformIndexingNative(in_struct->shaderStorageImageArrayNonUniformIndexingNative), + shaderInputAttachmentArrayNonUniformIndexingNative(in_struct->shaderInputAttachmentArrayNonUniformIndexingNative), + robustBufferAccessUpdateAfterBind(in_struct->robustBufferAccessUpdateAfterBind), + quadDivergentImplicitLod(in_struct->quadDivergentImplicitLod), + maxPerStageDescriptorUpdateAfterBindSamplers(in_struct->maxPerStageDescriptorUpdateAfterBindSamplers), + maxPerStageDescriptorUpdateAfterBindUniformBuffers(in_struct->maxPerStageDescriptorUpdateAfterBindUniformBuffers), + maxPerStageDescriptorUpdateAfterBindStorageBuffers(in_struct->maxPerStageDescriptorUpdateAfterBindStorageBuffers), + maxPerStageDescriptorUpdateAfterBindSampledImages(in_struct->maxPerStageDescriptorUpdateAfterBindSampledImages), + maxPerStageDescriptorUpdateAfterBindStorageImages(in_struct->maxPerStageDescriptorUpdateAfterBindStorageImages), + maxPerStageDescriptorUpdateAfterBindInputAttachments(in_struct->maxPerStageDescriptorUpdateAfterBindInputAttachments), + maxPerStageUpdateAfterBindResources(in_struct->maxPerStageUpdateAfterBindResources), + maxDescriptorSetUpdateAfterBindSamplers(in_struct->maxDescriptorSetUpdateAfterBindSamplers), + maxDescriptorSetUpdateAfterBindUniformBuffers(in_struct->maxDescriptorSetUpdateAfterBindUniformBuffers), + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic(in_struct->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic), + maxDescriptorSetUpdateAfterBindStorageBuffers(in_struct->maxDescriptorSetUpdateAfterBindStorageBuffers), + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic(in_struct->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic), + maxDescriptorSetUpdateAfterBindSampledImages(in_struct->maxDescriptorSetUpdateAfterBindSampledImages), + maxDescriptorSetUpdateAfterBindStorageImages(in_struct->maxDescriptorSetUpdateAfterBindStorageImages), + maxDescriptorSetUpdateAfterBindInputAttachments(in_struct->maxDescriptorSetUpdateAfterBindInputAttachments) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDescriptorIndexingProperties::safe_VkPhysicalDeviceDescriptorIndexingProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES), + pNext(nullptr), + maxUpdateAfterBindDescriptorsInAllPools(), + shaderUniformBufferArrayNonUniformIndexingNative(), + shaderSampledImageArrayNonUniformIndexingNative(), + shaderStorageBufferArrayNonUniformIndexingNative(), + shaderStorageImageArrayNonUniformIndexingNative(), + shaderInputAttachmentArrayNonUniformIndexingNative(), + robustBufferAccessUpdateAfterBind(), + quadDivergentImplicitLod(), + maxPerStageDescriptorUpdateAfterBindSamplers(), + maxPerStageDescriptorUpdateAfterBindUniformBuffers(), + maxPerStageDescriptorUpdateAfterBindStorageBuffers(), + maxPerStageDescriptorUpdateAfterBindSampledImages(), + maxPerStageDescriptorUpdateAfterBindStorageImages(), + maxPerStageDescriptorUpdateAfterBindInputAttachments(), + maxPerStageUpdateAfterBindResources(), + maxDescriptorSetUpdateAfterBindSamplers(), + maxDescriptorSetUpdateAfterBindUniformBuffers(), + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic(), + maxDescriptorSetUpdateAfterBindStorageBuffers(), + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic(), + maxDescriptorSetUpdateAfterBindSampledImages(), + maxDescriptorSetUpdateAfterBindStorageImages(), + maxDescriptorSetUpdateAfterBindInputAttachments() {} + +safe_VkPhysicalDeviceDescriptorIndexingProperties::safe_VkPhysicalDeviceDescriptorIndexingProperties( + const safe_VkPhysicalDeviceDescriptorIndexingProperties& copy_src) { + sType = copy_src.sType; + maxUpdateAfterBindDescriptorsInAllPools = copy_src.maxUpdateAfterBindDescriptorsInAllPools; + shaderUniformBufferArrayNonUniformIndexingNative = copy_src.shaderUniformBufferArrayNonUniformIndexingNative; + shaderSampledImageArrayNonUniformIndexingNative = copy_src.shaderSampledImageArrayNonUniformIndexingNative; + shaderStorageBufferArrayNonUniformIndexingNative = copy_src.shaderStorageBufferArrayNonUniformIndexingNative; + shaderStorageImageArrayNonUniformIndexingNative = copy_src.shaderStorageImageArrayNonUniformIndexingNative; + shaderInputAttachmentArrayNonUniformIndexingNative = copy_src.shaderInputAttachmentArrayNonUniformIndexingNative; + robustBufferAccessUpdateAfterBind = copy_src.robustBufferAccessUpdateAfterBind; + quadDivergentImplicitLod = copy_src.quadDivergentImplicitLod; + maxPerStageDescriptorUpdateAfterBindSamplers = copy_src.maxPerStageDescriptorUpdateAfterBindSamplers; + maxPerStageDescriptorUpdateAfterBindUniformBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindUniformBuffers; + maxPerStageDescriptorUpdateAfterBindStorageBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindStorageBuffers; + maxPerStageDescriptorUpdateAfterBindSampledImages = copy_src.maxPerStageDescriptorUpdateAfterBindSampledImages; + maxPerStageDescriptorUpdateAfterBindStorageImages = copy_src.maxPerStageDescriptorUpdateAfterBindStorageImages; + maxPerStageDescriptorUpdateAfterBindInputAttachments = copy_src.maxPerStageDescriptorUpdateAfterBindInputAttachments; + maxPerStageUpdateAfterBindResources = copy_src.maxPerStageUpdateAfterBindResources; + maxDescriptorSetUpdateAfterBindSamplers = copy_src.maxDescriptorSetUpdateAfterBindSamplers; + maxDescriptorSetUpdateAfterBindUniformBuffers = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffers; + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + maxDescriptorSetUpdateAfterBindStorageBuffers = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffers; + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + maxDescriptorSetUpdateAfterBindSampledImages = copy_src.maxDescriptorSetUpdateAfterBindSampledImages; + maxDescriptorSetUpdateAfterBindStorageImages = copy_src.maxDescriptorSetUpdateAfterBindStorageImages; + maxDescriptorSetUpdateAfterBindInputAttachments = copy_src.maxDescriptorSetUpdateAfterBindInputAttachments; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDescriptorIndexingProperties& safe_VkPhysicalDeviceDescriptorIndexingProperties::operator=( + const safe_VkPhysicalDeviceDescriptorIndexingProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxUpdateAfterBindDescriptorsInAllPools = copy_src.maxUpdateAfterBindDescriptorsInAllPools; + shaderUniformBufferArrayNonUniformIndexingNative = copy_src.shaderUniformBufferArrayNonUniformIndexingNative; + shaderSampledImageArrayNonUniformIndexingNative = copy_src.shaderSampledImageArrayNonUniformIndexingNative; + shaderStorageBufferArrayNonUniformIndexingNative = copy_src.shaderStorageBufferArrayNonUniformIndexingNative; + shaderStorageImageArrayNonUniformIndexingNative = copy_src.shaderStorageImageArrayNonUniformIndexingNative; + shaderInputAttachmentArrayNonUniformIndexingNative = copy_src.shaderInputAttachmentArrayNonUniformIndexingNative; + robustBufferAccessUpdateAfterBind = copy_src.robustBufferAccessUpdateAfterBind; + quadDivergentImplicitLod = copy_src.quadDivergentImplicitLod; + maxPerStageDescriptorUpdateAfterBindSamplers = copy_src.maxPerStageDescriptorUpdateAfterBindSamplers; + maxPerStageDescriptorUpdateAfterBindUniformBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindUniformBuffers; + maxPerStageDescriptorUpdateAfterBindStorageBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindStorageBuffers; + maxPerStageDescriptorUpdateAfterBindSampledImages = copy_src.maxPerStageDescriptorUpdateAfterBindSampledImages; + maxPerStageDescriptorUpdateAfterBindStorageImages = copy_src.maxPerStageDescriptorUpdateAfterBindStorageImages; + maxPerStageDescriptorUpdateAfterBindInputAttachments = copy_src.maxPerStageDescriptorUpdateAfterBindInputAttachments; + maxPerStageUpdateAfterBindResources = copy_src.maxPerStageUpdateAfterBindResources; + maxDescriptorSetUpdateAfterBindSamplers = copy_src.maxDescriptorSetUpdateAfterBindSamplers; + maxDescriptorSetUpdateAfterBindUniformBuffers = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffers; + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + maxDescriptorSetUpdateAfterBindStorageBuffers = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffers; + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + maxDescriptorSetUpdateAfterBindSampledImages = copy_src.maxDescriptorSetUpdateAfterBindSampledImages; + maxDescriptorSetUpdateAfterBindStorageImages = copy_src.maxDescriptorSetUpdateAfterBindStorageImages; + maxDescriptorSetUpdateAfterBindInputAttachments = copy_src.maxDescriptorSetUpdateAfterBindInputAttachments; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDescriptorIndexingProperties::~safe_VkPhysicalDeviceDescriptorIndexingProperties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceDescriptorIndexingProperties::initialize(const VkPhysicalDeviceDescriptorIndexingProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxUpdateAfterBindDescriptorsInAllPools = in_struct->maxUpdateAfterBindDescriptorsInAllPools; + shaderUniformBufferArrayNonUniformIndexingNative = in_struct->shaderUniformBufferArrayNonUniformIndexingNative; + shaderSampledImageArrayNonUniformIndexingNative = in_struct->shaderSampledImageArrayNonUniformIndexingNative; + shaderStorageBufferArrayNonUniformIndexingNative = in_struct->shaderStorageBufferArrayNonUniformIndexingNative; + shaderStorageImageArrayNonUniformIndexingNative = in_struct->shaderStorageImageArrayNonUniformIndexingNative; + shaderInputAttachmentArrayNonUniformIndexingNative = in_struct->shaderInputAttachmentArrayNonUniformIndexingNative; + robustBufferAccessUpdateAfterBind = in_struct->robustBufferAccessUpdateAfterBind; + quadDivergentImplicitLod = in_struct->quadDivergentImplicitLod; + maxPerStageDescriptorUpdateAfterBindSamplers = in_struct->maxPerStageDescriptorUpdateAfterBindSamplers; + maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_struct->maxPerStageDescriptorUpdateAfterBindUniformBuffers; + maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_struct->maxPerStageDescriptorUpdateAfterBindStorageBuffers; + maxPerStageDescriptorUpdateAfterBindSampledImages = in_struct->maxPerStageDescriptorUpdateAfterBindSampledImages; + maxPerStageDescriptorUpdateAfterBindStorageImages = in_struct->maxPerStageDescriptorUpdateAfterBindStorageImages; + maxPerStageDescriptorUpdateAfterBindInputAttachments = in_struct->maxPerStageDescriptorUpdateAfterBindInputAttachments; + maxPerStageUpdateAfterBindResources = in_struct->maxPerStageUpdateAfterBindResources; + maxDescriptorSetUpdateAfterBindSamplers = in_struct->maxDescriptorSetUpdateAfterBindSamplers; + maxDescriptorSetUpdateAfterBindUniformBuffers = in_struct->maxDescriptorSetUpdateAfterBindUniformBuffers; + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_struct->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + maxDescriptorSetUpdateAfterBindStorageBuffers = in_struct->maxDescriptorSetUpdateAfterBindStorageBuffers; + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_struct->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + maxDescriptorSetUpdateAfterBindSampledImages = in_struct->maxDescriptorSetUpdateAfterBindSampledImages; + maxDescriptorSetUpdateAfterBindStorageImages = in_struct->maxDescriptorSetUpdateAfterBindStorageImages; + maxDescriptorSetUpdateAfterBindInputAttachments = in_struct->maxDescriptorSetUpdateAfterBindInputAttachments; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDescriptorIndexingProperties::initialize( + const safe_VkPhysicalDeviceDescriptorIndexingProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxUpdateAfterBindDescriptorsInAllPools = copy_src->maxUpdateAfterBindDescriptorsInAllPools; + shaderUniformBufferArrayNonUniformIndexingNative = copy_src->shaderUniformBufferArrayNonUniformIndexingNative; + shaderSampledImageArrayNonUniformIndexingNative = copy_src->shaderSampledImageArrayNonUniformIndexingNative; + shaderStorageBufferArrayNonUniformIndexingNative = copy_src->shaderStorageBufferArrayNonUniformIndexingNative; + shaderStorageImageArrayNonUniformIndexingNative = copy_src->shaderStorageImageArrayNonUniformIndexingNative; + shaderInputAttachmentArrayNonUniformIndexingNative = copy_src->shaderInputAttachmentArrayNonUniformIndexingNative; + robustBufferAccessUpdateAfterBind = copy_src->robustBufferAccessUpdateAfterBind; + quadDivergentImplicitLod = copy_src->quadDivergentImplicitLod; + maxPerStageDescriptorUpdateAfterBindSamplers = copy_src->maxPerStageDescriptorUpdateAfterBindSamplers; + maxPerStageDescriptorUpdateAfterBindUniformBuffers = copy_src->maxPerStageDescriptorUpdateAfterBindUniformBuffers; + maxPerStageDescriptorUpdateAfterBindStorageBuffers = copy_src->maxPerStageDescriptorUpdateAfterBindStorageBuffers; + maxPerStageDescriptorUpdateAfterBindSampledImages = copy_src->maxPerStageDescriptorUpdateAfterBindSampledImages; + maxPerStageDescriptorUpdateAfterBindStorageImages = copy_src->maxPerStageDescriptorUpdateAfterBindStorageImages; + maxPerStageDescriptorUpdateAfterBindInputAttachments = copy_src->maxPerStageDescriptorUpdateAfterBindInputAttachments; + maxPerStageUpdateAfterBindResources = copy_src->maxPerStageUpdateAfterBindResources; + maxDescriptorSetUpdateAfterBindSamplers = copy_src->maxDescriptorSetUpdateAfterBindSamplers; + maxDescriptorSetUpdateAfterBindUniformBuffers = copy_src->maxDescriptorSetUpdateAfterBindUniformBuffers; + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = copy_src->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + maxDescriptorSetUpdateAfterBindStorageBuffers = copy_src->maxDescriptorSetUpdateAfterBindStorageBuffers; + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = copy_src->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + maxDescriptorSetUpdateAfterBindSampledImages = copy_src->maxDescriptorSetUpdateAfterBindSampledImages; + maxDescriptorSetUpdateAfterBindStorageImages = copy_src->maxDescriptorSetUpdateAfterBindStorageImages; + maxDescriptorSetUpdateAfterBindInputAttachments = copy_src->maxDescriptorSetUpdateAfterBindInputAttachments; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::safe_VkDescriptorSetVariableDescriptorCountAllocateInfo( + const VkDescriptorSetVariableDescriptorCountAllocateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), descriptorSetCount(in_struct->descriptorSetCount), pDescriptorCounts(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pDescriptorCounts) { + pDescriptorCounts = new uint32_t[in_struct->descriptorSetCount]; + memcpy((void*)pDescriptorCounts, (void*)in_struct->pDescriptorCounts, sizeof(uint32_t) * in_struct->descriptorSetCount); + } +} + +safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::safe_VkDescriptorSetVariableDescriptorCountAllocateInfo() + : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO), + pNext(nullptr), + descriptorSetCount(), + pDescriptorCounts(nullptr) {} + +safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::safe_VkDescriptorSetVariableDescriptorCountAllocateInfo( + const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& copy_src) { + sType = copy_src.sType; + descriptorSetCount = copy_src.descriptorSetCount; + pDescriptorCounts = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDescriptorCounts) { + pDescriptorCounts = new uint32_t[copy_src.descriptorSetCount]; + memcpy((void*)pDescriptorCounts, (void*)copy_src.pDescriptorCounts, sizeof(uint32_t) * copy_src.descriptorSetCount); + } +} + +safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::operator=( + const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& copy_src) { + if (©_src == this) return *this; + + if (pDescriptorCounts) delete[] pDescriptorCounts; + FreePnextChain(pNext); + + sType = copy_src.sType; + descriptorSetCount = copy_src.descriptorSetCount; + pDescriptorCounts = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDescriptorCounts) { + pDescriptorCounts = new uint32_t[copy_src.descriptorSetCount]; + memcpy((void*)pDescriptorCounts, (void*)copy_src.pDescriptorCounts, sizeof(uint32_t) * copy_src.descriptorSetCount); + } + + return *this; +} + +safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::~safe_VkDescriptorSetVariableDescriptorCountAllocateInfo() { + if (pDescriptorCounts) delete[] pDescriptorCounts; + FreePnextChain(pNext); +} + +void safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::initialize( + const VkDescriptorSetVariableDescriptorCountAllocateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pDescriptorCounts) delete[] pDescriptorCounts; + FreePnextChain(pNext); + sType = in_struct->sType; + descriptorSetCount = in_struct->descriptorSetCount; + pDescriptorCounts = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pDescriptorCounts) { + pDescriptorCounts = new uint32_t[in_struct->descriptorSetCount]; + memcpy((void*)pDescriptorCounts, (void*)in_struct->pDescriptorCounts, sizeof(uint32_t) * in_struct->descriptorSetCount); + } +} + +void safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::initialize( + const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + descriptorSetCount = copy_src->descriptorSetCount; + pDescriptorCounts = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pDescriptorCounts) { + pDescriptorCounts = new uint32_t[copy_src->descriptorSetCount]; + memcpy((void*)pDescriptorCounts, (void*)copy_src->pDescriptorCounts, sizeof(uint32_t) * copy_src->descriptorSetCount); + } +} + +safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::safe_VkDescriptorSetVariableDescriptorCountLayoutSupport( + const VkDescriptorSetVariableDescriptorCountLayoutSupport* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), maxVariableDescriptorCount(in_struct->maxVariableDescriptorCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::safe_VkDescriptorSetVariableDescriptorCountLayoutSupport() + : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT), + pNext(nullptr), + maxVariableDescriptorCount() {} + +safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::safe_VkDescriptorSetVariableDescriptorCountLayoutSupport( + const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& copy_src) { + sType = copy_src.sType; + maxVariableDescriptorCount = copy_src.maxVariableDescriptorCount; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::operator=( + const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxVariableDescriptorCount = copy_src.maxVariableDescriptorCount; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::~safe_VkDescriptorSetVariableDescriptorCountLayoutSupport() { + FreePnextChain(pNext); +} + +void safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::initialize( + const VkDescriptorSetVariableDescriptorCountLayoutSupport* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxVariableDescriptorCount = in_struct->maxVariableDescriptorCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::initialize( + const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxVariableDescriptorCount = copy_src->maxVariableDescriptorCount; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSubpassDescriptionDepthStencilResolve::safe_VkSubpassDescriptionDepthStencilResolve( + const VkSubpassDescriptionDepthStencilResolve* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + depthResolveMode(in_struct->depthResolveMode), + stencilResolveMode(in_struct->stencilResolveMode), + pDepthStencilResolveAttachment(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pDepthStencilResolveAttachment) + pDepthStencilResolveAttachment = new safe_VkAttachmentReference2(in_struct->pDepthStencilResolveAttachment); +} + +safe_VkSubpassDescriptionDepthStencilResolve::safe_VkSubpassDescriptionDepthStencilResolve() + : sType(VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE), + pNext(nullptr), + depthResolveMode(), + stencilResolveMode(), + pDepthStencilResolveAttachment(nullptr) {} + +safe_VkSubpassDescriptionDepthStencilResolve::safe_VkSubpassDescriptionDepthStencilResolve( + const safe_VkSubpassDescriptionDepthStencilResolve& copy_src) { + sType = copy_src.sType; + depthResolveMode = copy_src.depthResolveMode; + stencilResolveMode = copy_src.stencilResolveMode; + pDepthStencilResolveAttachment = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pDepthStencilResolveAttachment) + pDepthStencilResolveAttachment = new safe_VkAttachmentReference2(*copy_src.pDepthStencilResolveAttachment); +} + +safe_VkSubpassDescriptionDepthStencilResolve& safe_VkSubpassDescriptionDepthStencilResolve::operator=( + const safe_VkSubpassDescriptionDepthStencilResolve& copy_src) { + if (©_src == this) return *this; + + if (pDepthStencilResolveAttachment) delete pDepthStencilResolveAttachment; + FreePnextChain(pNext); + + sType = copy_src.sType; + depthResolveMode = copy_src.depthResolveMode; + stencilResolveMode = copy_src.stencilResolveMode; + pDepthStencilResolveAttachment = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pDepthStencilResolveAttachment) + pDepthStencilResolveAttachment = new safe_VkAttachmentReference2(*copy_src.pDepthStencilResolveAttachment); + + return *this; +} + +safe_VkSubpassDescriptionDepthStencilResolve::~safe_VkSubpassDescriptionDepthStencilResolve() { + if (pDepthStencilResolveAttachment) delete pDepthStencilResolveAttachment; + FreePnextChain(pNext); +} + +void safe_VkSubpassDescriptionDepthStencilResolve::initialize(const VkSubpassDescriptionDepthStencilResolve* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDepthStencilResolveAttachment) delete pDepthStencilResolveAttachment; + FreePnextChain(pNext); + sType = in_struct->sType; + depthResolveMode = in_struct->depthResolveMode; + stencilResolveMode = in_struct->stencilResolveMode; + pDepthStencilResolveAttachment = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (in_struct->pDepthStencilResolveAttachment) + pDepthStencilResolveAttachment = new safe_VkAttachmentReference2(in_struct->pDepthStencilResolveAttachment); +} + +void safe_VkSubpassDescriptionDepthStencilResolve::initialize(const safe_VkSubpassDescriptionDepthStencilResolve* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + depthResolveMode = copy_src->depthResolveMode; + stencilResolveMode = copy_src->stencilResolveMode; + pDepthStencilResolveAttachment = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (copy_src->pDepthStencilResolveAttachment) + pDepthStencilResolveAttachment = new safe_VkAttachmentReference2(*copy_src->pDepthStencilResolveAttachment); +} + +safe_VkPhysicalDeviceDepthStencilResolveProperties::safe_VkPhysicalDeviceDepthStencilResolveProperties( + const VkPhysicalDeviceDepthStencilResolveProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + supportedDepthResolveModes(in_struct->supportedDepthResolveModes), + supportedStencilResolveModes(in_struct->supportedStencilResolveModes), + independentResolveNone(in_struct->independentResolveNone), + independentResolve(in_struct->independentResolve) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDepthStencilResolveProperties::safe_VkPhysicalDeviceDepthStencilResolveProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES), + pNext(nullptr), + supportedDepthResolveModes(), + supportedStencilResolveModes(), + independentResolveNone(), + independentResolve() {} + +safe_VkPhysicalDeviceDepthStencilResolveProperties::safe_VkPhysicalDeviceDepthStencilResolveProperties( + const safe_VkPhysicalDeviceDepthStencilResolveProperties& copy_src) { + sType = copy_src.sType; + supportedDepthResolveModes = copy_src.supportedDepthResolveModes; + supportedStencilResolveModes = copy_src.supportedStencilResolveModes; + independentResolveNone = copy_src.independentResolveNone; + independentResolve = copy_src.independentResolve; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDepthStencilResolveProperties& safe_VkPhysicalDeviceDepthStencilResolveProperties::operator=( + const safe_VkPhysicalDeviceDepthStencilResolveProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + supportedDepthResolveModes = copy_src.supportedDepthResolveModes; + supportedStencilResolveModes = copy_src.supportedStencilResolveModes; + independentResolveNone = copy_src.independentResolveNone; + independentResolve = copy_src.independentResolve; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDepthStencilResolveProperties::~safe_VkPhysicalDeviceDepthStencilResolveProperties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceDepthStencilResolveProperties::initialize(const VkPhysicalDeviceDepthStencilResolveProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + supportedDepthResolveModes = in_struct->supportedDepthResolveModes; + supportedStencilResolveModes = in_struct->supportedStencilResolveModes; + independentResolveNone = in_struct->independentResolveNone; + independentResolve = in_struct->independentResolve; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDepthStencilResolveProperties::initialize( + const safe_VkPhysicalDeviceDepthStencilResolveProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + supportedDepthResolveModes = copy_src->supportedDepthResolveModes; + supportedStencilResolveModes = copy_src->supportedStencilResolveModes; + independentResolveNone = copy_src->independentResolveNone; + independentResolve = copy_src->independentResolve; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceScalarBlockLayoutFeatures::safe_VkPhysicalDeviceScalarBlockLayoutFeatures( + const VkPhysicalDeviceScalarBlockLayoutFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), scalarBlockLayout(in_struct->scalarBlockLayout) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceScalarBlockLayoutFeatures::safe_VkPhysicalDeviceScalarBlockLayoutFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES), pNext(nullptr), scalarBlockLayout() {} + +safe_VkPhysicalDeviceScalarBlockLayoutFeatures::safe_VkPhysicalDeviceScalarBlockLayoutFeatures( + const safe_VkPhysicalDeviceScalarBlockLayoutFeatures& copy_src) { + sType = copy_src.sType; + scalarBlockLayout = copy_src.scalarBlockLayout; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceScalarBlockLayoutFeatures& safe_VkPhysicalDeviceScalarBlockLayoutFeatures::operator=( + const safe_VkPhysicalDeviceScalarBlockLayoutFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + scalarBlockLayout = copy_src.scalarBlockLayout; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceScalarBlockLayoutFeatures::~safe_VkPhysicalDeviceScalarBlockLayoutFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceScalarBlockLayoutFeatures::initialize(const VkPhysicalDeviceScalarBlockLayoutFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + scalarBlockLayout = in_struct->scalarBlockLayout; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceScalarBlockLayoutFeatures::initialize(const safe_VkPhysicalDeviceScalarBlockLayoutFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + scalarBlockLayout = copy_src->scalarBlockLayout; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImageStencilUsageCreateInfo::safe_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), stencilUsage(in_struct->stencilUsage) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageStencilUsageCreateInfo::safe_VkImageStencilUsageCreateInfo() + : sType(VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO), pNext(nullptr), stencilUsage() {} + +safe_VkImageStencilUsageCreateInfo::safe_VkImageStencilUsageCreateInfo(const safe_VkImageStencilUsageCreateInfo& copy_src) { + sType = copy_src.sType; + stencilUsage = copy_src.stencilUsage; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageStencilUsageCreateInfo& safe_VkImageStencilUsageCreateInfo::operator=( + const safe_VkImageStencilUsageCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + stencilUsage = copy_src.stencilUsage; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageStencilUsageCreateInfo::~safe_VkImageStencilUsageCreateInfo() { FreePnextChain(pNext); } + +void safe_VkImageStencilUsageCreateInfo::initialize(const VkImageStencilUsageCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + stencilUsage = in_struct->stencilUsage; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageStencilUsageCreateInfo::initialize(const safe_VkImageStencilUsageCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stencilUsage = copy_src->stencilUsage; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSamplerReductionModeCreateInfo::safe_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), reductionMode(in_struct->reductionMode) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSamplerReductionModeCreateInfo::safe_VkSamplerReductionModeCreateInfo() + : sType(VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO), pNext(nullptr), reductionMode() {} + +safe_VkSamplerReductionModeCreateInfo::safe_VkSamplerReductionModeCreateInfo( + const safe_VkSamplerReductionModeCreateInfo& copy_src) { + sType = copy_src.sType; + reductionMode = copy_src.reductionMode; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSamplerReductionModeCreateInfo& safe_VkSamplerReductionModeCreateInfo::operator=( + const safe_VkSamplerReductionModeCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + reductionMode = copy_src.reductionMode; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSamplerReductionModeCreateInfo::~safe_VkSamplerReductionModeCreateInfo() { FreePnextChain(pNext); } + +void safe_VkSamplerReductionModeCreateInfo::initialize(const VkSamplerReductionModeCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + reductionMode = in_struct->reductionMode; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSamplerReductionModeCreateInfo::initialize(const safe_VkSamplerReductionModeCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + reductionMode = copy_src->reductionMode; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::safe_VkPhysicalDeviceSamplerFilterMinmaxProperties( + const VkPhysicalDeviceSamplerFilterMinmaxProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + filterMinmaxSingleComponentFormats(in_struct->filterMinmaxSingleComponentFormats), + filterMinmaxImageComponentMapping(in_struct->filterMinmaxImageComponentMapping) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::safe_VkPhysicalDeviceSamplerFilterMinmaxProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES), + pNext(nullptr), + filterMinmaxSingleComponentFormats(), + filterMinmaxImageComponentMapping() {} + +safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::safe_VkPhysicalDeviceSamplerFilterMinmaxProperties( + const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& copy_src) { + sType = copy_src.sType; + filterMinmaxSingleComponentFormats = copy_src.filterMinmaxSingleComponentFormats; + filterMinmaxImageComponentMapping = copy_src.filterMinmaxImageComponentMapping; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::operator=( + const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + filterMinmaxSingleComponentFormats = copy_src.filterMinmaxSingleComponentFormats; + filterMinmaxImageComponentMapping = copy_src.filterMinmaxImageComponentMapping; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::~safe_VkPhysicalDeviceSamplerFilterMinmaxProperties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::initialize(const VkPhysicalDeviceSamplerFilterMinmaxProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + filterMinmaxSingleComponentFormats = in_struct->filterMinmaxSingleComponentFormats; + filterMinmaxImageComponentMapping = in_struct->filterMinmaxImageComponentMapping; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::initialize( + const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + filterMinmaxSingleComponentFormats = copy_src->filterMinmaxSingleComponentFormats; + filterMinmaxImageComponentMapping = copy_src->filterMinmaxImageComponentMapping; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceVulkanMemoryModelFeatures::safe_VkPhysicalDeviceVulkanMemoryModelFeatures( + const VkPhysicalDeviceVulkanMemoryModelFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + vulkanMemoryModel(in_struct->vulkanMemoryModel), + vulkanMemoryModelDeviceScope(in_struct->vulkanMemoryModelDeviceScope), + vulkanMemoryModelAvailabilityVisibilityChains(in_struct->vulkanMemoryModelAvailabilityVisibilityChains) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceVulkanMemoryModelFeatures::safe_VkPhysicalDeviceVulkanMemoryModelFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES), + pNext(nullptr), + vulkanMemoryModel(), + vulkanMemoryModelDeviceScope(), + vulkanMemoryModelAvailabilityVisibilityChains() {} + +safe_VkPhysicalDeviceVulkanMemoryModelFeatures::safe_VkPhysicalDeviceVulkanMemoryModelFeatures( + const safe_VkPhysicalDeviceVulkanMemoryModelFeatures& copy_src) { + sType = copy_src.sType; + vulkanMemoryModel = copy_src.vulkanMemoryModel; + vulkanMemoryModelDeviceScope = copy_src.vulkanMemoryModelDeviceScope; + vulkanMemoryModelAvailabilityVisibilityChains = copy_src.vulkanMemoryModelAvailabilityVisibilityChains; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceVulkanMemoryModelFeatures& safe_VkPhysicalDeviceVulkanMemoryModelFeatures::operator=( + const safe_VkPhysicalDeviceVulkanMemoryModelFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + vulkanMemoryModel = copy_src.vulkanMemoryModel; + vulkanMemoryModelDeviceScope = copy_src.vulkanMemoryModelDeviceScope; + vulkanMemoryModelAvailabilityVisibilityChains = copy_src.vulkanMemoryModelAvailabilityVisibilityChains; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceVulkanMemoryModelFeatures::~safe_VkPhysicalDeviceVulkanMemoryModelFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceVulkanMemoryModelFeatures::initialize(const VkPhysicalDeviceVulkanMemoryModelFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + vulkanMemoryModel = in_struct->vulkanMemoryModel; + vulkanMemoryModelDeviceScope = in_struct->vulkanMemoryModelDeviceScope; + vulkanMemoryModelAvailabilityVisibilityChains = in_struct->vulkanMemoryModelAvailabilityVisibilityChains; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceVulkanMemoryModelFeatures::initialize(const safe_VkPhysicalDeviceVulkanMemoryModelFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + vulkanMemoryModel = copy_src->vulkanMemoryModel; + vulkanMemoryModelDeviceScope = copy_src->vulkanMemoryModelDeviceScope; + vulkanMemoryModelAvailabilityVisibilityChains = copy_src->vulkanMemoryModelAvailabilityVisibilityChains; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceImagelessFramebufferFeatures::safe_VkPhysicalDeviceImagelessFramebufferFeatures( + const VkPhysicalDeviceImagelessFramebufferFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), imagelessFramebuffer(in_struct->imagelessFramebuffer) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceImagelessFramebufferFeatures::safe_VkPhysicalDeviceImagelessFramebufferFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES), pNext(nullptr), imagelessFramebuffer() {} + +safe_VkPhysicalDeviceImagelessFramebufferFeatures::safe_VkPhysicalDeviceImagelessFramebufferFeatures( + const safe_VkPhysicalDeviceImagelessFramebufferFeatures& copy_src) { + sType = copy_src.sType; + imagelessFramebuffer = copy_src.imagelessFramebuffer; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceImagelessFramebufferFeatures& safe_VkPhysicalDeviceImagelessFramebufferFeatures::operator=( + const safe_VkPhysicalDeviceImagelessFramebufferFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + imagelessFramebuffer = copy_src.imagelessFramebuffer; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceImagelessFramebufferFeatures::~safe_VkPhysicalDeviceImagelessFramebufferFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceImagelessFramebufferFeatures::initialize(const VkPhysicalDeviceImagelessFramebufferFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + imagelessFramebuffer = in_struct->imagelessFramebuffer; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceImagelessFramebufferFeatures::initialize( + const safe_VkPhysicalDeviceImagelessFramebufferFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + imagelessFramebuffer = copy_src->imagelessFramebuffer; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkFramebufferAttachmentImageInfo::safe_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + usage(in_struct->usage), + width(in_struct->width), + height(in_struct->height), + layerCount(in_struct->layerCount), + viewFormatCount(in_struct->viewFormatCount), + pViewFormats(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pViewFormats) { + pViewFormats = new VkFormat[in_struct->viewFormatCount]; + memcpy((void*)pViewFormats, (void*)in_struct->pViewFormats, sizeof(VkFormat) * in_struct->viewFormatCount); + } +} + +safe_VkFramebufferAttachmentImageInfo::safe_VkFramebufferAttachmentImageInfo() + : sType(VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO), + pNext(nullptr), + flags(), + usage(), + width(), + height(), + layerCount(), + viewFormatCount(), + pViewFormats(nullptr) {} + +safe_VkFramebufferAttachmentImageInfo::safe_VkFramebufferAttachmentImageInfo( + const safe_VkFramebufferAttachmentImageInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + usage = copy_src.usage; + width = copy_src.width; + height = copy_src.height; + layerCount = copy_src.layerCount; + viewFormatCount = copy_src.viewFormatCount; + pViewFormats = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pViewFormats) { + pViewFormats = new VkFormat[copy_src.viewFormatCount]; + memcpy((void*)pViewFormats, (void*)copy_src.pViewFormats, sizeof(VkFormat) * copy_src.viewFormatCount); + } +} + +safe_VkFramebufferAttachmentImageInfo& safe_VkFramebufferAttachmentImageInfo::operator=( + const safe_VkFramebufferAttachmentImageInfo& copy_src) { + if (©_src == this) return *this; + + if (pViewFormats) delete[] pViewFormats; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + usage = copy_src.usage; + width = copy_src.width; + height = copy_src.height; + layerCount = copy_src.layerCount; + viewFormatCount = copy_src.viewFormatCount; + pViewFormats = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pViewFormats) { + pViewFormats = new VkFormat[copy_src.viewFormatCount]; + memcpy((void*)pViewFormats, (void*)copy_src.pViewFormats, sizeof(VkFormat) * copy_src.viewFormatCount); + } + + return *this; +} + +safe_VkFramebufferAttachmentImageInfo::~safe_VkFramebufferAttachmentImageInfo() { + if (pViewFormats) delete[] pViewFormats; + FreePnextChain(pNext); +} + +void safe_VkFramebufferAttachmentImageInfo::initialize(const VkFramebufferAttachmentImageInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pViewFormats) delete[] pViewFormats; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + usage = in_struct->usage; + width = in_struct->width; + height = in_struct->height; + layerCount = in_struct->layerCount; + viewFormatCount = in_struct->viewFormatCount; + pViewFormats = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pViewFormats) { + pViewFormats = new VkFormat[in_struct->viewFormatCount]; + memcpy((void*)pViewFormats, (void*)in_struct->pViewFormats, sizeof(VkFormat) * in_struct->viewFormatCount); + } +} + +void safe_VkFramebufferAttachmentImageInfo::initialize(const safe_VkFramebufferAttachmentImageInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + usage = copy_src->usage; + width = copy_src->width; + height = copy_src->height; + layerCount = copy_src->layerCount; + viewFormatCount = copy_src->viewFormatCount; + pViewFormats = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pViewFormats) { + pViewFormats = new VkFormat[copy_src->viewFormatCount]; + memcpy((void*)pViewFormats, (void*)copy_src->pViewFormats, sizeof(VkFormat) * copy_src->viewFormatCount); + } +} + +safe_VkFramebufferAttachmentsCreateInfo::safe_VkFramebufferAttachmentsCreateInfo( + const VkFramebufferAttachmentsCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), attachmentImageInfoCount(in_struct->attachmentImageInfoCount), pAttachmentImageInfos(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (attachmentImageInfoCount && in_struct->pAttachmentImageInfos) { + pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfo[attachmentImageInfoCount]; + for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) { + pAttachmentImageInfos[i].initialize(&in_struct->pAttachmentImageInfos[i]); + } + } +} + +safe_VkFramebufferAttachmentsCreateInfo::safe_VkFramebufferAttachmentsCreateInfo() + : sType(VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO), + pNext(nullptr), + attachmentImageInfoCount(), + pAttachmentImageInfos(nullptr) {} + +safe_VkFramebufferAttachmentsCreateInfo::safe_VkFramebufferAttachmentsCreateInfo( + const safe_VkFramebufferAttachmentsCreateInfo& copy_src) { + sType = copy_src.sType; + attachmentImageInfoCount = copy_src.attachmentImageInfoCount; + pAttachmentImageInfos = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (attachmentImageInfoCount && copy_src.pAttachmentImageInfos) { + pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfo[attachmentImageInfoCount]; + for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) { + pAttachmentImageInfos[i].initialize(©_src.pAttachmentImageInfos[i]); + } + } +} + +safe_VkFramebufferAttachmentsCreateInfo& safe_VkFramebufferAttachmentsCreateInfo::operator=( + const safe_VkFramebufferAttachmentsCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pAttachmentImageInfos) delete[] pAttachmentImageInfos; + FreePnextChain(pNext); + + sType = copy_src.sType; + attachmentImageInfoCount = copy_src.attachmentImageInfoCount; + pAttachmentImageInfos = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (attachmentImageInfoCount && copy_src.pAttachmentImageInfos) { + pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfo[attachmentImageInfoCount]; + for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) { + pAttachmentImageInfos[i].initialize(©_src.pAttachmentImageInfos[i]); + } + } + + return *this; +} + +safe_VkFramebufferAttachmentsCreateInfo::~safe_VkFramebufferAttachmentsCreateInfo() { + if (pAttachmentImageInfos) delete[] pAttachmentImageInfos; + FreePnextChain(pNext); +} + +void safe_VkFramebufferAttachmentsCreateInfo::initialize(const VkFramebufferAttachmentsCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pAttachmentImageInfos) delete[] pAttachmentImageInfos; + FreePnextChain(pNext); + sType = in_struct->sType; + attachmentImageInfoCount = in_struct->attachmentImageInfoCount; + pAttachmentImageInfos = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (attachmentImageInfoCount && in_struct->pAttachmentImageInfos) { + pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfo[attachmentImageInfoCount]; + for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) { + pAttachmentImageInfos[i].initialize(&in_struct->pAttachmentImageInfos[i]); + } + } +} + +void safe_VkFramebufferAttachmentsCreateInfo::initialize(const safe_VkFramebufferAttachmentsCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + attachmentImageInfoCount = copy_src->attachmentImageInfoCount; + pAttachmentImageInfos = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (attachmentImageInfoCount && copy_src->pAttachmentImageInfos) { + pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfo[attachmentImageInfoCount]; + for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) { + pAttachmentImageInfos[i].initialize(©_src->pAttachmentImageInfos[i]); + } + } +} + +safe_VkRenderPassAttachmentBeginInfo::safe_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), attachmentCount(in_struct->attachmentCount), pAttachments(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (attachmentCount && in_struct->pAttachments) { + pAttachments = new VkImageView[attachmentCount]; + for (uint32_t i = 0; i < attachmentCount; ++i) { + pAttachments[i] = in_struct->pAttachments[i]; + } + } +} + +safe_VkRenderPassAttachmentBeginInfo::safe_VkRenderPassAttachmentBeginInfo() + : sType(VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO), pNext(nullptr), attachmentCount(), pAttachments(nullptr) {} + +safe_VkRenderPassAttachmentBeginInfo::safe_VkRenderPassAttachmentBeginInfo(const safe_VkRenderPassAttachmentBeginInfo& copy_src) { + sType = copy_src.sType; + attachmentCount = copy_src.attachmentCount; + pAttachments = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (attachmentCount && copy_src.pAttachments) { + pAttachments = new VkImageView[attachmentCount]; + for (uint32_t i = 0; i < attachmentCount; ++i) { + pAttachments[i] = copy_src.pAttachments[i]; + } + } +} + +safe_VkRenderPassAttachmentBeginInfo& safe_VkRenderPassAttachmentBeginInfo::operator=( + const safe_VkRenderPassAttachmentBeginInfo& copy_src) { + if (©_src == this) return *this; + + if (pAttachments) delete[] pAttachments; + FreePnextChain(pNext); + + sType = copy_src.sType; + attachmentCount = copy_src.attachmentCount; + pAttachments = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (attachmentCount && copy_src.pAttachments) { + pAttachments = new VkImageView[attachmentCount]; + for (uint32_t i = 0; i < attachmentCount; ++i) { + pAttachments[i] = copy_src.pAttachments[i]; + } + } + + return *this; +} + +safe_VkRenderPassAttachmentBeginInfo::~safe_VkRenderPassAttachmentBeginInfo() { + if (pAttachments) delete[] pAttachments; + FreePnextChain(pNext); +} + +void safe_VkRenderPassAttachmentBeginInfo::initialize(const VkRenderPassAttachmentBeginInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pAttachments) delete[] pAttachments; + FreePnextChain(pNext); + sType = in_struct->sType; + attachmentCount = in_struct->attachmentCount; + pAttachments = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (attachmentCount && in_struct->pAttachments) { + pAttachments = new VkImageView[attachmentCount]; + for (uint32_t i = 0; i < attachmentCount; ++i) { + pAttachments[i] = in_struct->pAttachments[i]; + } + } +} + +void safe_VkRenderPassAttachmentBeginInfo::initialize(const safe_VkRenderPassAttachmentBeginInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + attachmentCount = copy_src->attachmentCount; + pAttachments = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (attachmentCount && copy_src->pAttachments) { + pAttachments = new VkImageView[attachmentCount]; + for (uint32_t i = 0; i < attachmentCount; ++i) { + pAttachments[i] = copy_src->pAttachments[i]; + } + } +} + +safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures( + const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), uniformBufferStandardLayout(in_struct->uniformBufferStandardLayout) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES), + pNext(nullptr), + uniformBufferStandardLayout() {} + +safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures( + const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& copy_src) { + sType = copy_src.sType; + uniformBufferStandardLayout = copy_src.uniformBufferStandardLayout; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::operator=( + const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + uniformBufferStandardLayout = copy_src.uniformBufferStandardLayout; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::~safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::initialize( + const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + uniformBufferStandardLayout = in_struct->uniformBufferStandardLayout; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::initialize( + const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + uniformBufferStandardLayout = copy_src->uniformBufferStandardLayout; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures( + const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), shaderSubgroupExtendedTypes(in_struct->shaderSubgroupExtendedTypes) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES), + pNext(nullptr), + shaderSubgroupExtendedTypes() {} + +safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures( + const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& copy_src) { + sType = copy_src.sType; + shaderSubgroupExtendedTypes = copy_src.shaderSubgroupExtendedTypes; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::operator=( + const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderSubgroupExtendedTypes = copy_src.shaderSubgroupExtendedTypes; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::~safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::initialize( + const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderSubgroupExtendedTypes = in_struct->shaderSubgroupExtendedTypes; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::initialize( + const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderSubgroupExtendedTypes = copy_src->shaderSubgroupExtendedTypes; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures( + const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), separateDepthStencilLayouts(in_struct->separateDepthStencilLayouts) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES), + pNext(nullptr), + separateDepthStencilLayouts() {} + +safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures( + const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& copy_src) { + sType = copy_src.sType; + separateDepthStencilLayouts = copy_src.separateDepthStencilLayouts; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::operator=( + const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + separateDepthStencilLayouts = copy_src.separateDepthStencilLayouts; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::~safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::initialize( + const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + separateDepthStencilLayouts = in_struct->separateDepthStencilLayouts; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::initialize( + const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + separateDepthStencilLayouts = copy_src->separateDepthStencilLayouts; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAttachmentReferenceStencilLayout::safe_VkAttachmentReferenceStencilLayout( + const VkAttachmentReferenceStencilLayout* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), stencilLayout(in_struct->stencilLayout) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAttachmentReferenceStencilLayout::safe_VkAttachmentReferenceStencilLayout() + : sType(VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT), pNext(nullptr), stencilLayout() {} + +safe_VkAttachmentReferenceStencilLayout::safe_VkAttachmentReferenceStencilLayout( + const safe_VkAttachmentReferenceStencilLayout& copy_src) { + sType = copy_src.sType; + stencilLayout = copy_src.stencilLayout; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAttachmentReferenceStencilLayout& safe_VkAttachmentReferenceStencilLayout::operator=( + const safe_VkAttachmentReferenceStencilLayout& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + stencilLayout = copy_src.stencilLayout; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAttachmentReferenceStencilLayout::~safe_VkAttachmentReferenceStencilLayout() { FreePnextChain(pNext); } + +void safe_VkAttachmentReferenceStencilLayout::initialize(const VkAttachmentReferenceStencilLayout* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + stencilLayout = in_struct->stencilLayout; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAttachmentReferenceStencilLayout::initialize(const safe_VkAttachmentReferenceStencilLayout* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stencilLayout = copy_src->stencilLayout; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAttachmentDescriptionStencilLayout::safe_VkAttachmentDescriptionStencilLayout( + const VkAttachmentDescriptionStencilLayout* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + stencilInitialLayout(in_struct->stencilInitialLayout), + stencilFinalLayout(in_struct->stencilFinalLayout) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAttachmentDescriptionStencilLayout::safe_VkAttachmentDescriptionStencilLayout() + : sType(VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT), + pNext(nullptr), + stencilInitialLayout(), + stencilFinalLayout() {} + +safe_VkAttachmentDescriptionStencilLayout::safe_VkAttachmentDescriptionStencilLayout( + const safe_VkAttachmentDescriptionStencilLayout& copy_src) { + sType = copy_src.sType; + stencilInitialLayout = copy_src.stencilInitialLayout; + stencilFinalLayout = copy_src.stencilFinalLayout; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAttachmentDescriptionStencilLayout& safe_VkAttachmentDescriptionStencilLayout::operator=( + const safe_VkAttachmentDescriptionStencilLayout& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + stencilInitialLayout = copy_src.stencilInitialLayout; + stencilFinalLayout = copy_src.stencilFinalLayout; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAttachmentDescriptionStencilLayout::~safe_VkAttachmentDescriptionStencilLayout() { FreePnextChain(pNext); } + +void safe_VkAttachmentDescriptionStencilLayout::initialize(const VkAttachmentDescriptionStencilLayout* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + stencilInitialLayout = in_struct->stencilInitialLayout; + stencilFinalLayout = in_struct->stencilFinalLayout; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAttachmentDescriptionStencilLayout::initialize(const safe_VkAttachmentDescriptionStencilLayout* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stencilInitialLayout = copy_src->stencilInitialLayout; + stencilFinalLayout = copy_src->stencilFinalLayout; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceHostQueryResetFeatures::safe_VkPhysicalDeviceHostQueryResetFeatures( + const VkPhysicalDeviceHostQueryResetFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), hostQueryReset(in_struct->hostQueryReset) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceHostQueryResetFeatures::safe_VkPhysicalDeviceHostQueryResetFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES), pNext(nullptr), hostQueryReset() {} + +safe_VkPhysicalDeviceHostQueryResetFeatures::safe_VkPhysicalDeviceHostQueryResetFeatures( + const safe_VkPhysicalDeviceHostQueryResetFeatures& copy_src) { + sType = copy_src.sType; + hostQueryReset = copy_src.hostQueryReset; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceHostQueryResetFeatures& safe_VkPhysicalDeviceHostQueryResetFeatures::operator=( + const safe_VkPhysicalDeviceHostQueryResetFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + hostQueryReset = copy_src.hostQueryReset; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceHostQueryResetFeatures::~safe_VkPhysicalDeviceHostQueryResetFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceHostQueryResetFeatures::initialize(const VkPhysicalDeviceHostQueryResetFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + hostQueryReset = in_struct->hostQueryReset; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceHostQueryResetFeatures::initialize(const safe_VkPhysicalDeviceHostQueryResetFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + hostQueryReset = copy_src->hostQueryReset; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceTimelineSemaphoreFeatures::safe_VkPhysicalDeviceTimelineSemaphoreFeatures( + const VkPhysicalDeviceTimelineSemaphoreFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), timelineSemaphore(in_struct->timelineSemaphore) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceTimelineSemaphoreFeatures::safe_VkPhysicalDeviceTimelineSemaphoreFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES), pNext(nullptr), timelineSemaphore() {} + +safe_VkPhysicalDeviceTimelineSemaphoreFeatures::safe_VkPhysicalDeviceTimelineSemaphoreFeatures( + const safe_VkPhysicalDeviceTimelineSemaphoreFeatures& copy_src) { + sType = copy_src.sType; + timelineSemaphore = copy_src.timelineSemaphore; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceTimelineSemaphoreFeatures& safe_VkPhysicalDeviceTimelineSemaphoreFeatures::operator=( + const safe_VkPhysicalDeviceTimelineSemaphoreFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + timelineSemaphore = copy_src.timelineSemaphore; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceTimelineSemaphoreFeatures::~safe_VkPhysicalDeviceTimelineSemaphoreFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceTimelineSemaphoreFeatures::initialize(const VkPhysicalDeviceTimelineSemaphoreFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + timelineSemaphore = in_struct->timelineSemaphore; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceTimelineSemaphoreFeatures::initialize(const safe_VkPhysicalDeviceTimelineSemaphoreFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + timelineSemaphore = copy_src->timelineSemaphore; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceTimelineSemaphoreProperties::safe_VkPhysicalDeviceTimelineSemaphoreProperties( + const VkPhysicalDeviceTimelineSemaphoreProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), maxTimelineSemaphoreValueDifference(in_struct->maxTimelineSemaphoreValueDifference) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceTimelineSemaphoreProperties::safe_VkPhysicalDeviceTimelineSemaphoreProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES), + pNext(nullptr), + maxTimelineSemaphoreValueDifference() {} + +safe_VkPhysicalDeviceTimelineSemaphoreProperties::safe_VkPhysicalDeviceTimelineSemaphoreProperties( + const safe_VkPhysicalDeviceTimelineSemaphoreProperties& copy_src) { + sType = copy_src.sType; + maxTimelineSemaphoreValueDifference = copy_src.maxTimelineSemaphoreValueDifference; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceTimelineSemaphoreProperties& safe_VkPhysicalDeviceTimelineSemaphoreProperties::operator=( + const safe_VkPhysicalDeviceTimelineSemaphoreProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxTimelineSemaphoreValueDifference = copy_src.maxTimelineSemaphoreValueDifference; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceTimelineSemaphoreProperties::~safe_VkPhysicalDeviceTimelineSemaphoreProperties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceTimelineSemaphoreProperties::initialize(const VkPhysicalDeviceTimelineSemaphoreProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxTimelineSemaphoreValueDifference = in_struct->maxTimelineSemaphoreValueDifference; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceTimelineSemaphoreProperties::initialize(const safe_VkPhysicalDeviceTimelineSemaphoreProperties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxTimelineSemaphoreValueDifference = copy_src->maxTimelineSemaphoreValueDifference; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSemaphoreTypeCreateInfo::safe_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), semaphoreType(in_struct->semaphoreType), initialValue(in_struct->initialValue) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSemaphoreTypeCreateInfo::safe_VkSemaphoreTypeCreateInfo() + : sType(VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO), pNext(nullptr), semaphoreType(), initialValue() {} + +safe_VkSemaphoreTypeCreateInfo::safe_VkSemaphoreTypeCreateInfo(const safe_VkSemaphoreTypeCreateInfo& copy_src) { + sType = copy_src.sType; + semaphoreType = copy_src.semaphoreType; + initialValue = copy_src.initialValue; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSemaphoreTypeCreateInfo& safe_VkSemaphoreTypeCreateInfo::operator=(const safe_VkSemaphoreTypeCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + semaphoreType = copy_src.semaphoreType; + initialValue = copy_src.initialValue; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSemaphoreTypeCreateInfo::~safe_VkSemaphoreTypeCreateInfo() { FreePnextChain(pNext); } + +void safe_VkSemaphoreTypeCreateInfo::initialize(const VkSemaphoreTypeCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + semaphoreType = in_struct->semaphoreType; + initialValue = in_struct->initialValue; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSemaphoreTypeCreateInfo::initialize(const safe_VkSemaphoreTypeCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + semaphoreType = copy_src->semaphoreType; + initialValue = copy_src->initialValue; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkTimelineSemaphoreSubmitInfo::safe_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + waitSemaphoreValueCount(in_struct->waitSemaphoreValueCount), + pWaitSemaphoreValues(nullptr), + signalSemaphoreValueCount(in_struct->signalSemaphoreValueCount), + pSignalSemaphoreValues(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pWaitSemaphoreValues) { + pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValueCount]; + memcpy((void*)pWaitSemaphoreValues, (void*)in_struct->pWaitSemaphoreValues, + sizeof(uint64_t) * in_struct->waitSemaphoreValueCount); + } + + if (in_struct->pSignalSemaphoreValues) { + pSignalSemaphoreValues = new uint64_t[in_struct->signalSemaphoreValueCount]; + memcpy((void*)pSignalSemaphoreValues, (void*)in_struct->pSignalSemaphoreValues, + sizeof(uint64_t) * in_struct->signalSemaphoreValueCount); + } +} + +safe_VkTimelineSemaphoreSubmitInfo::safe_VkTimelineSemaphoreSubmitInfo() + : sType(VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO), + pNext(nullptr), + waitSemaphoreValueCount(), + pWaitSemaphoreValues(nullptr), + signalSemaphoreValueCount(), + pSignalSemaphoreValues(nullptr) {} + +safe_VkTimelineSemaphoreSubmitInfo::safe_VkTimelineSemaphoreSubmitInfo(const safe_VkTimelineSemaphoreSubmitInfo& copy_src) { + sType = copy_src.sType; + waitSemaphoreValueCount = copy_src.waitSemaphoreValueCount; + pWaitSemaphoreValues = nullptr; + signalSemaphoreValueCount = copy_src.signalSemaphoreValueCount; + pSignalSemaphoreValues = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pWaitSemaphoreValues) { + pWaitSemaphoreValues = new uint64_t[copy_src.waitSemaphoreValueCount]; + memcpy((void*)pWaitSemaphoreValues, (void*)copy_src.pWaitSemaphoreValues, + sizeof(uint64_t) * copy_src.waitSemaphoreValueCount); + } + + if (copy_src.pSignalSemaphoreValues) { + pSignalSemaphoreValues = new uint64_t[copy_src.signalSemaphoreValueCount]; + memcpy((void*)pSignalSemaphoreValues, (void*)copy_src.pSignalSemaphoreValues, + sizeof(uint64_t) * copy_src.signalSemaphoreValueCount); + } +} + +safe_VkTimelineSemaphoreSubmitInfo& safe_VkTimelineSemaphoreSubmitInfo::operator=( + const safe_VkTimelineSemaphoreSubmitInfo& copy_src) { + if (©_src == this) return *this; + + if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues; + if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues; + FreePnextChain(pNext); + + sType = copy_src.sType; + waitSemaphoreValueCount = copy_src.waitSemaphoreValueCount; + pWaitSemaphoreValues = nullptr; + signalSemaphoreValueCount = copy_src.signalSemaphoreValueCount; + pSignalSemaphoreValues = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pWaitSemaphoreValues) { + pWaitSemaphoreValues = new uint64_t[copy_src.waitSemaphoreValueCount]; + memcpy((void*)pWaitSemaphoreValues, (void*)copy_src.pWaitSemaphoreValues, + sizeof(uint64_t) * copy_src.waitSemaphoreValueCount); + } + + if (copy_src.pSignalSemaphoreValues) { + pSignalSemaphoreValues = new uint64_t[copy_src.signalSemaphoreValueCount]; + memcpy((void*)pSignalSemaphoreValues, (void*)copy_src.pSignalSemaphoreValues, + sizeof(uint64_t) * copy_src.signalSemaphoreValueCount); + } + + return *this; +} + +safe_VkTimelineSemaphoreSubmitInfo::~safe_VkTimelineSemaphoreSubmitInfo() { + if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues; + if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues; + FreePnextChain(pNext); +} + +void safe_VkTimelineSemaphoreSubmitInfo::initialize(const VkTimelineSemaphoreSubmitInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues; + if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues; + FreePnextChain(pNext); + sType = in_struct->sType; + waitSemaphoreValueCount = in_struct->waitSemaphoreValueCount; + pWaitSemaphoreValues = nullptr; + signalSemaphoreValueCount = in_struct->signalSemaphoreValueCount; + pSignalSemaphoreValues = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pWaitSemaphoreValues) { + pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValueCount]; + memcpy((void*)pWaitSemaphoreValues, (void*)in_struct->pWaitSemaphoreValues, + sizeof(uint64_t) * in_struct->waitSemaphoreValueCount); + } + + if (in_struct->pSignalSemaphoreValues) { + pSignalSemaphoreValues = new uint64_t[in_struct->signalSemaphoreValueCount]; + memcpy((void*)pSignalSemaphoreValues, (void*)in_struct->pSignalSemaphoreValues, + sizeof(uint64_t) * in_struct->signalSemaphoreValueCount); + } +} + +void safe_VkTimelineSemaphoreSubmitInfo::initialize(const safe_VkTimelineSemaphoreSubmitInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + waitSemaphoreValueCount = copy_src->waitSemaphoreValueCount; + pWaitSemaphoreValues = nullptr; + signalSemaphoreValueCount = copy_src->signalSemaphoreValueCount; + pSignalSemaphoreValues = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pWaitSemaphoreValues) { + pWaitSemaphoreValues = new uint64_t[copy_src->waitSemaphoreValueCount]; + memcpy((void*)pWaitSemaphoreValues, (void*)copy_src->pWaitSemaphoreValues, + sizeof(uint64_t) * copy_src->waitSemaphoreValueCount); + } + + if (copy_src->pSignalSemaphoreValues) { + pSignalSemaphoreValues = new uint64_t[copy_src->signalSemaphoreValueCount]; + memcpy((void*)pSignalSemaphoreValues, (void*)copy_src->pSignalSemaphoreValues, + sizeof(uint64_t) * copy_src->signalSemaphoreValueCount); + } +} + +safe_VkSemaphoreWaitInfo::safe_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + semaphoreCount(in_struct->semaphoreCount), + pSemaphores(nullptr), + pValues(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (semaphoreCount && in_struct->pSemaphores) { + pSemaphores = new VkSemaphore[semaphoreCount]; + for (uint32_t i = 0; i < semaphoreCount; ++i) { + pSemaphores[i] = in_struct->pSemaphores[i]; + } + } + + if (in_struct->pValues) { + pValues = new uint64_t[in_struct->semaphoreCount]; + memcpy((void*)pValues, (void*)in_struct->pValues, sizeof(uint64_t) * in_struct->semaphoreCount); + } +} + +safe_VkSemaphoreWaitInfo::safe_VkSemaphoreWaitInfo() + : sType(VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO), + pNext(nullptr), + flags(), + semaphoreCount(), + pSemaphores(nullptr), + pValues(nullptr) {} + +safe_VkSemaphoreWaitInfo::safe_VkSemaphoreWaitInfo(const safe_VkSemaphoreWaitInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + semaphoreCount = copy_src.semaphoreCount; + pSemaphores = nullptr; + pValues = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (semaphoreCount && copy_src.pSemaphores) { + pSemaphores = new VkSemaphore[semaphoreCount]; + for (uint32_t i = 0; i < semaphoreCount; ++i) { + pSemaphores[i] = copy_src.pSemaphores[i]; + } + } + + if (copy_src.pValues) { + pValues = new uint64_t[copy_src.semaphoreCount]; + memcpy((void*)pValues, (void*)copy_src.pValues, sizeof(uint64_t) * copy_src.semaphoreCount); + } +} + +safe_VkSemaphoreWaitInfo& safe_VkSemaphoreWaitInfo::operator=(const safe_VkSemaphoreWaitInfo& copy_src) { + if (©_src == this) return *this; + + if (pSemaphores) delete[] pSemaphores; + if (pValues) delete[] pValues; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + semaphoreCount = copy_src.semaphoreCount; + pSemaphores = nullptr; + pValues = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (semaphoreCount && copy_src.pSemaphores) { + pSemaphores = new VkSemaphore[semaphoreCount]; + for (uint32_t i = 0; i < semaphoreCount; ++i) { + pSemaphores[i] = copy_src.pSemaphores[i]; + } + } + + if (copy_src.pValues) { + pValues = new uint64_t[copy_src.semaphoreCount]; + memcpy((void*)pValues, (void*)copy_src.pValues, sizeof(uint64_t) * copy_src.semaphoreCount); + } + + return *this; +} + +safe_VkSemaphoreWaitInfo::~safe_VkSemaphoreWaitInfo() { + if (pSemaphores) delete[] pSemaphores; + if (pValues) delete[] pValues; + FreePnextChain(pNext); +} + +void safe_VkSemaphoreWaitInfo::initialize(const VkSemaphoreWaitInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pSemaphores) delete[] pSemaphores; + if (pValues) delete[] pValues; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + semaphoreCount = in_struct->semaphoreCount; + pSemaphores = nullptr; + pValues = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (semaphoreCount && in_struct->pSemaphores) { + pSemaphores = new VkSemaphore[semaphoreCount]; + for (uint32_t i = 0; i < semaphoreCount; ++i) { + pSemaphores[i] = in_struct->pSemaphores[i]; + } + } + + if (in_struct->pValues) { + pValues = new uint64_t[in_struct->semaphoreCount]; + memcpy((void*)pValues, (void*)in_struct->pValues, sizeof(uint64_t) * in_struct->semaphoreCount); + } +} + +void safe_VkSemaphoreWaitInfo::initialize(const safe_VkSemaphoreWaitInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + semaphoreCount = copy_src->semaphoreCount; + pSemaphores = nullptr; + pValues = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (semaphoreCount && copy_src->pSemaphores) { + pSemaphores = new VkSemaphore[semaphoreCount]; + for (uint32_t i = 0; i < semaphoreCount; ++i) { + pSemaphores[i] = copy_src->pSemaphores[i]; + } + } + + if (copy_src->pValues) { + pValues = new uint64_t[copy_src->semaphoreCount]; + memcpy((void*)pValues, (void*)copy_src->pValues, sizeof(uint64_t) * copy_src->semaphoreCount); + } +} + +safe_VkSemaphoreSignalInfo::safe_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), semaphore(in_struct->semaphore), value(in_struct->value) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSemaphoreSignalInfo::safe_VkSemaphoreSignalInfo() + : sType(VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO), pNext(nullptr), semaphore(), value() {} + +safe_VkSemaphoreSignalInfo::safe_VkSemaphoreSignalInfo(const safe_VkSemaphoreSignalInfo& copy_src) { + sType = copy_src.sType; + semaphore = copy_src.semaphore; + value = copy_src.value; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSemaphoreSignalInfo& safe_VkSemaphoreSignalInfo::operator=(const safe_VkSemaphoreSignalInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + semaphore = copy_src.semaphore; + value = copy_src.value; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSemaphoreSignalInfo::~safe_VkSemaphoreSignalInfo() { FreePnextChain(pNext); } + +void safe_VkSemaphoreSignalInfo::initialize(const VkSemaphoreSignalInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + semaphore = in_struct->semaphore; + value = in_struct->value; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSemaphoreSignalInfo::initialize(const safe_VkSemaphoreSignalInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + semaphore = copy_src->semaphore; + value = copy_src->value; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceBufferDeviceAddressFeatures::safe_VkPhysicalDeviceBufferDeviceAddressFeatures( + const VkPhysicalDeviceBufferDeviceAddressFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + bufferDeviceAddress(in_struct->bufferDeviceAddress), + bufferDeviceAddressCaptureReplay(in_struct->bufferDeviceAddressCaptureReplay), + bufferDeviceAddressMultiDevice(in_struct->bufferDeviceAddressMultiDevice) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceBufferDeviceAddressFeatures::safe_VkPhysicalDeviceBufferDeviceAddressFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES), + pNext(nullptr), + bufferDeviceAddress(), + bufferDeviceAddressCaptureReplay(), + bufferDeviceAddressMultiDevice() {} + +safe_VkPhysicalDeviceBufferDeviceAddressFeatures::safe_VkPhysicalDeviceBufferDeviceAddressFeatures( + const safe_VkPhysicalDeviceBufferDeviceAddressFeatures& copy_src) { + sType = copy_src.sType; + bufferDeviceAddress = copy_src.bufferDeviceAddress; + bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay; + bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceBufferDeviceAddressFeatures& safe_VkPhysicalDeviceBufferDeviceAddressFeatures::operator=( + const safe_VkPhysicalDeviceBufferDeviceAddressFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + bufferDeviceAddress = copy_src.bufferDeviceAddress; + bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay; + bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceBufferDeviceAddressFeatures::~safe_VkPhysicalDeviceBufferDeviceAddressFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceBufferDeviceAddressFeatures::initialize(const VkPhysicalDeviceBufferDeviceAddressFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + bufferDeviceAddress = in_struct->bufferDeviceAddress; + bufferDeviceAddressCaptureReplay = in_struct->bufferDeviceAddressCaptureReplay; + bufferDeviceAddressMultiDevice = in_struct->bufferDeviceAddressMultiDevice; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceBufferDeviceAddressFeatures::initialize(const safe_VkPhysicalDeviceBufferDeviceAddressFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + bufferDeviceAddress = copy_src->bufferDeviceAddress; + bufferDeviceAddressCaptureReplay = copy_src->bufferDeviceAddressCaptureReplay; + bufferDeviceAddressMultiDevice = copy_src->bufferDeviceAddressMultiDevice; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBufferDeviceAddressInfo::safe_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), buffer(in_struct->buffer) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBufferDeviceAddressInfo::safe_VkBufferDeviceAddressInfo() + : sType(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO), pNext(nullptr), buffer() {} + +safe_VkBufferDeviceAddressInfo::safe_VkBufferDeviceAddressInfo(const safe_VkBufferDeviceAddressInfo& copy_src) { + sType = copy_src.sType; + buffer = copy_src.buffer; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBufferDeviceAddressInfo& safe_VkBufferDeviceAddressInfo::operator=(const safe_VkBufferDeviceAddressInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + buffer = copy_src.buffer; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBufferDeviceAddressInfo::~safe_VkBufferDeviceAddressInfo() { FreePnextChain(pNext); } + +void safe_VkBufferDeviceAddressInfo::initialize(const VkBufferDeviceAddressInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + buffer = in_struct->buffer; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBufferDeviceAddressInfo::initialize(const safe_VkBufferDeviceAddressInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + buffer = copy_src->buffer; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBufferOpaqueCaptureAddressCreateInfo::safe_VkBufferOpaqueCaptureAddressCreateInfo( + const VkBufferOpaqueCaptureAddressCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), opaqueCaptureAddress(in_struct->opaqueCaptureAddress) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBufferOpaqueCaptureAddressCreateInfo::safe_VkBufferOpaqueCaptureAddressCreateInfo() + : sType(VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO), pNext(nullptr), opaqueCaptureAddress() {} + +safe_VkBufferOpaqueCaptureAddressCreateInfo::safe_VkBufferOpaqueCaptureAddressCreateInfo( + const safe_VkBufferOpaqueCaptureAddressCreateInfo& copy_src) { + sType = copy_src.sType; + opaqueCaptureAddress = copy_src.opaqueCaptureAddress; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBufferOpaqueCaptureAddressCreateInfo& safe_VkBufferOpaqueCaptureAddressCreateInfo::operator=( + const safe_VkBufferOpaqueCaptureAddressCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + opaqueCaptureAddress = copy_src.opaqueCaptureAddress; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBufferOpaqueCaptureAddressCreateInfo::~safe_VkBufferOpaqueCaptureAddressCreateInfo() { FreePnextChain(pNext); } + +void safe_VkBufferOpaqueCaptureAddressCreateInfo::initialize(const VkBufferOpaqueCaptureAddressCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + opaqueCaptureAddress = in_struct->opaqueCaptureAddress; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBufferOpaqueCaptureAddressCreateInfo::initialize(const safe_VkBufferOpaqueCaptureAddressCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + opaqueCaptureAddress = copy_src->opaqueCaptureAddress; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMemoryOpaqueCaptureAddressAllocateInfo::safe_VkMemoryOpaqueCaptureAddressAllocateInfo( + const VkMemoryOpaqueCaptureAddressAllocateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), opaqueCaptureAddress(in_struct->opaqueCaptureAddress) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMemoryOpaqueCaptureAddressAllocateInfo::safe_VkMemoryOpaqueCaptureAddressAllocateInfo() + : sType(VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO), pNext(nullptr), opaqueCaptureAddress() {} + +safe_VkMemoryOpaqueCaptureAddressAllocateInfo::safe_VkMemoryOpaqueCaptureAddressAllocateInfo( + const safe_VkMemoryOpaqueCaptureAddressAllocateInfo& copy_src) { + sType = copy_src.sType; + opaqueCaptureAddress = copy_src.opaqueCaptureAddress; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryOpaqueCaptureAddressAllocateInfo& safe_VkMemoryOpaqueCaptureAddressAllocateInfo::operator=( + const safe_VkMemoryOpaqueCaptureAddressAllocateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + opaqueCaptureAddress = copy_src.opaqueCaptureAddress; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryOpaqueCaptureAddressAllocateInfo::~safe_VkMemoryOpaqueCaptureAddressAllocateInfo() { FreePnextChain(pNext); } + +void safe_VkMemoryOpaqueCaptureAddressAllocateInfo::initialize(const VkMemoryOpaqueCaptureAddressAllocateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + opaqueCaptureAddress = in_struct->opaqueCaptureAddress; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryOpaqueCaptureAddressAllocateInfo::initialize(const safe_VkMemoryOpaqueCaptureAddressAllocateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + opaqueCaptureAddress = copy_src->opaqueCaptureAddress; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDeviceMemoryOpaqueCaptureAddressInfo::safe_VkDeviceMemoryOpaqueCaptureAddressInfo( + const VkDeviceMemoryOpaqueCaptureAddressInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), memory(in_struct->memory) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDeviceMemoryOpaqueCaptureAddressInfo::safe_VkDeviceMemoryOpaqueCaptureAddressInfo() + : sType(VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO), pNext(nullptr), memory() {} + +safe_VkDeviceMemoryOpaqueCaptureAddressInfo::safe_VkDeviceMemoryOpaqueCaptureAddressInfo( + const safe_VkDeviceMemoryOpaqueCaptureAddressInfo& copy_src) { + sType = copy_src.sType; + memory = copy_src.memory; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDeviceMemoryOpaqueCaptureAddressInfo& safe_VkDeviceMemoryOpaqueCaptureAddressInfo::operator=( + const safe_VkDeviceMemoryOpaqueCaptureAddressInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memory = copy_src.memory; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDeviceMemoryOpaqueCaptureAddressInfo::~safe_VkDeviceMemoryOpaqueCaptureAddressInfo() { FreePnextChain(pNext); } + +void safe_VkDeviceMemoryOpaqueCaptureAddressInfo::initialize(const VkDeviceMemoryOpaqueCaptureAddressInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memory = in_struct->memory; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDeviceMemoryOpaqueCaptureAddressInfo::initialize(const safe_VkDeviceMemoryOpaqueCaptureAddressInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memory = copy_src->memory; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceVulkan13Features::safe_VkPhysicalDeviceVulkan13Features(const VkPhysicalDeviceVulkan13Features* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + robustImageAccess(in_struct->robustImageAccess), + inlineUniformBlock(in_struct->inlineUniformBlock), + descriptorBindingInlineUniformBlockUpdateAfterBind(in_struct->descriptorBindingInlineUniformBlockUpdateAfterBind), + pipelineCreationCacheControl(in_struct->pipelineCreationCacheControl), + privateData(in_struct->privateData), + shaderDemoteToHelperInvocation(in_struct->shaderDemoteToHelperInvocation), + shaderTerminateInvocation(in_struct->shaderTerminateInvocation), + subgroupSizeControl(in_struct->subgroupSizeControl), + computeFullSubgroups(in_struct->computeFullSubgroups), + synchronization2(in_struct->synchronization2), + textureCompressionASTC_HDR(in_struct->textureCompressionASTC_HDR), + shaderZeroInitializeWorkgroupMemory(in_struct->shaderZeroInitializeWorkgroupMemory), + dynamicRendering(in_struct->dynamicRendering), + shaderIntegerDotProduct(in_struct->shaderIntegerDotProduct), + maintenance4(in_struct->maintenance4) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceVulkan13Features::safe_VkPhysicalDeviceVulkan13Features() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES), + pNext(nullptr), + robustImageAccess(), + inlineUniformBlock(), + descriptorBindingInlineUniformBlockUpdateAfterBind(), + pipelineCreationCacheControl(), + privateData(), + shaderDemoteToHelperInvocation(), + shaderTerminateInvocation(), + subgroupSizeControl(), + computeFullSubgroups(), + synchronization2(), + textureCompressionASTC_HDR(), + shaderZeroInitializeWorkgroupMemory(), + dynamicRendering(), + shaderIntegerDotProduct(), + maintenance4() {} + +safe_VkPhysicalDeviceVulkan13Features::safe_VkPhysicalDeviceVulkan13Features( + const safe_VkPhysicalDeviceVulkan13Features& copy_src) { + sType = copy_src.sType; + robustImageAccess = copy_src.robustImageAccess; + inlineUniformBlock = copy_src.inlineUniformBlock; + descriptorBindingInlineUniformBlockUpdateAfterBind = copy_src.descriptorBindingInlineUniformBlockUpdateAfterBind; + pipelineCreationCacheControl = copy_src.pipelineCreationCacheControl; + privateData = copy_src.privateData; + shaderDemoteToHelperInvocation = copy_src.shaderDemoteToHelperInvocation; + shaderTerminateInvocation = copy_src.shaderTerminateInvocation; + subgroupSizeControl = copy_src.subgroupSizeControl; + computeFullSubgroups = copy_src.computeFullSubgroups; + synchronization2 = copy_src.synchronization2; + textureCompressionASTC_HDR = copy_src.textureCompressionASTC_HDR; + shaderZeroInitializeWorkgroupMemory = copy_src.shaderZeroInitializeWorkgroupMemory; + dynamicRendering = copy_src.dynamicRendering; + shaderIntegerDotProduct = copy_src.shaderIntegerDotProduct; + maintenance4 = copy_src.maintenance4; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceVulkan13Features& safe_VkPhysicalDeviceVulkan13Features::operator=( + const safe_VkPhysicalDeviceVulkan13Features& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + robustImageAccess = copy_src.robustImageAccess; + inlineUniformBlock = copy_src.inlineUniformBlock; + descriptorBindingInlineUniformBlockUpdateAfterBind = copy_src.descriptorBindingInlineUniformBlockUpdateAfterBind; + pipelineCreationCacheControl = copy_src.pipelineCreationCacheControl; + privateData = copy_src.privateData; + shaderDemoteToHelperInvocation = copy_src.shaderDemoteToHelperInvocation; + shaderTerminateInvocation = copy_src.shaderTerminateInvocation; + subgroupSizeControl = copy_src.subgroupSizeControl; + computeFullSubgroups = copy_src.computeFullSubgroups; + synchronization2 = copy_src.synchronization2; + textureCompressionASTC_HDR = copy_src.textureCompressionASTC_HDR; + shaderZeroInitializeWorkgroupMemory = copy_src.shaderZeroInitializeWorkgroupMemory; + dynamicRendering = copy_src.dynamicRendering; + shaderIntegerDotProduct = copy_src.shaderIntegerDotProduct; + maintenance4 = copy_src.maintenance4; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceVulkan13Features::~safe_VkPhysicalDeviceVulkan13Features() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceVulkan13Features::initialize(const VkPhysicalDeviceVulkan13Features* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + robustImageAccess = in_struct->robustImageAccess; + inlineUniformBlock = in_struct->inlineUniformBlock; + descriptorBindingInlineUniformBlockUpdateAfterBind = in_struct->descriptorBindingInlineUniformBlockUpdateAfterBind; + pipelineCreationCacheControl = in_struct->pipelineCreationCacheControl; + privateData = in_struct->privateData; + shaderDemoteToHelperInvocation = in_struct->shaderDemoteToHelperInvocation; + shaderTerminateInvocation = in_struct->shaderTerminateInvocation; + subgroupSizeControl = in_struct->subgroupSizeControl; + computeFullSubgroups = in_struct->computeFullSubgroups; + synchronization2 = in_struct->synchronization2; + textureCompressionASTC_HDR = in_struct->textureCompressionASTC_HDR; + shaderZeroInitializeWorkgroupMemory = in_struct->shaderZeroInitializeWorkgroupMemory; + dynamicRendering = in_struct->dynamicRendering; + shaderIntegerDotProduct = in_struct->shaderIntegerDotProduct; + maintenance4 = in_struct->maintenance4; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceVulkan13Features::initialize(const safe_VkPhysicalDeviceVulkan13Features* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + robustImageAccess = copy_src->robustImageAccess; + inlineUniformBlock = copy_src->inlineUniformBlock; + descriptorBindingInlineUniformBlockUpdateAfterBind = copy_src->descriptorBindingInlineUniformBlockUpdateAfterBind; + pipelineCreationCacheControl = copy_src->pipelineCreationCacheControl; + privateData = copy_src->privateData; + shaderDemoteToHelperInvocation = copy_src->shaderDemoteToHelperInvocation; + shaderTerminateInvocation = copy_src->shaderTerminateInvocation; + subgroupSizeControl = copy_src->subgroupSizeControl; + computeFullSubgroups = copy_src->computeFullSubgroups; + synchronization2 = copy_src->synchronization2; + textureCompressionASTC_HDR = copy_src->textureCompressionASTC_HDR; + shaderZeroInitializeWorkgroupMemory = copy_src->shaderZeroInitializeWorkgroupMemory; + dynamicRendering = copy_src->dynamicRendering; + shaderIntegerDotProduct = copy_src->shaderIntegerDotProduct; + maintenance4 = copy_src->maintenance4; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceVulkan13Properties::safe_VkPhysicalDeviceVulkan13Properties( + const VkPhysicalDeviceVulkan13Properties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + minSubgroupSize(in_struct->minSubgroupSize), + maxSubgroupSize(in_struct->maxSubgroupSize), + maxComputeWorkgroupSubgroups(in_struct->maxComputeWorkgroupSubgroups), + requiredSubgroupSizeStages(in_struct->requiredSubgroupSizeStages), + maxInlineUniformBlockSize(in_struct->maxInlineUniformBlockSize), + maxPerStageDescriptorInlineUniformBlocks(in_struct->maxPerStageDescriptorInlineUniformBlocks), + maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks(in_struct->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks), + maxDescriptorSetInlineUniformBlocks(in_struct->maxDescriptorSetInlineUniformBlocks), + maxDescriptorSetUpdateAfterBindInlineUniformBlocks(in_struct->maxDescriptorSetUpdateAfterBindInlineUniformBlocks), + maxInlineUniformTotalSize(in_struct->maxInlineUniformTotalSize), + integerDotProduct8BitUnsignedAccelerated(in_struct->integerDotProduct8BitUnsignedAccelerated), + integerDotProduct8BitSignedAccelerated(in_struct->integerDotProduct8BitSignedAccelerated), + integerDotProduct8BitMixedSignednessAccelerated(in_struct->integerDotProduct8BitMixedSignednessAccelerated), + integerDotProduct4x8BitPackedUnsignedAccelerated(in_struct->integerDotProduct4x8BitPackedUnsignedAccelerated), + integerDotProduct4x8BitPackedSignedAccelerated(in_struct->integerDotProduct4x8BitPackedSignedAccelerated), + integerDotProduct4x8BitPackedMixedSignednessAccelerated(in_struct->integerDotProduct4x8BitPackedMixedSignednessAccelerated), + integerDotProduct16BitUnsignedAccelerated(in_struct->integerDotProduct16BitUnsignedAccelerated), + integerDotProduct16BitSignedAccelerated(in_struct->integerDotProduct16BitSignedAccelerated), + integerDotProduct16BitMixedSignednessAccelerated(in_struct->integerDotProduct16BitMixedSignednessAccelerated), + integerDotProduct32BitUnsignedAccelerated(in_struct->integerDotProduct32BitUnsignedAccelerated), + integerDotProduct32BitSignedAccelerated(in_struct->integerDotProduct32BitSignedAccelerated), + integerDotProduct32BitMixedSignednessAccelerated(in_struct->integerDotProduct32BitMixedSignednessAccelerated), + integerDotProduct64BitUnsignedAccelerated(in_struct->integerDotProduct64BitUnsignedAccelerated), + integerDotProduct64BitSignedAccelerated(in_struct->integerDotProduct64BitSignedAccelerated), + integerDotProduct64BitMixedSignednessAccelerated(in_struct->integerDotProduct64BitMixedSignednessAccelerated), + integerDotProductAccumulatingSaturating8BitUnsignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated), + integerDotProductAccumulatingSaturating8BitSignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating8BitSignedAccelerated), + integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated( + in_struct->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated), + integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated), + integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated), + integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated( + in_struct->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated), + integerDotProductAccumulatingSaturating16BitUnsignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated), + integerDotProductAccumulatingSaturating16BitSignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating16BitSignedAccelerated), + integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated( + in_struct->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated), + integerDotProductAccumulatingSaturating32BitUnsignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated), + integerDotProductAccumulatingSaturating32BitSignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating32BitSignedAccelerated), + integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated( + in_struct->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated), + integerDotProductAccumulatingSaturating64BitUnsignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated), + integerDotProductAccumulatingSaturating64BitSignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating64BitSignedAccelerated), + integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated( + in_struct->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated), + storageTexelBufferOffsetAlignmentBytes(in_struct->storageTexelBufferOffsetAlignmentBytes), + storageTexelBufferOffsetSingleTexelAlignment(in_struct->storageTexelBufferOffsetSingleTexelAlignment), + uniformTexelBufferOffsetAlignmentBytes(in_struct->uniformTexelBufferOffsetAlignmentBytes), + uniformTexelBufferOffsetSingleTexelAlignment(in_struct->uniformTexelBufferOffsetSingleTexelAlignment), + maxBufferSize(in_struct->maxBufferSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceVulkan13Properties::safe_VkPhysicalDeviceVulkan13Properties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES), + pNext(nullptr), + minSubgroupSize(), + maxSubgroupSize(), + maxComputeWorkgroupSubgroups(), + requiredSubgroupSizeStages(), + maxInlineUniformBlockSize(), + maxPerStageDescriptorInlineUniformBlocks(), + maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks(), + maxDescriptorSetInlineUniformBlocks(), + maxDescriptorSetUpdateAfterBindInlineUniformBlocks(), + maxInlineUniformTotalSize(), + integerDotProduct8BitUnsignedAccelerated(), + integerDotProduct8BitSignedAccelerated(), + integerDotProduct8BitMixedSignednessAccelerated(), + integerDotProduct4x8BitPackedUnsignedAccelerated(), + integerDotProduct4x8BitPackedSignedAccelerated(), + integerDotProduct4x8BitPackedMixedSignednessAccelerated(), + integerDotProduct16BitUnsignedAccelerated(), + integerDotProduct16BitSignedAccelerated(), + integerDotProduct16BitMixedSignednessAccelerated(), + integerDotProduct32BitUnsignedAccelerated(), + integerDotProduct32BitSignedAccelerated(), + integerDotProduct32BitMixedSignednessAccelerated(), + integerDotProduct64BitUnsignedAccelerated(), + integerDotProduct64BitSignedAccelerated(), + integerDotProduct64BitMixedSignednessAccelerated(), + integerDotProductAccumulatingSaturating8BitUnsignedAccelerated(), + integerDotProductAccumulatingSaturating8BitSignedAccelerated(), + integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated(), + integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated(), + integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated(), + integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated(), + integerDotProductAccumulatingSaturating16BitUnsignedAccelerated(), + integerDotProductAccumulatingSaturating16BitSignedAccelerated(), + integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated(), + integerDotProductAccumulatingSaturating32BitUnsignedAccelerated(), + integerDotProductAccumulatingSaturating32BitSignedAccelerated(), + integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated(), + integerDotProductAccumulatingSaturating64BitUnsignedAccelerated(), + integerDotProductAccumulatingSaturating64BitSignedAccelerated(), + integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated(), + storageTexelBufferOffsetAlignmentBytes(), + storageTexelBufferOffsetSingleTexelAlignment(), + uniformTexelBufferOffsetAlignmentBytes(), + uniformTexelBufferOffsetSingleTexelAlignment(), + maxBufferSize() {} + +safe_VkPhysicalDeviceVulkan13Properties::safe_VkPhysicalDeviceVulkan13Properties( + const safe_VkPhysicalDeviceVulkan13Properties& copy_src) { + sType = copy_src.sType; + minSubgroupSize = copy_src.minSubgroupSize; + maxSubgroupSize = copy_src.maxSubgroupSize; + maxComputeWorkgroupSubgroups = copy_src.maxComputeWorkgroupSubgroups; + requiredSubgroupSizeStages = copy_src.requiredSubgroupSizeStages; + maxInlineUniformBlockSize = copy_src.maxInlineUniformBlockSize; + maxPerStageDescriptorInlineUniformBlocks = copy_src.maxPerStageDescriptorInlineUniformBlocks; + maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = copy_src.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + maxDescriptorSetInlineUniformBlocks = copy_src.maxDescriptorSetInlineUniformBlocks; + maxDescriptorSetUpdateAfterBindInlineUniformBlocks = copy_src.maxDescriptorSetUpdateAfterBindInlineUniformBlocks; + maxInlineUniformTotalSize = copy_src.maxInlineUniformTotalSize; + integerDotProduct8BitUnsignedAccelerated = copy_src.integerDotProduct8BitUnsignedAccelerated; + integerDotProduct8BitSignedAccelerated = copy_src.integerDotProduct8BitSignedAccelerated; + integerDotProduct8BitMixedSignednessAccelerated = copy_src.integerDotProduct8BitMixedSignednessAccelerated; + integerDotProduct4x8BitPackedUnsignedAccelerated = copy_src.integerDotProduct4x8BitPackedUnsignedAccelerated; + integerDotProduct4x8BitPackedSignedAccelerated = copy_src.integerDotProduct4x8BitPackedSignedAccelerated; + integerDotProduct4x8BitPackedMixedSignednessAccelerated = copy_src.integerDotProduct4x8BitPackedMixedSignednessAccelerated; + integerDotProduct16BitUnsignedAccelerated = copy_src.integerDotProduct16BitUnsignedAccelerated; + integerDotProduct16BitSignedAccelerated = copy_src.integerDotProduct16BitSignedAccelerated; + integerDotProduct16BitMixedSignednessAccelerated = copy_src.integerDotProduct16BitMixedSignednessAccelerated; + integerDotProduct32BitUnsignedAccelerated = copy_src.integerDotProduct32BitUnsignedAccelerated; + integerDotProduct32BitSignedAccelerated = copy_src.integerDotProduct32BitSignedAccelerated; + integerDotProduct32BitMixedSignednessAccelerated = copy_src.integerDotProduct32BitMixedSignednessAccelerated; + integerDotProduct64BitUnsignedAccelerated = copy_src.integerDotProduct64BitUnsignedAccelerated; + integerDotProduct64BitSignedAccelerated = copy_src.integerDotProduct64BitSignedAccelerated; + integerDotProduct64BitMixedSignednessAccelerated = copy_src.integerDotProduct64BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating8BitSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating8BitSignedAccelerated; + integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating16BitSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating16BitSignedAccelerated; + integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating32BitSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating32BitSignedAccelerated; + integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating64BitSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating64BitSignedAccelerated; + integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; + storageTexelBufferOffsetAlignmentBytes = copy_src.storageTexelBufferOffsetAlignmentBytes; + storageTexelBufferOffsetSingleTexelAlignment = copy_src.storageTexelBufferOffsetSingleTexelAlignment; + uniformTexelBufferOffsetAlignmentBytes = copy_src.uniformTexelBufferOffsetAlignmentBytes; + uniformTexelBufferOffsetSingleTexelAlignment = copy_src.uniformTexelBufferOffsetSingleTexelAlignment; + maxBufferSize = copy_src.maxBufferSize; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceVulkan13Properties& safe_VkPhysicalDeviceVulkan13Properties::operator=( + const safe_VkPhysicalDeviceVulkan13Properties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + minSubgroupSize = copy_src.minSubgroupSize; + maxSubgroupSize = copy_src.maxSubgroupSize; + maxComputeWorkgroupSubgroups = copy_src.maxComputeWorkgroupSubgroups; + requiredSubgroupSizeStages = copy_src.requiredSubgroupSizeStages; + maxInlineUniformBlockSize = copy_src.maxInlineUniformBlockSize; + maxPerStageDescriptorInlineUniformBlocks = copy_src.maxPerStageDescriptorInlineUniformBlocks; + maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = copy_src.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + maxDescriptorSetInlineUniformBlocks = copy_src.maxDescriptorSetInlineUniformBlocks; + maxDescriptorSetUpdateAfterBindInlineUniformBlocks = copy_src.maxDescriptorSetUpdateAfterBindInlineUniformBlocks; + maxInlineUniformTotalSize = copy_src.maxInlineUniformTotalSize; + integerDotProduct8BitUnsignedAccelerated = copy_src.integerDotProduct8BitUnsignedAccelerated; + integerDotProduct8BitSignedAccelerated = copy_src.integerDotProduct8BitSignedAccelerated; + integerDotProduct8BitMixedSignednessAccelerated = copy_src.integerDotProduct8BitMixedSignednessAccelerated; + integerDotProduct4x8BitPackedUnsignedAccelerated = copy_src.integerDotProduct4x8BitPackedUnsignedAccelerated; + integerDotProduct4x8BitPackedSignedAccelerated = copy_src.integerDotProduct4x8BitPackedSignedAccelerated; + integerDotProduct4x8BitPackedMixedSignednessAccelerated = copy_src.integerDotProduct4x8BitPackedMixedSignednessAccelerated; + integerDotProduct16BitUnsignedAccelerated = copy_src.integerDotProduct16BitUnsignedAccelerated; + integerDotProduct16BitSignedAccelerated = copy_src.integerDotProduct16BitSignedAccelerated; + integerDotProduct16BitMixedSignednessAccelerated = copy_src.integerDotProduct16BitMixedSignednessAccelerated; + integerDotProduct32BitUnsignedAccelerated = copy_src.integerDotProduct32BitUnsignedAccelerated; + integerDotProduct32BitSignedAccelerated = copy_src.integerDotProduct32BitSignedAccelerated; + integerDotProduct32BitMixedSignednessAccelerated = copy_src.integerDotProduct32BitMixedSignednessAccelerated; + integerDotProduct64BitUnsignedAccelerated = copy_src.integerDotProduct64BitUnsignedAccelerated; + integerDotProduct64BitSignedAccelerated = copy_src.integerDotProduct64BitSignedAccelerated; + integerDotProduct64BitMixedSignednessAccelerated = copy_src.integerDotProduct64BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating8BitSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating8BitSignedAccelerated; + integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating16BitSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating16BitSignedAccelerated; + integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating32BitSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating32BitSignedAccelerated; + integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating64BitSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating64BitSignedAccelerated; + integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; + storageTexelBufferOffsetAlignmentBytes = copy_src.storageTexelBufferOffsetAlignmentBytes; + storageTexelBufferOffsetSingleTexelAlignment = copy_src.storageTexelBufferOffsetSingleTexelAlignment; + uniformTexelBufferOffsetAlignmentBytes = copy_src.uniformTexelBufferOffsetAlignmentBytes; + uniformTexelBufferOffsetSingleTexelAlignment = copy_src.uniformTexelBufferOffsetSingleTexelAlignment; + maxBufferSize = copy_src.maxBufferSize; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceVulkan13Properties::~safe_VkPhysicalDeviceVulkan13Properties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceVulkan13Properties::initialize(const VkPhysicalDeviceVulkan13Properties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + minSubgroupSize = in_struct->minSubgroupSize; + maxSubgroupSize = in_struct->maxSubgroupSize; + maxComputeWorkgroupSubgroups = in_struct->maxComputeWorkgroupSubgroups; + requiredSubgroupSizeStages = in_struct->requiredSubgroupSizeStages; + maxInlineUniformBlockSize = in_struct->maxInlineUniformBlockSize; + maxPerStageDescriptorInlineUniformBlocks = in_struct->maxPerStageDescriptorInlineUniformBlocks; + maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_struct->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + maxDescriptorSetInlineUniformBlocks = in_struct->maxDescriptorSetInlineUniformBlocks; + maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_struct->maxDescriptorSetUpdateAfterBindInlineUniformBlocks; + maxInlineUniformTotalSize = in_struct->maxInlineUniformTotalSize; + integerDotProduct8BitUnsignedAccelerated = in_struct->integerDotProduct8BitUnsignedAccelerated; + integerDotProduct8BitSignedAccelerated = in_struct->integerDotProduct8BitSignedAccelerated; + integerDotProduct8BitMixedSignednessAccelerated = in_struct->integerDotProduct8BitMixedSignednessAccelerated; + integerDotProduct4x8BitPackedUnsignedAccelerated = in_struct->integerDotProduct4x8BitPackedUnsignedAccelerated; + integerDotProduct4x8BitPackedSignedAccelerated = in_struct->integerDotProduct4x8BitPackedSignedAccelerated; + integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_struct->integerDotProduct4x8BitPackedMixedSignednessAccelerated; + integerDotProduct16BitUnsignedAccelerated = in_struct->integerDotProduct16BitUnsignedAccelerated; + integerDotProduct16BitSignedAccelerated = in_struct->integerDotProduct16BitSignedAccelerated; + integerDotProduct16BitMixedSignednessAccelerated = in_struct->integerDotProduct16BitMixedSignednessAccelerated; + integerDotProduct32BitUnsignedAccelerated = in_struct->integerDotProduct32BitUnsignedAccelerated; + integerDotProduct32BitSignedAccelerated = in_struct->integerDotProduct32BitSignedAccelerated; + integerDotProduct32BitMixedSignednessAccelerated = in_struct->integerDotProduct32BitMixedSignednessAccelerated; + integerDotProduct64BitUnsignedAccelerated = in_struct->integerDotProduct64BitUnsignedAccelerated; + integerDotProduct64BitSignedAccelerated = in_struct->integerDotProduct64BitSignedAccelerated; + integerDotProduct64BitMixedSignednessAccelerated = in_struct->integerDotProduct64BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating8BitSignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating8BitSignedAccelerated; + integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = + in_struct->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = + in_struct->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating16BitSignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating16BitSignedAccelerated; + integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = + in_struct->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating32BitSignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating32BitSignedAccelerated; + integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = + in_struct->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating64BitSignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating64BitSignedAccelerated; + integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = + in_struct->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; + storageTexelBufferOffsetAlignmentBytes = in_struct->storageTexelBufferOffsetAlignmentBytes; + storageTexelBufferOffsetSingleTexelAlignment = in_struct->storageTexelBufferOffsetSingleTexelAlignment; + uniformTexelBufferOffsetAlignmentBytes = in_struct->uniformTexelBufferOffsetAlignmentBytes; + uniformTexelBufferOffsetSingleTexelAlignment = in_struct->uniformTexelBufferOffsetSingleTexelAlignment; + maxBufferSize = in_struct->maxBufferSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceVulkan13Properties::initialize(const safe_VkPhysicalDeviceVulkan13Properties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + minSubgroupSize = copy_src->minSubgroupSize; + maxSubgroupSize = copy_src->maxSubgroupSize; + maxComputeWorkgroupSubgroups = copy_src->maxComputeWorkgroupSubgroups; + requiredSubgroupSizeStages = copy_src->requiredSubgroupSizeStages; + maxInlineUniformBlockSize = copy_src->maxInlineUniformBlockSize; + maxPerStageDescriptorInlineUniformBlocks = copy_src->maxPerStageDescriptorInlineUniformBlocks; + maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = copy_src->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + maxDescriptorSetInlineUniformBlocks = copy_src->maxDescriptorSetInlineUniformBlocks; + maxDescriptorSetUpdateAfterBindInlineUniformBlocks = copy_src->maxDescriptorSetUpdateAfterBindInlineUniformBlocks; + maxInlineUniformTotalSize = copy_src->maxInlineUniformTotalSize; + integerDotProduct8BitUnsignedAccelerated = copy_src->integerDotProduct8BitUnsignedAccelerated; + integerDotProduct8BitSignedAccelerated = copy_src->integerDotProduct8BitSignedAccelerated; + integerDotProduct8BitMixedSignednessAccelerated = copy_src->integerDotProduct8BitMixedSignednessAccelerated; + integerDotProduct4x8BitPackedUnsignedAccelerated = copy_src->integerDotProduct4x8BitPackedUnsignedAccelerated; + integerDotProduct4x8BitPackedSignedAccelerated = copy_src->integerDotProduct4x8BitPackedSignedAccelerated; + integerDotProduct4x8BitPackedMixedSignednessAccelerated = copy_src->integerDotProduct4x8BitPackedMixedSignednessAccelerated; + integerDotProduct16BitUnsignedAccelerated = copy_src->integerDotProduct16BitUnsignedAccelerated; + integerDotProduct16BitSignedAccelerated = copy_src->integerDotProduct16BitSignedAccelerated; + integerDotProduct16BitMixedSignednessAccelerated = copy_src->integerDotProduct16BitMixedSignednessAccelerated; + integerDotProduct32BitUnsignedAccelerated = copy_src->integerDotProduct32BitUnsignedAccelerated; + integerDotProduct32BitSignedAccelerated = copy_src->integerDotProduct32BitSignedAccelerated; + integerDotProduct32BitMixedSignednessAccelerated = copy_src->integerDotProduct32BitMixedSignednessAccelerated; + integerDotProduct64BitUnsignedAccelerated = copy_src->integerDotProduct64BitUnsignedAccelerated; + integerDotProduct64BitSignedAccelerated = copy_src->integerDotProduct64BitSignedAccelerated; + integerDotProduct64BitMixedSignednessAccelerated = copy_src->integerDotProduct64BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating8BitSignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating8BitSignedAccelerated; + integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = + copy_src->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = + copy_src->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating16BitSignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating16BitSignedAccelerated; + integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = + copy_src->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating32BitSignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating32BitSignedAccelerated; + integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = + copy_src->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating64BitSignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating64BitSignedAccelerated; + integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = + copy_src->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; + storageTexelBufferOffsetAlignmentBytes = copy_src->storageTexelBufferOffsetAlignmentBytes; + storageTexelBufferOffsetSingleTexelAlignment = copy_src->storageTexelBufferOffsetSingleTexelAlignment; + uniformTexelBufferOffsetAlignmentBytes = copy_src->uniformTexelBufferOffsetAlignmentBytes; + uniformTexelBufferOffsetSingleTexelAlignment = copy_src->uniformTexelBufferOffsetSingleTexelAlignment; + maxBufferSize = copy_src->maxBufferSize; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineCreationFeedbackCreateInfo::safe_VkPipelineCreationFeedbackCreateInfo( + const VkPipelineCreationFeedbackCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + pPipelineCreationFeedback(nullptr), + pipelineStageCreationFeedbackCount(in_struct->pipelineStageCreationFeedbackCount), + pPipelineStageCreationFeedbacks(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pPipelineCreationFeedback) { + pPipelineCreationFeedback = new VkPipelineCreationFeedback(*in_struct->pPipelineCreationFeedback); + } + + if (in_struct->pPipelineStageCreationFeedbacks) { + pPipelineStageCreationFeedbacks = new VkPipelineCreationFeedback[in_struct->pipelineStageCreationFeedbackCount]; + memcpy((void*)pPipelineStageCreationFeedbacks, (void*)in_struct->pPipelineStageCreationFeedbacks, + sizeof(VkPipelineCreationFeedback) * in_struct->pipelineStageCreationFeedbackCount); + } +} + +safe_VkPipelineCreationFeedbackCreateInfo::safe_VkPipelineCreationFeedbackCreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO), + pNext(nullptr), + pPipelineCreationFeedback(nullptr), + pipelineStageCreationFeedbackCount(), + pPipelineStageCreationFeedbacks(nullptr) {} + +safe_VkPipelineCreationFeedbackCreateInfo::safe_VkPipelineCreationFeedbackCreateInfo( + const safe_VkPipelineCreationFeedbackCreateInfo& copy_src) { + sType = copy_src.sType; + pPipelineCreationFeedback = nullptr; + pipelineStageCreationFeedbackCount = copy_src.pipelineStageCreationFeedbackCount; + pPipelineStageCreationFeedbacks = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPipelineCreationFeedback) { + pPipelineCreationFeedback = new VkPipelineCreationFeedback(*copy_src.pPipelineCreationFeedback); + } + + if (copy_src.pPipelineStageCreationFeedbacks) { + pPipelineStageCreationFeedbacks = new VkPipelineCreationFeedback[copy_src.pipelineStageCreationFeedbackCount]; + memcpy((void*)pPipelineStageCreationFeedbacks, (void*)copy_src.pPipelineStageCreationFeedbacks, + sizeof(VkPipelineCreationFeedback) * copy_src.pipelineStageCreationFeedbackCount); + } +} + +safe_VkPipelineCreationFeedbackCreateInfo& safe_VkPipelineCreationFeedbackCreateInfo::operator=( + const safe_VkPipelineCreationFeedbackCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pPipelineCreationFeedback) delete pPipelineCreationFeedback; + if (pPipelineStageCreationFeedbacks) delete[] pPipelineStageCreationFeedbacks; + FreePnextChain(pNext); + + sType = copy_src.sType; + pPipelineCreationFeedback = nullptr; + pipelineStageCreationFeedbackCount = copy_src.pipelineStageCreationFeedbackCount; + pPipelineStageCreationFeedbacks = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPipelineCreationFeedback) { + pPipelineCreationFeedback = new VkPipelineCreationFeedback(*copy_src.pPipelineCreationFeedback); + } + + if (copy_src.pPipelineStageCreationFeedbacks) { + pPipelineStageCreationFeedbacks = new VkPipelineCreationFeedback[copy_src.pipelineStageCreationFeedbackCount]; + memcpy((void*)pPipelineStageCreationFeedbacks, (void*)copy_src.pPipelineStageCreationFeedbacks, + sizeof(VkPipelineCreationFeedback) * copy_src.pipelineStageCreationFeedbackCount); + } + + return *this; +} + +safe_VkPipelineCreationFeedbackCreateInfo::~safe_VkPipelineCreationFeedbackCreateInfo() { + if (pPipelineCreationFeedback) delete pPipelineCreationFeedback; + if (pPipelineStageCreationFeedbacks) delete[] pPipelineStageCreationFeedbacks; + FreePnextChain(pNext); +} + +void safe_VkPipelineCreationFeedbackCreateInfo::initialize(const VkPipelineCreationFeedbackCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPipelineCreationFeedback) delete pPipelineCreationFeedback; + if (pPipelineStageCreationFeedbacks) delete[] pPipelineStageCreationFeedbacks; + FreePnextChain(pNext); + sType = in_struct->sType; + pPipelineCreationFeedback = nullptr; + pipelineStageCreationFeedbackCount = in_struct->pipelineStageCreationFeedbackCount; + pPipelineStageCreationFeedbacks = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pPipelineCreationFeedback) { + pPipelineCreationFeedback = new VkPipelineCreationFeedback(*in_struct->pPipelineCreationFeedback); + } + + if (in_struct->pPipelineStageCreationFeedbacks) { + pPipelineStageCreationFeedbacks = new VkPipelineCreationFeedback[in_struct->pipelineStageCreationFeedbackCount]; + memcpy((void*)pPipelineStageCreationFeedbacks, (void*)in_struct->pPipelineStageCreationFeedbacks, + sizeof(VkPipelineCreationFeedback) * in_struct->pipelineStageCreationFeedbackCount); + } +} + +void safe_VkPipelineCreationFeedbackCreateInfo::initialize(const safe_VkPipelineCreationFeedbackCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pPipelineCreationFeedback = nullptr; + pipelineStageCreationFeedbackCount = copy_src->pipelineStageCreationFeedbackCount; + pPipelineStageCreationFeedbacks = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pPipelineCreationFeedback) { + pPipelineCreationFeedback = new VkPipelineCreationFeedback(*copy_src->pPipelineCreationFeedback); + } + + if (copy_src->pPipelineStageCreationFeedbacks) { + pPipelineStageCreationFeedbacks = new VkPipelineCreationFeedback[copy_src->pipelineStageCreationFeedbackCount]; + memcpy((void*)pPipelineStageCreationFeedbacks, (void*)copy_src->pPipelineStageCreationFeedbacks, + sizeof(VkPipelineCreationFeedback) * copy_src->pipelineStageCreationFeedbackCount); + } +} + +safe_VkPhysicalDeviceShaderTerminateInvocationFeatures::safe_VkPhysicalDeviceShaderTerminateInvocationFeatures( + const VkPhysicalDeviceShaderTerminateInvocationFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), shaderTerminateInvocation(in_struct->shaderTerminateInvocation) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderTerminateInvocationFeatures::safe_VkPhysicalDeviceShaderTerminateInvocationFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES), pNext(nullptr), shaderTerminateInvocation() {} + +safe_VkPhysicalDeviceShaderTerminateInvocationFeatures::safe_VkPhysicalDeviceShaderTerminateInvocationFeatures( + const safe_VkPhysicalDeviceShaderTerminateInvocationFeatures& copy_src) { + sType = copy_src.sType; + shaderTerminateInvocation = copy_src.shaderTerminateInvocation; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderTerminateInvocationFeatures& safe_VkPhysicalDeviceShaderTerminateInvocationFeatures::operator=( + const safe_VkPhysicalDeviceShaderTerminateInvocationFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderTerminateInvocation = copy_src.shaderTerminateInvocation; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderTerminateInvocationFeatures::~safe_VkPhysicalDeviceShaderTerminateInvocationFeatures() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderTerminateInvocationFeatures::initialize( + const VkPhysicalDeviceShaderTerminateInvocationFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderTerminateInvocation = in_struct->shaderTerminateInvocation; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderTerminateInvocationFeatures::initialize( + const safe_VkPhysicalDeviceShaderTerminateInvocationFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderTerminateInvocation = copy_src->shaderTerminateInvocation; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceToolProperties::safe_VkPhysicalDeviceToolProperties(const VkPhysicalDeviceToolProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), purposes(in_struct->purposes) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) { + name[i] = in_struct->name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) { + version[i] = in_struct->version[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = in_struct->description[i]; + } + + for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) { + layer[i] = in_struct->layer[i]; + } +} + +safe_VkPhysicalDeviceToolProperties::safe_VkPhysicalDeviceToolProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES), pNext(nullptr), purposes() {} + +safe_VkPhysicalDeviceToolProperties::safe_VkPhysicalDeviceToolProperties(const safe_VkPhysicalDeviceToolProperties& copy_src) { + sType = copy_src.sType; + purposes = copy_src.purposes; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) { + name[i] = copy_src.name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) { + version[i] = copy_src.version[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = copy_src.description[i]; + } + + for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) { + layer[i] = copy_src.layer[i]; + } +} + +safe_VkPhysicalDeviceToolProperties& safe_VkPhysicalDeviceToolProperties::operator=( + const safe_VkPhysicalDeviceToolProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + purposes = copy_src.purposes; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) { + name[i] = copy_src.name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) { + version[i] = copy_src.version[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = copy_src.description[i]; + } + + for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) { + layer[i] = copy_src.layer[i]; + } + + return *this; +} + +safe_VkPhysicalDeviceToolProperties::~safe_VkPhysicalDeviceToolProperties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceToolProperties::initialize(const VkPhysicalDeviceToolProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + purposes = in_struct->purposes; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) { + name[i] = in_struct->name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) { + version[i] = in_struct->version[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = in_struct->description[i]; + } + + for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) { + layer[i] = in_struct->layer[i]; + } +} + +void safe_VkPhysicalDeviceToolProperties::initialize(const safe_VkPhysicalDeviceToolProperties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + purposes = copy_src->purposes; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) { + name[i] = copy_src->name[i]; + } + + for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) { + version[i] = copy_src->version[i]; + } + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = copy_src->description[i]; + } + + for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) { + layer[i] = copy_src->layer[i]; + } +} + +safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures::safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures( + const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), shaderDemoteToHelperInvocation(in_struct->shaderDemoteToHelperInvocation) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures::safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES), + pNext(nullptr), + shaderDemoteToHelperInvocation() {} + +safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures::safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures( + const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& copy_src) { + sType = copy_src.sType; + shaderDemoteToHelperInvocation = copy_src.shaderDemoteToHelperInvocation; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures::operator=( + const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderDemoteToHelperInvocation = copy_src.shaderDemoteToHelperInvocation; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures::~safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures::initialize( + const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderDemoteToHelperInvocation = in_struct->shaderDemoteToHelperInvocation; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures::initialize( + const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderDemoteToHelperInvocation = copy_src->shaderDemoteToHelperInvocation; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePrivateDataFeatures::safe_VkPhysicalDevicePrivateDataFeatures( + const VkPhysicalDevicePrivateDataFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), privateData(in_struct->privateData) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePrivateDataFeatures::safe_VkPhysicalDevicePrivateDataFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES), pNext(nullptr), privateData() {} + +safe_VkPhysicalDevicePrivateDataFeatures::safe_VkPhysicalDevicePrivateDataFeatures( + const safe_VkPhysicalDevicePrivateDataFeatures& copy_src) { + sType = copy_src.sType; + privateData = copy_src.privateData; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePrivateDataFeatures& safe_VkPhysicalDevicePrivateDataFeatures::operator=( + const safe_VkPhysicalDevicePrivateDataFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + privateData = copy_src.privateData; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePrivateDataFeatures::~safe_VkPhysicalDevicePrivateDataFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePrivateDataFeatures::initialize(const VkPhysicalDevicePrivateDataFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + privateData = in_struct->privateData; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePrivateDataFeatures::initialize(const safe_VkPhysicalDevicePrivateDataFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + privateData = copy_src->privateData; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDevicePrivateDataCreateInfo::safe_VkDevicePrivateDataCreateInfo(const VkDevicePrivateDataCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), privateDataSlotRequestCount(in_struct->privateDataSlotRequestCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDevicePrivateDataCreateInfo::safe_VkDevicePrivateDataCreateInfo() + : sType(VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO), pNext(nullptr), privateDataSlotRequestCount() {} + +safe_VkDevicePrivateDataCreateInfo::safe_VkDevicePrivateDataCreateInfo(const safe_VkDevicePrivateDataCreateInfo& copy_src) { + sType = copy_src.sType; + privateDataSlotRequestCount = copy_src.privateDataSlotRequestCount; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDevicePrivateDataCreateInfo& safe_VkDevicePrivateDataCreateInfo::operator=( + const safe_VkDevicePrivateDataCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + privateDataSlotRequestCount = copy_src.privateDataSlotRequestCount; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDevicePrivateDataCreateInfo::~safe_VkDevicePrivateDataCreateInfo() { FreePnextChain(pNext); } + +void safe_VkDevicePrivateDataCreateInfo::initialize(const VkDevicePrivateDataCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + privateDataSlotRequestCount = in_struct->privateDataSlotRequestCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDevicePrivateDataCreateInfo::initialize(const safe_VkDevicePrivateDataCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + privateDataSlotRequestCount = copy_src->privateDataSlotRequestCount; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPrivateDataSlotCreateInfo::safe_VkPrivateDataSlotCreateInfo(const VkPrivateDataSlotCreateInfo* 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_VkPrivateDataSlotCreateInfo::safe_VkPrivateDataSlotCreateInfo() + : sType(VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO), pNext(nullptr), flags() {} + +safe_VkPrivateDataSlotCreateInfo::safe_VkPrivateDataSlotCreateInfo(const safe_VkPrivateDataSlotCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPrivateDataSlotCreateInfo& safe_VkPrivateDataSlotCreateInfo::operator=(const safe_VkPrivateDataSlotCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPrivateDataSlotCreateInfo::~safe_VkPrivateDataSlotCreateInfo() { FreePnextChain(pNext); } + +void safe_VkPrivateDataSlotCreateInfo::initialize(const VkPrivateDataSlotCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPrivateDataSlotCreateInfo::initialize(const safe_VkPrivateDataSlotCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePipelineCreationCacheControlFeatures::safe_VkPhysicalDevicePipelineCreationCacheControlFeatures( + const VkPhysicalDevicePipelineCreationCacheControlFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), pipelineCreationCacheControl(in_struct->pipelineCreationCacheControl) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePipelineCreationCacheControlFeatures::safe_VkPhysicalDevicePipelineCreationCacheControlFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES), + pNext(nullptr), + pipelineCreationCacheControl() {} + +safe_VkPhysicalDevicePipelineCreationCacheControlFeatures::safe_VkPhysicalDevicePipelineCreationCacheControlFeatures( + const safe_VkPhysicalDevicePipelineCreationCacheControlFeatures& copy_src) { + sType = copy_src.sType; + pipelineCreationCacheControl = copy_src.pipelineCreationCacheControl; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePipelineCreationCacheControlFeatures& safe_VkPhysicalDevicePipelineCreationCacheControlFeatures::operator=( + const safe_VkPhysicalDevicePipelineCreationCacheControlFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pipelineCreationCacheControl = copy_src.pipelineCreationCacheControl; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePipelineCreationCacheControlFeatures::~safe_VkPhysicalDevicePipelineCreationCacheControlFeatures() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDevicePipelineCreationCacheControlFeatures::initialize( + const VkPhysicalDevicePipelineCreationCacheControlFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pipelineCreationCacheControl = in_struct->pipelineCreationCacheControl; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePipelineCreationCacheControlFeatures::initialize( + const safe_VkPhysicalDevicePipelineCreationCacheControlFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipelineCreationCacheControl = copy_src->pipelineCreationCacheControl; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMemoryBarrier2::safe_VkMemoryBarrier2(const VkMemoryBarrier2* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + srcStageMask(in_struct->srcStageMask), + srcAccessMask(in_struct->srcAccessMask), + dstStageMask(in_struct->dstStageMask), + dstAccessMask(in_struct->dstAccessMask) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMemoryBarrier2::safe_VkMemoryBarrier2() + : sType(VK_STRUCTURE_TYPE_MEMORY_BARRIER_2), pNext(nullptr), srcStageMask(), srcAccessMask(), dstStageMask(), dstAccessMask() {} + +safe_VkMemoryBarrier2::safe_VkMemoryBarrier2(const safe_VkMemoryBarrier2& copy_src) { + sType = copy_src.sType; + srcStageMask = copy_src.srcStageMask; + srcAccessMask = copy_src.srcAccessMask; + dstStageMask = copy_src.dstStageMask; + dstAccessMask = copy_src.dstAccessMask; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryBarrier2& safe_VkMemoryBarrier2::operator=(const safe_VkMemoryBarrier2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + srcStageMask = copy_src.srcStageMask; + srcAccessMask = copy_src.srcAccessMask; + dstStageMask = copy_src.dstStageMask; + dstAccessMask = copy_src.dstAccessMask; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryBarrier2::~safe_VkMemoryBarrier2() { FreePnextChain(pNext); } + +void safe_VkMemoryBarrier2::initialize(const VkMemoryBarrier2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + srcStageMask = in_struct->srcStageMask; + srcAccessMask = in_struct->srcAccessMask; + dstStageMask = in_struct->dstStageMask; + dstAccessMask = in_struct->dstAccessMask; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryBarrier2::initialize(const safe_VkMemoryBarrier2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcStageMask = copy_src->srcStageMask; + srcAccessMask = copy_src->srcAccessMask; + dstStageMask = copy_src->dstStageMask; + dstAccessMask = copy_src->dstAccessMask; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBufferMemoryBarrier2::safe_VkBufferMemoryBarrier2(const VkBufferMemoryBarrier2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + srcStageMask(in_struct->srcStageMask), + srcAccessMask(in_struct->srcAccessMask), + dstStageMask(in_struct->dstStageMask), + dstAccessMask(in_struct->dstAccessMask), + srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex), + dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex), + buffer(in_struct->buffer), + offset(in_struct->offset), + size(in_struct->size) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBufferMemoryBarrier2::safe_VkBufferMemoryBarrier2() + : sType(VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2), + pNext(nullptr), + srcStageMask(), + srcAccessMask(), + dstStageMask(), + dstAccessMask(), + srcQueueFamilyIndex(), + dstQueueFamilyIndex(), + buffer(), + offset(), + size() {} + +safe_VkBufferMemoryBarrier2::safe_VkBufferMemoryBarrier2(const safe_VkBufferMemoryBarrier2& copy_src) { + sType = copy_src.sType; + srcStageMask = copy_src.srcStageMask; + srcAccessMask = copy_src.srcAccessMask; + dstStageMask = copy_src.dstStageMask; + dstAccessMask = copy_src.dstAccessMask; + srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex; + dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex; + buffer = copy_src.buffer; + offset = copy_src.offset; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBufferMemoryBarrier2& safe_VkBufferMemoryBarrier2::operator=(const safe_VkBufferMemoryBarrier2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + srcStageMask = copy_src.srcStageMask; + srcAccessMask = copy_src.srcAccessMask; + dstStageMask = copy_src.dstStageMask; + dstAccessMask = copy_src.dstAccessMask; + srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex; + dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex; + buffer = copy_src.buffer; + offset = copy_src.offset; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBufferMemoryBarrier2::~safe_VkBufferMemoryBarrier2() { FreePnextChain(pNext); } + +void safe_VkBufferMemoryBarrier2::initialize(const VkBufferMemoryBarrier2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + srcStageMask = in_struct->srcStageMask; + srcAccessMask = in_struct->srcAccessMask; + dstStageMask = in_struct->dstStageMask; + dstAccessMask = in_struct->dstAccessMask; + srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex; + dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex; + buffer = in_struct->buffer; + offset = in_struct->offset; + size = in_struct->size; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBufferMemoryBarrier2::initialize(const safe_VkBufferMemoryBarrier2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcStageMask = copy_src->srcStageMask; + srcAccessMask = copy_src->srcAccessMask; + dstStageMask = copy_src->dstStageMask; + dstAccessMask = copy_src->dstAccessMask; + srcQueueFamilyIndex = copy_src->srcQueueFamilyIndex; + dstQueueFamilyIndex = copy_src->dstQueueFamilyIndex; + buffer = copy_src->buffer; + offset = copy_src->offset; + size = copy_src->size; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImageMemoryBarrier2::safe_VkImageMemoryBarrier2(const VkImageMemoryBarrier2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + srcStageMask(in_struct->srcStageMask), + srcAccessMask(in_struct->srcAccessMask), + dstStageMask(in_struct->dstStageMask), + dstAccessMask(in_struct->dstAccessMask), + oldLayout(in_struct->oldLayout), + newLayout(in_struct->newLayout), + srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex), + dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex), + image(in_struct->image), + subresourceRange(in_struct->subresourceRange) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageMemoryBarrier2::safe_VkImageMemoryBarrier2() + : sType(VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2), + pNext(nullptr), + srcStageMask(), + srcAccessMask(), + dstStageMask(), + dstAccessMask(), + oldLayout(), + newLayout(), + srcQueueFamilyIndex(), + dstQueueFamilyIndex(), + image(), + subresourceRange() {} + +safe_VkImageMemoryBarrier2::safe_VkImageMemoryBarrier2(const safe_VkImageMemoryBarrier2& copy_src) { + sType = copy_src.sType; + srcStageMask = copy_src.srcStageMask; + srcAccessMask = copy_src.srcAccessMask; + dstStageMask = copy_src.dstStageMask; + dstAccessMask = copy_src.dstAccessMask; + oldLayout = copy_src.oldLayout; + newLayout = copy_src.newLayout; + srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex; + dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex; + image = copy_src.image; + subresourceRange = copy_src.subresourceRange; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageMemoryBarrier2& safe_VkImageMemoryBarrier2::operator=(const safe_VkImageMemoryBarrier2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + srcStageMask = copy_src.srcStageMask; + srcAccessMask = copy_src.srcAccessMask; + dstStageMask = copy_src.dstStageMask; + dstAccessMask = copy_src.dstAccessMask; + oldLayout = copy_src.oldLayout; + newLayout = copy_src.newLayout; + srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex; + dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex; + image = copy_src.image; + subresourceRange = copy_src.subresourceRange; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageMemoryBarrier2::~safe_VkImageMemoryBarrier2() { FreePnextChain(pNext); } + +void safe_VkImageMemoryBarrier2::initialize(const VkImageMemoryBarrier2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + srcStageMask = in_struct->srcStageMask; + srcAccessMask = in_struct->srcAccessMask; + dstStageMask = in_struct->dstStageMask; + dstAccessMask = in_struct->dstAccessMask; + oldLayout = in_struct->oldLayout; + newLayout = in_struct->newLayout; + srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex; + dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex; + image = in_struct->image; + subresourceRange = in_struct->subresourceRange; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageMemoryBarrier2::initialize(const safe_VkImageMemoryBarrier2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcStageMask = copy_src->srcStageMask; + srcAccessMask = copy_src->srcAccessMask; + dstStageMask = copy_src->dstStageMask; + dstAccessMask = copy_src->dstAccessMask; + oldLayout = copy_src->oldLayout; + newLayout = copy_src->newLayout; + srcQueueFamilyIndex = copy_src->srcQueueFamilyIndex; + dstQueueFamilyIndex = copy_src->dstQueueFamilyIndex; + image = copy_src->image; + subresourceRange = copy_src->subresourceRange; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDependencyInfo::safe_VkDependencyInfo(const VkDependencyInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + dependencyFlags(in_struct->dependencyFlags), + memoryBarrierCount(in_struct->memoryBarrierCount), + pMemoryBarriers(nullptr), + bufferMemoryBarrierCount(in_struct->bufferMemoryBarrierCount), + pBufferMemoryBarriers(nullptr), + imageMemoryBarrierCount(in_struct->imageMemoryBarrierCount), + pImageMemoryBarriers(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (memoryBarrierCount && in_struct->pMemoryBarriers) { + pMemoryBarriers = new safe_VkMemoryBarrier2[memoryBarrierCount]; + for (uint32_t i = 0; i < memoryBarrierCount; ++i) { + pMemoryBarriers[i].initialize(&in_struct->pMemoryBarriers[i]); + } + } + if (bufferMemoryBarrierCount && in_struct->pBufferMemoryBarriers) { + pBufferMemoryBarriers = new safe_VkBufferMemoryBarrier2[bufferMemoryBarrierCount]; + for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) { + pBufferMemoryBarriers[i].initialize(&in_struct->pBufferMemoryBarriers[i]); + } + } + if (imageMemoryBarrierCount && in_struct->pImageMemoryBarriers) { + pImageMemoryBarriers = new safe_VkImageMemoryBarrier2[imageMemoryBarrierCount]; + for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) { + pImageMemoryBarriers[i].initialize(&in_struct->pImageMemoryBarriers[i]); + } + } +} + +safe_VkDependencyInfo::safe_VkDependencyInfo() + : sType(VK_STRUCTURE_TYPE_DEPENDENCY_INFO), + pNext(nullptr), + dependencyFlags(), + memoryBarrierCount(), + pMemoryBarriers(nullptr), + bufferMemoryBarrierCount(), + pBufferMemoryBarriers(nullptr), + imageMemoryBarrierCount(), + pImageMemoryBarriers(nullptr) {} + +safe_VkDependencyInfo::safe_VkDependencyInfo(const safe_VkDependencyInfo& copy_src) { + sType = copy_src.sType; + dependencyFlags = copy_src.dependencyFlags; + memoryBarrierCount = copy_src.memoryBarrierCount; + pMemoryBarriers = nullptr; + bufferMemoryBarrierCount = copy_src.bufferMemoryBarrierCount; + pBufferMemoryBarriers = nullptr; + imageMemoryBarrierCount = copy_src.imageMemoryBarrierCount; + pImageMemoryBarriers = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (memoryBarrierCount && copy_src.pMemoryBarriers) { + pMemoryBarriers = new safe_VkMemoryBarrier2[memoryBarrierCount]; + for (uint32_t i = 0; i < memoryBarrierCount; ++i) { + pMemoryBarriers[i].initialize(©_src.pMemoryBarriers[i]); + } + } + if (bufferMemoryBarrierCount && copy_src.pBufferMemoryBarriers) { + pBufferMemoryBarriers = new safe_VkBufferMemoryBarrier2[bufferMemoryBarrierCount]; + for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) { + pBufferMemoryBarriers[i].initialize(©_src.pBufferMemoryBarriers[i]); + } + } + if (imageMemoryBarrierCount && copy_src.pImageMemoryBarriers) { + pImageMemoryBarriers = new safe_VkImageMemoryBarrier2[imageMemoryBarrierCount]; + for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) { + pImageMemoryBarriers[i].initialize(©_src.pImageMemoryBarriers[i]); + } + } +} + +safe_VkDependencyInfo& safe_VkDependencyInfo::operator=(const safe_VkDependencyInfo& copy_src) { + if (©_src == this) return *this; + + if (pMemoryBarriers) delete[] pMemoryBarriers; + if (pBufferMemoryBarriers) delete[] pBufferMemoryBarriers; + if (pImageMemoryBarriers) delete[] pImageMemoryBarriers; + FreePnextChain(pNext); + + sType = copy_src.sType; + dependencyFlags = copy_src.dependencyFlags; + memoryBarrierCount = copy_src.memoryBarrierCount; + pMemoryBarriers = nullptr; + bufferMemoryBarrierCount = copy_src.bufferMemoryBarrierCount; + pBufferMemoryBarriers = nullptr; + imageMemoryBarrierCount = copy_src.imageMemoryBarrierCount; + pImageMemoryBarriers = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (memoryBarrierCount && copy_src.pMemoryBarriers) { + pMemoryBarriers = new safe_VkMemoryBarrier2[memoryBarrierCount]; + for (uint32_t i = 0; i < memoryBarrierCount; ++i) { + pMemoryBarriers[i].initialize(©_src.pMemoryBarriers[i]); + } + } + if (bufferMemoryBarrierCount && copy_src.pBufferMemoryBarriers) { + pBufferMemoryBarriers = new safe_VkBufferMemoryBarrier2[bufferMemoryBarrierCount]; + for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) { + pBufferMemoryBarriers[i].initialize(©_src.pBufferMemoryBarriers[i]); + } + } + if (imageMemoryBarrierCount && copy_src.pImageMemoryBarriers) { + pImageMemoryBarriers = new safe_VkImageMemoryBarrier2[imageMemoryBarrierCount]; + for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) { + pImageMemoryBarriers[i].initialize(©_src.pImageMemoryBarriers[i]); + } + } + + return *this; +} + +safe_VkDependencyInfo::~safe_VkDependencyInfo() { + if (pMemoryBarriers) delete[] pMemoryBarriers; + if (pBufferMemoryBarriers) delete[] pBufferMemoryBarriers; + if (pImageMemoryBarriers) delete[] pImageMemoryBarriers; + FreePnextChain(pNext); +} + +void safe_VkDependencyInfo::initialize(const VkDependencyInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pMemoryBarriers) delete[] pMemoryBarriers; + if (pBufferMemoryBarriers) delete[] pBufferMemoryBarriers; + if (pImageMemoryBarriers) delete[] pImageMemoryBarriers; + FreePnextChain(pNext); + sType = in_struct->sType; + dependencyFlags = in_struct->dependencyFlags; + memoryBarrierCount = in_struct->memoryBarrierCount; + pMemoryBarriers = nullptr; + bufferMemoryBarrierCount = in_struct->bufferMemoryBarrierCount; + pBufferMemoryBarriers = nullptr; + imageMemoryBarrierCount = in_struct->imageMemoryBarrierCount; + pImageMemoryBarriers = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (memoryBarrierCount && in_struct->pMemoryBarriers) { + pMemoryBarriers = new safe_VkMemoryBarrier2[memoryBarrierCount]; + for (uint32_t i = 0; i < memoryBarrierCount; ++i) { + pMemoryBarriers[i].initialize(&in_struct->pMemoryBarriers[i]); + } + } + if (bufferMemoryBarrierCount && in_struct->pBufferMemoryBarriers) { + pBufferMemoryBarriers = new safe_VkBufferMemoryBarrier2[bufferMemoryBarrierCount]; + for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) { + pBufferMemoryBarriers[i].initialize(&in_struct->pBufferMemoryBarriers[i]); + } + } + if (imageMemoryBarrierCount && in_struct->pImageMemoryBarriers) { + pImageMemoryBarriers = new safe_VkImageMemoryBarrier2[imageMemoryBarrierCount]; + for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) { + pImageMemoryBarriers[i].initialize(&in_struct->pImageMemoryBarriers[i]); + } + } +} + +void safe_VkDependencyInfo::initialize(const safe_VkDependencyInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + dependencyFlags = copy_src->dependencyFlags; + memoryBarrierCount = copy_src->memoryBarrierCount; + pMemoryBarriers = nullptr; + bufferMemoryBarrierCount = copy_src->bufferMemoryBarrierCount; + pBufferMemoryBarriers = nullptr; + imageMemoryBarrierCount = copy_src->imageMemoryBarrierCount; + pImageMemoryBarriers = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (memoryBarrierCount && copy_src->pMemoryBarriers) { + pMemoryBarriers = new safe_VkMemoryBarrier2[memoryBarrierCount]; + for (uint32_t i = 0; i < memoryBarrierCount; ++i) { + pMemoryBarriers[i].initialize(©_src->pMemoryBarriers[i]); + } + } + if (bufferMemoryBarrierCount && copy_src->pBufferMemoryBarriers) { + pBufferMemoryBarriers = new safe_VkBufferMemoryBarrier2[bufferMemoryBarrierCount]; + for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) { + pBufferMemoryBarriers[i].initialize(©_src->pBufferMemoryBarriers[i]); + } + } + if (imageMemoryBarrierCount && copy_src->pImageMemoryBarriers) { + pImageMemoryBarriers = new safe_VkImageMemoryBarrier2[imageMemoryBarrierCount]; + for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) { + pImageMemoryBarriers[i].initialize(©_src->pImageMemoryBarriers[i]); + } + } +} + +safe_VkSemaphoreSubmitInfo::safe_VkSemaphoreSubmitInfo(const VkSemaphoreSubmitInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + semaphore(in_struct->semaphore), + value(in_struct->value), + stageMask(in_struct->stageMask), + deviceIndex(in_struct->deviceIndex) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSemaphoreSubmitInfo::safe_VkSemaphoreSubmitInfo() + : sType(VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO), pNext(nullptr), semaphore(), value(), stageMask(), deviceIndex() {} + +safe_VkSemaphoreSubmitInfo::safe_VkSemaphoreSubmitInfo(const safe_VkSemaphoreSubmitInfo& copy_src) { + sType = copy_src.sType; + semaphore = copy_src.semaphore; + value = copy_src.value; + stageMask = copy_src.stageMask; + deviceIndex = copy_src.deviceIndex; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSemaphoreSubmitInfo& safe_VkSemaphoreSubmitInfo::operator=(const safe_VkSemaphoreSubmitInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + semaphore = copy_src.semaphore; + value = copy_src.value; + stageMask = copy_src.stageMask; + deviceIndex = copy_src.deviceIndex; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSemaphoreSubmitInfo::~safe_VkSemaphoreSubmitInfo() { FreePnextChain(pNext); } + +void safe_VkSemaphoreSubmitInfo::initialize(const VkSemaphoreSubmitInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + semaphore = in_struct->semaphore; + value = in_struct->value; + stageMask = in_struct->stageMask; + deviceIndex = in_struct->deviceIndex; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSemaphoreSubmitInfo::initialize(const safe_VkSemaphoreSubmitInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + semaphore = copy_src->semaphore; + value = copy_src->value; + stageMask = copy_src->stageMask; + deviceIndex = copy_src->deviceIndex; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCommandBufferSubmitInfo::safe_VkCommandBufferSubmitInfo(const VkCommandBufferSubmitInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), commandBuffer(in_struct->commandBuffer), deviceMask(in_struct->deviceMask) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCommandBufferSubmitInfo::safe_VkCommandBufferSubmitInfo() + : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO), pNext(nullptr), commandBuffer(), deviceMask() {} + +safe_VkCommandBufferSubmitInfo::safe_VkCommandBufferSubmitInfo(const safe_VkCommandBufferSubmitInfo& copy_src) { + sType = copy_src.sType; + commandBuffer = copy_src.commandBuffer; + deviceMask = copy_src.deviceMask; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCommandBufferSubmitInfo& safe_VkCommandBufferSubmitInfo::operator=(const safe_VkCommandBufferSubmitInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + commandBuffer = copy_src.commandBuffer; + deviceMask = copy_src.deviceMask; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCommandBufferSubmitInfo::~safe_VkCommandBufferSubmitInfo() { FreePnextChain(pNext); } + +void safe_VkCommandBufferSubmitInfo::initialize(const VkCommandBufferSubmitInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + commandBuffer = in_struct->commandBuffer; + deviceMask = in_struct->deviceMask; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCommandBufferSubmitInfo::initialize(const safe_VkCommandBufferSubmitInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + commandBuffer = copy_src->commandBuffer; + deviceMask = copy_src->deviceMask; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSubmitInfo2::safe_VkSubmitInfo2(const VkSubmitInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + waitSemaphoreInfoCount(in_struct->waitSemaphoreInfoCount), + pWaitSemaphoreInfos(nullptr), + commandBufferInfoCount(in_struct->commandBufferInfoCount), + pCommandBufferInfos(nullptr), + signalSemaphoreInfoCount(in_struct->signalSemaphoreInfoCount), + pSignalSemaphoreInfos(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (waitSemaphoreInfoCount && in_struct->pWaitSemaphoreInfos) { + pWaitSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[waitSemaphoreInfoCount]; + for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) { + pWaitSemaphoreInfos[i].initialize(&in_struct->pWaitSemaphoreInfos[i]); + } + } + if (commandBufferInfoCount && in_struct->pCommandBufferInfos) { + pCommandBufferInfos = new safe_VkCommandBufferSubmitInfo[commandBufferInfoCount]; + for (uint32_t i = 0; i < commandBufferInfoCount; ++i) { + pCommandBufferInfos[i].initialize(&in_struct->pCommandBufferInfos[i]); + } + } + if (signalSemaphoreInfoCount && in_struct->pSignalSemaphoreInfos) { + pSignalSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[signalSemaphoreInfoCount]; + for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) { + pSignalSemaphoreInfos[i].initialize(&in_struct->pSignalSemaphoreInfos[i]); + } + } +} + +safe_VkSubmitInfo2::safe_VkSubmitInfo2() + : sType(VK_STRUCTURE_TYPE_SUBMIT_INFO_2), + pNext(nullptr), + flags(), + waitSemaphoreInfoCount(), + pWaitSemaphoreInfos(nullptr), + commandBufferInfoCount(), + pCommandBufferInfos(nullptr), + signalSemaphoreInfoCount(), + pSignalSemaphoreInfos(nullptr) {} + +safe_VkSubmitInfo2::safe_VkSubmitInfo2(const safe_VkSubmitInfo2& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + waitSemaphoreInfoCount = copy_src.waitSemaphoreInfoCount; + pWaitSemaphoreInfos = nullptr; + commandBufferInfoCount = copy_src.commandBufferInfoCount; + pCommandBufferInfos = nullptr; + signalSemaphoreInfoCount = copy_src.signalSemaphoreInfoCount; + pSignalSemaphoreInfos = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (waitSemaphoreInfoCount && copy_src.pWaitSemaphoreInfos) { + pWaitSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[waitSemaphoreInfoCount]; + for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) { + pWaitSemaphoreInfos[i].initialize(©_src.pWaitSemaphoreInfos[i]); + } + } + if (commandBufferInfoCount && copy_src.pCommandBufferInfos) { + pCommandBufferInfos = new safe_VkCommandBufferSubmitInfo[commandBufferInfoCount]; + for (uint32_t i = 0; i < commandBufferInfoCount; ++i) { + pCommandBufferInfos[i].initialize(©_src.pCommandBufferInfos[i]); + } + } + if (signalSemaphoreInfoCount && copy_src.pSignalSemaphoreInfos) { + pSignalSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[signalSemaphoreInfoCount]; + for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) { + pSignalSemaphoreInfos[i].initialize(©_src.pSignalSemaphoreInfos[i]); + } + } +} + +safe_VkSubmitInfo2& safe_VkSubmitInfo2::operator=(const safe_VkSubmitInfo2& copy_src) { + if (©_src == this) return *this; + + if (pWaitSemaphoreInfos) delete[] pWaitSemaphoreInfos; + if (pCommandBufferInfos) delete[] pCommandBufferInfos; + if (pSignalSemaphoreInfos) delete[] pSignalSemaphoreInfos; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + waitSemaphoreInfoCount = copy_src.waitSemaphoreInfoCount; + pWaitSemaphoreInfos = nullptr; + commandBufferInfoCount = copy_src.commandBufferInfoCount; + pCommandBufferInfos = nullptr; + signalSemaphoreInfoCount = copy_src.signalSemaphoreInfoCount; + pSignalSemaphoreInfos = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (waitSemaphoreInfoCount && copy_src.pWaitSemaphoreInfos) { + pWaitSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[waitSemaphoreInfoCount]; + for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) { + pWaitSemaphoreInfos[i].initialize(©_src.pWaitSemaphoreInfos[i]); + } + } + if (commandBufferInfoCount && copy_src.pCommandBufferInfos) { + pCommandBufferInfos = new safe_VkCommandBufferSubmitInfo[commandBufferInfoCount]; + for (uint32_t i = 0; i < commandBufferInfoCount; ++i) { + pCommandBufferInfos[i].initialize(©_src.pCommandBufferInfos[i]); + } + } + if (signalSemaphoreInfoCount && copy_src.pSignalSemaphoreInfos) { + pSignalSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[signalSemaphoreInfoCount]; + for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) { + pSignalSemaphoreInfos[i].initialize(©_src.pSignalSemaphoreInfos[i]); + } + } + + return *this; +} + +safe_VkSubmitInfo2::~safe_VkSubmitInfo2() { + if (pWaitSemaphoreInfos) delete[] pWaitSemaphoreInfos; + if (pCommandBufferInfos) delete[] pCommandBufferInfos; + if (pSignalSemaphoreInfos) delete[] pSignalSemaphoreInfos; + FreePnextChain(pNext); +} + +void safe_VkSubmitInfo2::initialize(const VkSubmitInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pWaitSemaphoreInfos) delete[] pWaitSemaphoreInfos; + if (pCommandBufferInfos) delete[] pCommandBufferInfos; + if (pSignalSemaphoreInfos) delete[] pSignalSemaphoreInfos; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + waitSemaphoreInfoCount = in_struct->waitSemaphoreInfoCount; + pWaitSemaphoreInfos = nullptr; + commandBufferInfoCount = in_struct->commandBufferInfoCount; + pCommandBufferInfos = nullptr; + signalSemaphoreInfoCount = in_struct->signalSemaphoreInfoCount; + pSignalSemaphoreInfos = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (waitSemaphoreInfoCount && in_struct->pWaitSemaphoreInfos) { + pWaitSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[waitSemaphoreInfoCount]; + for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) { + pWaitSemaphoreInfos[i].initialize(&in_struct->pWaitSemaphoreInfos[i]); + } + } + if (commandBufferInfoCount && in_struct->pCommandBufferInfos) { + pCommandBufferInfos = new safe_VkCommandBufferSubmitInfo[commandBufferInfoCount]; + for (uint32_t i = 0; i < commandBufferInfoCount; ++i) { + pCommandBufferInfos[i].initialize(&in_struct->pCommandBufferInfos[i]); + } + } + if (signalSemaphoreInfoCount && in_struct->pSignalSemaphoreInfos) { + pSignalSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[signalSemaphoreInfoCount]; + for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) { + pSignalSemaphoreInfos[i].initialize(&in_struct->pSignalSemaphoreInfos[i]); + } + } +} + +void safe_VkSubmitInfo2::initialize(const safe_VkSubmitInfo2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + waitSemaphoreInfoCount = copy_src->waitSemaphoreInfoCount; + pWaitSemaphoreInfos = nullptr; + commandBufferInfoCount = copy_src->commandBufferInfoCount; + pCommandBufferInfos = nullptr; + signalSemaphoreInfoCount = copy_src->signalSemaphoreInfoCount; + pSignalSemaphoreInfos = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (waitSemaphoreInfoCount && copy_src->pWaitSemaphoreInfos) { + pWaitSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[waitSemaphoreInfoCount]; + for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) { + pWaitSemaphoreInfos[i].initialize(©_src->pWaitSemaphoreInfos[i]); + } + } + if (commandBufferInfoCount && copy_src->pCommandBufferInfos) { + pCommandBufferInfos = new safe_VkCommandBufferSubmitInfo[commandBufferInfoCount]; + for (uint32_t i = 0; i < commandBufferInfoCount; ++i) { + pCommandBufferInfos[i].initialize(©_src->pCommandBufferInfos[i]); + } + } + if (signalSemaphoreInfoCount && copy_src->pSignalSemaphoreInfos) { + pSignalSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[signalSemaphoreInfoCount]; + for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) { + pSignalSemaphoreInfos[i].initialize(©_src->pSignalSemaphoreInfos[i]); + } + } +} + +safe_VkPhysicalDeviceSynchronization2Features::safe_VkPhysicalDeviceSynchronization2Features( + const VkPhysicalDeviceSynchronization2Features* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), synchronization2(in_struct->synchronization2) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceSynchronization2Features::safe_VkPhysicalDeviceSynchronization2Features() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES), pNext(nullptr), synchronization2() {} + +safe_VkPhysicalDeviceSynchronization2Features::safe_VkPhysicalDeviceSynchronization2Features( + const safe_VkPhysicalDeviceSynchronization2Features& copy_src) { + sType = copy_src.sType; + synchronization2 = copy_src.synchronization2; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceSynchronization2Features& safe_VkPhysicalDeviceSynchronization2Features::operator=( + const safe_VkPhysicalDeviceSynchronization2Features& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + synchronization2 = copy_src.synchronization2; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceSynchronization2Features::~safe_VkPhysicalDeviceSynchronization2Features() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceSynchronization2Features::initialize(const VkPhysicalDeviceSynchronization2Features* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + synchronization2 = in_struct->synchronization2; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceSynchronization2Features::initialize(const safe_VkPhysicalDeviceSynchronization2Features* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + synchronization2 = copy_src->synchronization2; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures( + const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), shaderZeroInitializeWorkgroupMemory(in_struct->shaderZeroInitializeWorkgroupMemory) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES), + pNext(nullptr), + shaderZeroInitializeWorkgroupMemory() {} + +safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures( + const safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& copy_src) { + sType = copy_src.sType; + shaderZeroInitializeWorkgroupMemory = copy_src.shaderZeroInitializeWorkgroupMemory; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::operator=( + const safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderZeroInitializeWorkgroupMemory = copy_src.shaderZeroInitializeWorkgroupMemory; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::~safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::initialize( + const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderZeroInitializeWorkgroupMemory = in_struct->shaderZeroInitializeWorkgroupMemory; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::initialize( + const safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderZeroInitializeWorkgroupMemory = copy_src->shaderZeroInitializeWorkgroupMemory; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceImageRobustnessFeatures::safe_VkPhysicalDeviceImageRobustnessFeatures( + const VkPhysicalDeviceImageRobustnessFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), robustImageAccess(in_struct->robustImageAccess) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceImageRobustnessFeatures::safe_VkPhysicalDeviceImageRobustnessFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES), pNext(nullptr), robustImageAccess() {} + +safe_VkPhysicalDeviceImageRobustnessFeatures::safe_VkPhysicalDeviceImageRobustnessFeatures( + const safe_VkPhysicalDeviceImageRobustnessFeatures& copy_src) { + sType = copy_src.sType; + robustImageAccess = copy_src.robustImageAccess; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceImageRobustnessFeatures& safe_VkPhysicalDeviceImageRobustnessFeatures::operator=( + const safe_VkPhysicalDeviceImageRobustnessFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + robustImageAccess = copy_src.robustImageAccess; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceImageRobustnessFeatures::~safe_VkPhysicalDeviceImageRobustnessFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceImageRobustnessFeatures::initialize(const VkPhysicalDeviceImageRobustnessFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + robustImageAccess = in_struct->robustImageAccess; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceImageRobustnessFeatures::initialize(const safe_VkPhysicalDeviceImageRobustnessFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + robustImageAccess = copy_src->robustImageAccess; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBufferCopy2::safe_VkBufferCopy2(const VkBufferCopy2* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), srcOffset(in_struct->srcOffset), dstOffset(in_struct->dstOffset), size(in_struct->size) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBufferCopy2::safe_VkBufferCopy2() + : sType(VK_STRUCTURE_TYPE_BUFFER_COPY_2), pNext(nullptr), srcOffset(), dstOffset(), size() {} + +safe_VkBufferCopy2::safe_VkBufferCopy2(const safe_VkBufferCopy2& copy_src) { + sType = copy_src.sType; + srcOffset = copy_src.srcOffset; + dstOffset = copy_src.dstOffset; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBufferCopy2& safe_VkBufferCopy2::operator=(const safe_VkBufferCopy2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + srcOffset = copy_src.srcOffset; + dstOffset = copy_src.dstOffset; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBufferCopy2::~safe_VkBufferCopy2() { FreePnextChain(pNext); } + +void safe_VkBufferCopy2::initialize(const VkBufferCopy2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + srcOffset = in_struct->srcOffset; + dstOffset = in_struct->dstOffset; + size = in_struct->size; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBufferCopy2::initialize(const safe_VkBufferCopy2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcOffset = copy_src->srcOffset; + dstOffset = copy_src->dstOffset; + size = copy_src->size; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCopyBufferInfo2::safe_VkCopyBufferInfo2(const VkCopyBufferInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + srcBuffer(in_struct->srcBuffer), + dstBuffer(in_struct->dstBuffer), + regionCount(in_struct->regionCount), + pRegions(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkBufferCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +safe_VkCopyBufferInfo2::safe_VkCopyBufferInfo2() + : sType(VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2), pNext(nullptr), srcBuffer(), dstBuffer(), regionCount(), pRegions(nullptr) {} + +safe_VkCopyBufferInfo2::safe_VkCopyBufferInfo2(const safe_VkCopyBufferInfo2& copy_src) { + sType = copy_src.sType; + srcBuffer = copy_src.srcBuffer; + dstBuffer = copy_src.dstBuffer; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkBufferCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } +} + +safe_VkCopyBufferInfo2& safe_VkCopyBufferInfo2::operator=(const safe_VkCopyBufferInfo2& copy_src) { + if (©_src == this) return *this; + + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + + sType = copy_src.sType; + srcBuffer = copy_src.srcBuffer; + dstBuffer = copy_src.dstBuffer; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkBufferCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } + + return *this; +} + +safe_VkCopyBufferInfo2::~safe_VkCopyBufferInfo2() { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); +} + +void safe_VkCopyBufferInfo2::initialize(const VkCopyBufferInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + sType = in_struct->sType; + srcBuffer = in_struct->srcBuffer; + dstBuffer = in_struct->dstBuffer; + regionCount = in_struct->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkBufferCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +void safe_VkCopyBufferInfo2::initialize(const safe_VkCopyBufferInfo2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcBuffer = copy_src->srcBuffer; + dstBuffer = copy_src->dstBuffer; + regionCount = copy_src->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (regionCount && copy_src->pRegions) { + pRegions = new safe_VkBufferCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src->pRegions[i]); + } + } +} + +safe_VkImageCopy2::safe_VkImageCopy2(const VkImageCopy2* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + srcSubresource(in_struct->srcSubresource), + srcOffset(in_struct->srcOffset), + dstSubresource(in_struct->dstSubresource), + dstOffset(in_struct->dstOffset), + extent(in_struct->extent) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageCopy2::safe_VkImageCopy2() + : sType(VK_STRUCTURE_TYPE_IMAGE_COPY_2), + pNext(nullptr), + srcSubresource(), + srcOffset(), + dstSubresource(), + dstOffset(), + extent() {} + +safe_VkImageCopy2::safe_VkImageCopy2(const safe_VkImageCopy2& copy_src) { + sType = copy_src.sType; + srcSubresource = copy_src.srcSubresource; + srcOffset = copy_src.srcOffset; + dstSubresource = copy_src.dstSubresource; + dstOffset = copy_src.dstOffset; + extent = copy_src.extent; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageCopy2& safe_VkImageCopy2::operator=(const safe_VkImageCopy2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + srcSubresource = copy_src.srcSubresource; + srcOffset = copy_src.srcOffset; + dstSubresource = copy_src.dstSubresource; + dstOffset = copy_src.dstOffset; + extent = copy_src.extent; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageCopy2::~safe_VkImageCopy2() { FreePnextChain(pNext); } + +void safe_VkImageCopy2::initialize(const VkImageCopy2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + srcSubresource = in_struct->srcSubresource; + srcOffset = in_struct->srcOffset; + dstSubresource = in_struct->dstSubresource; + dstOffset = in_struct->dstOffset; + extent = in_struct->extent; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageCopy2::initialize(const safe_VkImageCopy2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcSubresource = copy_src->srcSubresource; + srcOffset = copy_src->srcOffset; + dstSubresource = copy_src->dstSubresource; + dstOffset = copy_src->dstOffset; + extent = copy_src->extent; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCopyImageInfo2::safe_VkCopyImageInfo2(const VkCopyImageInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + srcImage(in_struct->srcImage), + srcImageLayout(in_struct->srcImageLayout), + dstImage(in_struct->dstImage), + dstImageLayout(in_struct->dstImageLayout), + regionCount(in_struct->regionCount), + pRegions(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +safe_VkCopyImageInfo2::safe_VkCopyImageInfo2() + : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2), + pNext(nullptr), + srcImage(), + srcImageLayout(), + dstImage(), + dstImageLayout(), + regionCount(), + pRegions(nullptr) {} + +safe_VkCopyImageInfo2::safe_VkCopyImageInfo2(const safe_VkCopyImageInfo2& copy_src) { + sType = copy_src.sType; + srcImage = copy_src.srcImage; + srcImageLayout = copy_src.srcImageLayout; + dstImage = copy_src.dstImage; + dstImageLayout = copy_src.dstImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } +} + +safe_VkCopyImageInfo2& safe_VkCopyImageInfo2::operator=(const safe_VkCopyImageInfo2& copy_src) { + if (©_src == this) return *this; + + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + + sType = copy_src.sType; + srcImage = copy_src.srcImage; + srcImageLayout = copy_src.srcImageLayout; + dstImage = copy_src.dstImage; + dstImageLayout = copy_src.dstImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } + + return *this; +} + +safe_VkCopyImageInfo2::~safe_VkCopyImageInfo2() { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); +} + +void safe_VkCopyImageInfo2::initialize(const VkCopyImageInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + sType = in_struct->sType; + srcImage = in_struct->srcImage; + srcImageLayout = in_struct->srcImageLayout; + dstImage = in_struct->dstImage; + dstImageLayout = in_struct->dstImageLayout; + regionCount = in_struct->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +void safe_VkCopyImageInfo2::initialize(const safe_VkCopyImageInfo2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcImage = copy_src->srcImage; + srcImageLayout = copy_src->srcImageLayout; + dstImage = copy_src->dstImage; + dstImageLayout = copy_src->dstImageLayout; + regionCount = copy_src->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (regionCount && copy_src->pRegions) { + pRegions = new safe_VkImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src->pRegions[i]); + } + } +} + +safe_VkBufferImageCopy2::safe_VkBufferImageCopy2(const VkBufferImageCopy2* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + bufferOffset(in_struct->bufferOffset), + bufferRowLength(in_struct->bufferRowLength), + bufferImageHeight(in_struct->bufferImageHeight), + imageSubresource(in_struct->imageSubresource), + imageOffset(in_struct->imageOffset), + imageExtent(in_struct->imageExtent) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBufferImageCopy2::safe_VkBufferImageCopy2() + : sType(VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2), + pNext(nullptr), + bufferOffset(), + bufferRowLength(), + bufferImageHeight(), + imageSubresource(), + imageOffset(), + imageExtent() {} + +safe_VkBufferImageCopy2::safe_VkBufferImageCopy2(const safe_VkBufferImageCopy2& copy_src) { + sType = copy_src.sType; + bufferOffset = copy_src.bufferOffset; + bufferRowLength = copy_src.bufferRowLength; + bufferImageHeight = copy_src.bufferImageHeight; + imageSubresource = copy_src.imageSubresource; + imageOffset = copy_src.imageOffset; + imageExtent = copy_src.imageExtent; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBufferImageCopy2& safe_VkBufferImageCopy2::operator=(const safe_VkBufferImageCopy2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + bufferOffset = copy_src.bufferOffset; + bufferRowLength = copy_src.bufferRowLength; + bufferImageHeight = copy_src.bufferImageHeight; + imageSubresource = copy_src.imageSubresource; + imageOffset = copy_src.imageOffset; + imageExtent = copy_src.imageExtent; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBufferImageCopy2::~safe_VkBufferImageCopy2() { FreePnextChain(pNext); } + +void safe_VkBufferImageCopy2::initialize(const VkBufferImageCopy2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + bufferOffset = in_struct->bufferOffset; + bufferRowLength = in_struct->bufferRowLength; + bufferImageHeight = in_struct->bufferImageHeight; + imageSubresource = in_struct->imageSubresource; + imageOffset = in_struct->imageOffset; + imageExtent = in_struct->imageExtent; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBufferImageCopy2::initialize(const safe_VkBufferImageCopy2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + bufferOffset = copy_src->bufferOffset; + bufferRowLength = copy_src->bufferRowLength; + bufferImageHeight = copy_src->bufferImageHeight; + imageSubresource = copy_src->imageSubresource; + imageOffset = copy_src->imageOffset; + imageExtent = copy_src->imageExtent; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCopyBufferToImageInfo2::safe_VkCopyBufferToImageInfo2(const VkCopyBufferToImageInfo2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + srcBuffer(in_struct->srcBuffer), + dstImage(in_struct->dstImage), + dstImageLayout(in_struct->dstImageLayout), + regionCount(in_struct->regionCount), + pRegions(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkBufferImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +safe_VkCopyBufferToImageInfo2::safe_VkCopyBufferToImageInfo2() + : sType(VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2), + pNext(nullptr), + srcBuffer(), + dstImage(), + dstImageLayout(), + regionCount(), + pRegions(nullptr) {} + +safe_VkCopyBufferToImageInfo2::safe_VkCopyBufferToImageInfo2(const safe_VkCopyBufferToImageInfo2& copy_src) { + sType = copy_src.sType; + srcBuffer = copy_src.srcBuffer; + dstImage = copy_src.dstImage; + dstImageLayout = copy_src.dstImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkBufferImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } +} + +safe_VkCopyBufferToImageInfo2& safe_VkCopyBufferToImageInfo2::operator=(const safe_VkCopyBufferToImageInfo2& copy_src) { + if (©_src == this) return *this; + + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + + sType = copy_src.sType; + srcBuffer = copy_src.srcBuffer; + dstImage = copy_src.dstImage; + dstImageLayout = copy_src.dstImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkBufferImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } + + return *this; +} + +safe_VkCopyBufferToImageInfo2::~safe_VkCopyBufferToImageInfo2() { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); +} + +void safe_VkCopyBufferToImageInfo2::initialize(const VkCopyBufferToImageInfo2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + sType = in_struct->sType; + srcBuffer = in_struct->srcBuffer; + dstImage = in_struct->dstImage; + dstImageLayout = in_struct->dstImageLayout; + regionCount = in_struct->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkBufferImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +void safe_VkCopyBufferToImageInfo2::initialize(const safe_VkCopyBufferToImageInfo2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcBuffer = copy_src->srcBuffer; + dstImage = copy_src->dstImage; + dstImageLayout = copy_src->dstImageLayout; + regionCount = copy_src->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (regionCount && copy_src->pRegions) { + pRegions = new safe_VkBufferImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src->pRegions[i]); + } + } +} + +safe_VkCopyImageToBufferInfo2::safe_VkCopyImageToBufferInfo2(const VkCopyImageToBufferInfo2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + srcImage(in_struct->srcImage), + srcImageLayout(in_struct->srcImageLayout), + dstBuffer(in_struct->dstBuffer), + regionCount(in_struct->regionCount), + pRegions(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkBufferImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +safe_VkCopyImageToBufferInfo2::safe_VkCopyImageToBufferInfo2() + : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2), + pNext(nullptr), + srcImage(), + srcImageLayout(), + dstBuffer(), + regionCount(), + pRegions(nullptr) {} + +safe_VkCopyImageToBufferInfo2::safe_VkCopyImageToBufferInfo2(const safe_VkCopyImageToBufferInfo2& copy_src) { + sType = copy_src.sType; + srcImage = copy_src.srcImage; + srcImageLayout = copy_src.srcImageLayout; + dstBuffer = copy_src.dstBuffer; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkBufferImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } +} + +safe_VkCopyImageToBufferInfo2& safe_VkCopyImageToBufferInfo2::operator=(const safe_VkCopyImageToBufferInfo2& copy_src) { + if (©_src == this) return *this; + + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + + sType = copy_src.sType; + srcImage = copy_src.srcImage; + srcImageLayout = copy_src.srcImageLayout; + dstBuffer = copy_src.dstBuffer; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkBufferImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } + + return *this; +} + +safe_VkCopyImageToBufferInfo2::~safe_VkCopyImageToBufferInfo2() { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); +} + +void safe_VkCopyImageToBufferInfo2::initialize(const VkCopyImageToBufferInfo2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + sType = in_struct->sType; + srcImage = in_struct->srcImage; + srcImageLayout = in_struct->srcImageLayout; + dstBuffer = in_struct->dstBuffer; + regionCount = in_struct->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkBufferImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +void safe_VkCopyImageToBufferInfo2::initialize(const safe_VkCopyImageToBufferInfo2* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcImage = copy_src->srcImage; + srcImageLayout = copy_src->srcImageLayout; + dstBuffer = copy_src->dstBuffer; + regionCount = copy_src->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (regionCount && copy_src->pRegions) { + pRegions = new safe_VkBufferImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src->pRegions[i]); + } + } +} + +safe_VkImageBlit2::safe_VkImageBlit2(const VkImageBlit2* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), srcSubresource(in_struct->srcSubresource), dstSubresource(in_struct->dstSubresource) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < 2; ++i) { + srcOffsets[i] = in_struct->srcOffsets[i]; + } + + for (uint32_t i = 0; i < 2; ++i) { + dstOffsets[i] = in_struct->dstOffsets[i]; + } +} + +safe_VkImageBlit2::safe_VkImageBlit2() + : sType(VK_STRUCTURE_TYPE_IMAGE_BLIT_2), pNext(nullptr), srcSubresource(), dstSubresource() {} + +safe_VkImageBlit2::safe_VkImageBlit2(const safe_VkImageBlit2& copy_src) { + sType = copy_src.sType; + srcSubresource = copy_src.srcSubresource; + dstSubresource = copy_src.dstSubresource; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < 2; ++i) { + srcOffsets[i] = copy_src.srcOffsets[i]; + } + + for (uint32_t i = 0; i < 2; ++i) { + dstOffsets[i] = copy_src.dstOffsets[i]; + } +} + +safe_VkImageBlit2& safe_VkImageBlit2::operator=(const safe_VkImageBlit2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + srcSubresource = copy_src.srcSubresource; + dstSubresource = copy_src.dstSubresource; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < 2; ++i) { + srcOffsets[i] = copy_src.srcOffsets[i]; + } + + for (uint32_t i = 0; i < 2; ++i) { + dstOffsets[i] = copy_src.dstOffsets[i]; + } + + return *this; +} + +safe_VkImageBlit2::~safe_VkImageBlit2() { FreePnextChain(pNext); } + +void safe_VkImageBlit2::initialize(const VkImageBlit2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + srcSubresource = in_struct->srcSubresource; + dstSubresource = in_struct->dstSubresource; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < 2; ++i) { + srcOffsets[i] = in_struct->srcOffsets[i]; + } + + for (uint32_t i = 0; i < 2; ++i) { + dstOffsets[i] = in_struct->dstOffsets[i]; + } +} + +void safe_VkImageBlit2::initialize(const safe_VkImageBlit2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcSubresource = copy_src->srcSubresource; + dstSubresource = copy_src->dstSubresource; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < 2; ++i) { + srcOffsets[i] = copy_src->srcOffsets[i]; + } + + for (uint32_t i = 0; i < 2; ++i) { + dstOffsets[i] = copy_src->dstOffsets[i]; + } +} + +safe_VkBlitImageInfo2::safe_VkBlitImageInfo2(const VkBlitImageInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + srcImage(in_struct->srcImage), + srcImageLayout(in_struct->srcImageLayout), + dstImage(in_struct->dstImage), + dstImageLayout(in_struct->dstImageLayout), + regionCount(in_struct->regionCount), + pRegions(nullptr), + filter(in_struct->filter) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkImageBlit2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +safe_VkBlitImageInfo2::safe_VkBlitImageInfo2() + : sType(VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2), + pNext(nullptr), + srcImage(), + srcImageLayout(), + dstImage(), + dstImageLayout(), + regionCount(), + pRegions(nullptr), + filter() {} + +safe_VkBlitImageInfo2::safe_VkBlitImageInfo2(const safe_VkBlitImageInfo2& copy_src) { + sType = copy_src.sType; + srcImage = copy_src.srcImage; + srcImageLayout = copy_src.srcImageLayout; + dstImage = copy_src.dstImage; + dstImageLayout = copy_src.dstImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + filter = copy_src.filter; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkImageBlit2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } +} + +safe_VkBlitImageInfo2& safe_VkBlitImageInfo2::operator=(const safe_VkBlitImageInfo2& copy_src) { + if (©_src == this) return *this; + + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + + sType = copy_src.sType; + srcImage = copy_src.srcImage; + srcImageLayout = copy_src.srcImageLayout; + dstImage = copy_src.dstImage; + dstImageLayout = copy_src.dstImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + filter = copy_src.filter; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkImageBlit2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } + + return *this; +} + +safe_VkBlitImageInfo2::~safe_VkBlitImageInfo2() { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); +} + +void safe_VkBlitImageInfo2::initialize(const VkBlitImageInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + sType = in_struct->sType; + srcImage = in_struct->srcImage; + srcImageLayout = in_struct->srcImageLayout; + dstImage = in_struct->dstImage; + dstImageLayout = in_struct->dstImageLayout; + regionCount = in_struct->regionCount; + pRegions = nullptr; + filter = in_struct->filter; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkImageBlit2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +void safe_VkBlitImageInfo2::initialize(const safe_VkBlitImageInfo2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcImage = copy_src->srcImage; + srcImageLayout = copy_src->srcImageLayout; + dstImage = copy_src->dstImage; + dstImageLayout = copy_src->dstImageLayout; + regionCount = copy_src->regionCount; + pRegions = nullptr; + filter = copy_src->filter; + pNext = SafePnextCopy(copy_src->pNext); + if (regionCount && copy_src->pRegions) { + pRegions = new safe_VkImageBlit2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src->pRegions[i]); + } + } +} + +safe_VkImageResolve2::safe_VkImageResolve2(const VkImageResolve2* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + srcSubresource(in_struct->srcSubresource), + srcOffset(in_struct->srcOffset), + dstSubresource(in_struct->dstSubresource), + dstOffset(in_struct->dstOffset), + extent(in_struct->extent) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageResolve2::safe_VkImageResolve2() + : sType(VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2), + pNext(nullptr), + srcSubresource(), + srcOffset(), + dstSubresource(), + dstOffset(), + extent() {} + +safe_VkImageResolve2::safe_VkImageResolve2(const safe_VkImageResolve2& copy_src) { + sType = copy_src.sType; + srcSubresource = copy_src.srcSubresource; + srcOffset = copy_src.srcOffset; + dstSubresource = copy_src.dstSubresource; + dstOffset = copy_src.dstOffset; + extent = copy_src.extent; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageResolve2& safe_VkImageResolve2::operator=(const safe_VkImageResolve2& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + srcSubresource = copy_src.srcSubresource; + srcOffset = copy_src.srcOffset; + dstSubresource = copy_src.dstSubresource; + dstOffset = copy_src.dstOffset; + extent = copy_src.extent; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageResolve2::~safe_VkImageResolve2() { FreePnextChain(pNext); } + +void safe_VkImageResolve2::initialize(const VkImageResolve2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + srcSubresource = in_struct->srcSubresource; + srcOffset = in_struct->srcOffset; + dstSubresource = in_struct->dstSubresource; + dstOffset = in_struct->dstOffset; + extent = in_struct->extent; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageResolve2::initialize(const safe_VkImageResolve2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcSubresource = copy_src->srcSubresource; + srcOffset = copy_src->srcOffset; + dstSubresource = copy_src->dstSubresource; + dstOffset = copy_src->dstOffset; + extent = copy_src->extent; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkResolveImageInfo2::safe_VkResolveImageInfo2(const VkResolveImageInfo2* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + srcImage(in_struct->srcImage), + srcImageLayout(in_struct->srcImageLayout), + dstImage(in_struct->dstImage), + dstImageLayout(in_struct->dstImageLayout), + regionCount(in_struct->regionCount), + pRegions(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkImageResolve2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +safe_VkResolveImageInfo2::safe_VkResolveImageInfo2() + : sType(VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2), + pNext(nullptr), + srcImage(), + srcImageLayout(), + dstImage(), + dstImageLayout(), + regionCount(), + pRegions(nullptr) {} + +safe_VkResolveImageInfo2::safe_VkResolveImageInfo2(const safe_VkResolveImageInfo2& copy_src) { + sType = copy_src.sType; + srcImage = copy_src.srcImage; + srcImageLayout = copy_src.srcImageLayout; + dstImage = copy_src.dstImage; + dstImageLayout = copy_src.dstImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkImageResolve2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } +} + +safe_VkResolveImageInfo2& safe_VkResolveImageInfo2::operator=(const safe_VkResolveImageInfo2& copy_src) { + if (©_src == this) return *this; + + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + + sType = copy_src.sType; + srcImage = copy_src.srcImage; + srcImageLayout = copy_src.srcImageLayout; + dstImage = copy_src.dstImage; + dstImageLayout = copy_src.dstImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkImageResolve2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } + + return *this; +} + +safe_VkResolveImageInfo2::~safe_VkResolveImageInfo2() { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); +} + +void safe_VkResolveImageInfo2::initialize(const VkResolveImageInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + sType = in_struct->sType; + srcImage = in_struct->srcImage; + srcImageLayout = in_struct->srcImageLayout; + dstImage = in_struct->dstImage; + dstImageLayout = in_struct->dstImageLayout; + regionCount = in_struct->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkImageResolve2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +void safe_VkResolveImageInfo2::initialize(const safe_VkResolveImageInfo2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcImage = copy_src->srcImage; + srcImageLayout = copy_src->srcImageLayout; + dstImage = copy_src->dstImage; + dstImageLayout = copy_src->dstImageLayout; + regionCount = copy_src->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (regionCount && copy_src->pRegions) { + pRegions = new safe_VkImageResolve2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src->pRegions[i]); + } + } +} + +safe_VkPhysicalDeviceSubgroupSizeControlFeatures::safe_VkPhysicalDeviceSubgroupSizeControlFeatures( + const VkPhysicalDeviceSubgroupSizeControlFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + subgroupSizeControl(in_struct->subgroupSizeControl), + computeFullSubgroups(in_struct->computeFullSubgroups) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceSubgroupSizeControlFeatures::safe_VkPhysicalDeviceSubgroupSizeControlFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES), + pNext(nullptr), + subgroupSizeControl(), + computeFullSubgroups() {} + +safe_VkPhysicalDeviceSubgroupSizeControlFeatures::safe_VkPhysicalDeviceSubgroupSizeControlFeatures( + const safe_VkPhysicalDeviceSubgroupSizeControlFeatures& copy_src) { + sType = copy_src.sType; + subgroupSizeControl = copy_src.subgroupSizeControl; + computeFullSubgroups = copy_src.computeFullSubgroups; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceSubgroupSizeControlFeatures& safe_VkPhysicalDeviceSubgroupSizeControlFeatures::operator=( + const safe_VkPhysicalDeviceSubgroupSizeControlFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + subgroupSizeControl = copy_src.subgroupSizeControl; + computeFullSubgroups = copy_src.computeFullSubgroups; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceSubgroupSizeControlFeatures::~safe_VkPhysicalDeviceSubgroupSizeControlFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceSubgroupSizeControlFeatures::initialize(const VkPhysicalDeviceSubgroupSizeControlFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + subgroupSizeControl = in_struct->subgroupSizeControl; + computeFullSubgroups = in_struct->computeFullSubgroups; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceSubgroupSizeControlFeatures::initialize(const safe_VkPhysicalDeviceSubgroupSizeControlFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + subgroupSizeControl = copy_src->subgroupSizeControl; + computeFullSubgroups = copy_src->computeFullSubgroups; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceSubgroupSizeControlProperties::safe_VkPhysicalDeviceSubgroupSizeControlProperties( + const VkPhysicalDeviceSubgroupSizeControlProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + minSubgroupSize(in_struct->minSubgroupSize), + maxSubgroupSize(in_struct->maxSubgroupSize), + maxComputeWorkgroupSubgroups(in_struct->maxComputeWorkgroupSubgroups), + requiredSubgroupSizeStages(in_struct->requiredSubgroupSizeStages) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceSubgroupSizeControlProperties::safe_VkPhysicalDeviceSubgroupSizeControlProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES), + pNext(nullptr), + minSubgroupSize(), + maxSubgroupSize(), + maxComputeWorkgroupSubgroups(), + requiredSubgroupSizeStages() {} + +safe_VkPhysicalDeviceSubgroupSizeControlProperties::safe_VkPhysicalDeviceSubgroupSizeControlProperties( + const safe_VkPhysicalDeviceSubgroupSizeControlProperties& copy_src) { + sType = copy_src.sType; + minSubgroupSize = copy_src.minSubgroupSize; + maxSubgroupSize = copy_src.maxSubgroupSize; + maxComputeWorkgroupSubgroups = copy_src.maxComputeWorkgroupSubgroups; + requiredSubgroupSizeStages = copy_src.requiredSubgroupSizeStages; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceSubgroupSizeControlProperties& safe_VkPhysicalDeviceSubgroupSizeControlProperties::operator=( + const safe_VkPhysicalDeviceSubgroupSizeControlProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + minSubgroupSize = copy_src.minSubgroupSize; + maxSubgroupSize = copy_src.maxSubgroupSize; + maxComputeWorkgroupSubgroups = copy_src.maxComputeWorkgroupSubgroups; + requiredSubgroupSizeStages = copy_src.requiredSubgroupSizeStages; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceSubgroupSizeControlProperties::~safe_VkPhysicalDeviceSubgroupSizeControlProperties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceSubgroupSizeControlProperties::initialize(const VkPhysicalDeviceSubgroupSizeControlProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + minSubgroupSize = in_struct->minSubgroupSize; + maxSubgroupSize = in_struct->maxSubgroupSize; + maxComputeWorkgroupSubgroups = in_struct->maxComputeWorkgroupSubgroups; + requiredSubgroupSizeStages = in_struct->requiredSubgroupSizeStages; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceSubgroupSizeControlProperties::initialize( + const safe_VkPhysicalDeviceSubgroupSizeControlProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + minSubgroupSize = copy_src->minSubgroupSize; + maxSubgroupSize = copy_src->maxSubgroupSize; + maxComputeWorkgroupSubgroups = copy_src->maxComputeWorkgroupSubgroups; + requiredSubgroupSizeStages = copy_src->requiredSubgroupSizeStages; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo::safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo( + const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), requiredSubgroupSize(in_struct->requiredSubgroupSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo::safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO), pNext(nullptr), requiredSubgroupSize() {} + +safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo::safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo( + const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& copy_src) { + sType = copy_src.sType; + requiredSubgroupSize = copy_src.requiredSubgroupSize; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo::operator=( + const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + requiredSubgroupSize = copy_src.requiredSubgroupSize; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo::~safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo() { + FreePnextChain(pNext); +} + +void safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo::initialize( + const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + requiredSubgroupSize = in_struct->requiredSubgroupSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo::initialize( + const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + requiredSubgroupSize = copy_src->requiredSubgroupSize; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceInlineUniformBlockFeatures::safe_VkPhysicalDeviceInlineUniformBlockFeatures( + const VkPhysicalDeviceInlineUniformBlockFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + inlineUniformBlock(in_struct->inlineUniformBlock), + descriptorBindingInlineUniformBlockUpdateAfterBind(in_struct->descriptorBindingInlineUniformBlockUpdateAfterBind) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceInlineUniformBlockFeatures::safe_VkPhysicalDeviceInlineUniformBlockFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES), + pNext(nullptr), + inlineUniformBlock(), + descriptorBindingInlineUniformBlockUpdateAfterBind() {} + +safe_VkPhysicalDeviceInlineUniformBlockFeatures::safe_VkPhysicalDeviceInlineUniformBlockFeatures( + const safe_VkPhysicalDeviceInlineUniformBlockFeatures& copy_src) { + sType = copy_src.sType; + inlineUniformBlock = copy_src.inlineUniformBlock; + descriptorBindingInlineUniformBlockUpdateAfterBind = copy_src.descriptorBindingInlineUniformBlockUpdateAfterBind; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceInlineUniformBlockFeatures& safe_VkPhysicalDeviceInlineUniformBlockFeatures::operator=( + const safe_VkPhysicalDeviceInlineUniformBlockFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + inlineUniformBlock = copy_src.inlineUniformBlock; + descriptorBindingInlineUniformBlockUpdateAfterBind = copy_src.descriptorBindingInlineUniformBlockUpdateAfterBind; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceInlineUniformBlockFeatures::~safe_VkPhysicalDeviceInlineUniformBlockFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceInlineUniformBlockFeatures::initialize(const VkPhysicalDeviceInlineUniformBlockFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + inlineUniformBlock = in_struct->inlineUniformBlock; + descriptorBindingInlineUniformBlockUpdateAfterBind = in_struct->descriptorBindingInlineUniformBlockUpdateAfterBind; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceInlineUniformBlockFeatures::initialize(const safe_VkPhysicalDeviceInlineUniformBlockFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + inlineUniformBlock = copy_src->inlineUniformBlock; + descriptorBindingInlineUniformBlockUpdateAfterBind = copy_src->descriptorBindingInlineUniformBlockUpdateAfterBind; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceInlineUniformBlockProperties::safe_VkPhysicalDeviceInlineUniformBlockProperties( + const VkPhysicalDeviceInlineUniformBlockProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + maxInlineUniformBlockSize(in_struct->maxInlineUniformBlockSize), + maxPerStageDescriptorInlineUniformBlocks(in_struct->maxPerStageDescriptorInlineUniformBlocks), + maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks(in_struct->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks), + maxDescriptorSetInlineUniformBlocks(in_struct->maxDescriptorSetInlineUniformBlocks), + maxDescriptorSetUpdateAfterBindInlineUniformBlocks(in_struct->maxDescriptorSetUpdateAfterBindInlineUniformBlocks) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceInlineUniformBlockProperties::safe_VkPhysicalDeviceInlineUniformBlockProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES), + pNext(nullptr), + maxInlineUniformBlockSize(), + maxPerStageDescriptorInlineUniformBlocks(), + maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks(), + maxDescriptorSetInlineUniformBlocks(), + maxDescriptorSetUpdateAfterBindInlineUniformBlocks() {} + +safe_VkPhysicalDeviceInlineUniformBlockProperties::safe_VkPhysicalDeviceInlineUniformBlockProperties( + const safe_VkPhysicalDeviceInlineUniformBlockProperties& copy_src) { + sType = copy_src.sType; + maxInlineUniformBlockSize = copy_src.maxInlineUniformBlockSize; + maxPerStageDescriptorInlineUniformBlocks = copy_src.maxPerStageDescriptorInlineUniformBlocks; + maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = copy_src.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + maxDescriptorSetInlineUniformBlocks = copy_src.maxDescriptorSetInlineUniformBlocks; + maxDescriptorSetUpdateAfterBindInlineUniformBlocks = copy_src.maxDescriptorSetUpdateAfterBindInlineUniformBlocks; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceInlineUniformBlockProperties& safe_VkPhysicalDeviceInlineUniformBlockProperties::operator=( + const safe_VkPhysicalDeviceInlineUniformBlockProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxInlineUniformBlockSize = copy_src.maxInlineUniformBlockSize; + maxPerStageDescriptorInlineUniformBlocks = copy_src.maxPerStageDescriptorInlineUniformBlocks; + maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = copy_src.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + maxDescriptorSetInlineUniformBlocks = copy_src.maxDescriptorSetInlineUniformBlocks; + maxDescriptorSetUpdateAfterBindInlineUniformBlocks = copy_src.maxDescriptorSetUpdateAfterBindInlineUniformBlocks; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceInlineUniformBlockProperties::~safe_VkPhysicalDeviceInlineUniformBlockProperties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceInlineUniformBlockProperties::initialize(const VkPhysicalDeviceInlineUniformBlockProperties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxInlineUniformBlockSize = in_struct->maxInlineUniformBlockSize; + maxPerStageDescriptorInlineUniformBlocks = in_struct->maxPerStageDescriptorInlineUniformBlocks; + maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_struct->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + maxDescriptorSetInlineUniformBlocks = in_struct->maxDescriptorSetInlineUniformBlocks; + maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_struct->maxDescriptorSetUpdateAfterBindInlineUniformBlocks; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceInlineUniformBlockProperties::initialize( + const safe_VkPhysicalDeviceInlineUniformBlockProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxInlineUniformBlockSize = copy_src->maxInlineUniformBlockSize; + maxPerStageDescriptorInlineUniformBlocks = copy_src->maxPerStageDescriptorInlineUniformBlocks; + maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = copy_src->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + maxDescriptorSetInlineUniformBlocks = copy_src->maxDescriptorSetInlineUniformBlocks; + maxDescriptorSetUpdateAfterBindInlineUniformBlocks = copy_src->maxDescriptorSetUpdateAfterBindInlineUniformBlocks; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkWriteDescriptorSetInlineUniformBlock::safe_VkWriteDescriptorSetInlineUniformBlock( + const VkWriteDescriptorSetInlineUniformBlock* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), dataSize(in_struct->dataSize), pData(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + 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_VkWriteDescriptorSetInlineUniformBlock::safe_VkWriteDescriptorSetInlineUniformBlock() + : sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK), pNext(nullptr), dataSize(), pData(nullptr) {} + +safe_VkWriteDescriptorSetInlineUniformBlock::safe_VkWriteDescriptorSetInlineUniformBlock( + const safe_VkWriteDescriptorSetInlineUniformBlock& copy_src) { + sType = copy_src.sType; + dataSize = copy_src.dataSize; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pData != nullptr) { + auto temp = new std::byte[copy_src.dataSize]; + std::memcpy(temp, copy_src.pData, copy_src.dataSize); + pData = temp; + } +} + +safe_VkWriteDescriptorSetInlineUniformBlock& safe_VkWriteDescriptorSetInlineUniformBlock::operator=( + const safe_VkWriteDescriptorSetInlineUniformBlock& copy_src) { + if (©_src == this) return *this; + + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + FreePnextChain(pNext); + + sType = copy_src.sType; + dataSize = copy_src.dataSize; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pData != nullptr) { + auto temp = new std::byte[copy_src.dataSize]; + std::memcpy(temp, copy_src.pData, copy_src.dataSize); + pData = temp; + } + + return *this; +} + +safe_VkWriteDescriptorSetInlineUniformBlock::~safe_VkWriteDescriptorSetInlineUniformBlock() { + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + FreePnextChain(pNext); +} + +void safe_VkWriteDescriptorSetInlineUniformBlock::initialize(const VkWriteDescriptorSetInlineUniformBlock* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + FreePnextChain(pNext); + sType = in_struct->sType; + dataSize = in_struct->dataSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + 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_VkWriteDescriptorSetInlineUniformBlock::initialize(const safe_VkWriteDescriptorSetInlineUniformBlock* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + dataSize = copy_src->dataSize; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pData != nullptr) { + auto temp = new std::byte[copy_src->dataSize]; + std::memcpy(temp, copy_src->pData, copy_src->dataSize); + pData = temp; + } +} + +safe_VkDescriptorPoolInlineUniformBlockCreateInfo::safe_VkDescriptorPoolInlineUniformBlockCreateInfo( + const VkDescriptorPoolInlineUniformBlockCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), maxInlineUniformBlockBindings(in_struct->maxInlineUniformBlockBindings) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDescriptorPoolInlineUniformBlockCreateInfo::safe_VkDescriptorPoolInlineUniformBlockCreateInfo() + : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO), pNext(nullptr), maxInlineUniformBlockBindings() {} + +safe_VkDescriptorPoolInlineUniformBlockCreateInfo::safe_VkDescriptorPoolInlineUniformBlockCreateInfo( + const safe_VkDescriptorPoolInlineUniformBlockCreateInfo& copy_src) { + sType = copy_src.sType; + maxInlineUniformBlockBindings = copy_src.maxInlineUniformBlockBindings; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDescriptorPoolInlineUniformBlockCreateInfo& safe_VkDescriptorPoolInlineUniformBlockCreateInfo::operator=( + const safe_VkDescriptorPoolInlineUniformBlockCreateInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxInlineUniformBlockBindings = copy_src.maxInlineUniformBlockBindings; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDescriptorPoolInlineUniformBlockCreateInfo::~safe_VkDescriptorPoolInlineUniformBlockCreateInfo() { FreePnextChain(pNext); } + +void safe_VkDescriptorPoolInlineUniformBlockCreateInfo::initialize(const VkDescriptorPoolInlineUniformBlockCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxInlineUniformBlockBindings = in_struct->maxInlineUniformBlockBindings; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDescriptorPoolInlineUniformBlockCreateInfo::initialize( + const safe_VkDescriptorPoolInlineUniformBlockCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxInlineUniformBlockBindings = copy_src->maxInlineUniformBlockBindings; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures::safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures( + const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), textureCompressionASTC_HDR(in_struct->textureCompressionASTC_HDR) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures::safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES), + pNext(nullptr), + textureCompressionASTC_HDR() {} + +safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures::safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures( + const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures& copy_src) { + sType = copy_src.sType; + textureCompressionASTC_HDR = copy_src.textureCompressionASTC_HDR; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures& safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures::operator=( + const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + textureCompressionASTC_HDR = copy_src.textureCompressionASTC_HDR; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures::~safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures::initialize( + const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + textureCompressionASTC_HDR = in_struct->textureCompressionASTC_HDR; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures::initialize( + const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + textureCompressionASTC_HDR = copy_src->textureCompressionASTC_HDR; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkRenderingAttachmentInfo::safe_VkRenderingAttachmentInfo(const VkRenderingAttachmentInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + imageView(in_struct->imageView), + imageLayout(in_struct->imageLayout), + resolveMode(in_struct->resolveMode), + resolveImageView(in_struct->resolveImageView), + resolveImageLayout(in_struct->resolveImageLayout), + loadOp(in_struct->loadOp), + storeOp(in_struct->storeOp), + clearValue(in_struct->clearValue) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkRenderingAttachmentInfo::safe_VkRenderingAttachmentInfo() + : sType(VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO), + pNext(nullptr), + imageView(), + imageLayout(), + resolveMode(), + resolveImageView(), + resolveImageLayout(), + loadOp(), + storeOp(), + clearValue() {} + +safe_VkRenderingAttachmentInfo::safe_VkRenderingAttachmentInfo(const safe_VkRenderingAttachmentInfo& copy_src) { + sType = copy_src.sType; + imageView = copy_src.imageView; + imageLayout = copy_src.imageLayout; + resolveMode = copy_src.resolveMode; + resolveImageView = copy_src.resolveImageView; + resolveImageLayout = copy_src.resolveImageLayout; + loadOp = copy_src.loadOp; + storeOp = copy_src.storeOp; + clearValue = copy_src.clearValue; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkRenderingAttachmentInfo& safe_VkRenderingAttachmentInfo::operator=(const safe_VkRenderingAttachmentInfo& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + imageView = copy_src.imageView; + imageLayout = copy_src.imageLayout; + resolveMode = copy_src.resolveMode; + resolveImageView = copy_src.resolveImageView; + resolveImageLayout = copy_src.resolveImageLayout; + loadOp = copy_src.loadOp; + storeOp = copy_src.storeOp; + clearValue = copy_src.clearValue; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkRenderingAttachmentInfo::~safe_VkRenderingAttachmentInfo() { FreePnextChain(pNext); } + +void safe_VkRenderingAttachmentInfo::initialize(const VkRenderingAttachmentInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + imageView = in_struct->imageView; + imageLayout = in_struct->imageLayout; + resolveMode = in_struct->resolveMode; + resolveImageView = in_struct->resolveImageView; + resolveImageLayout = in_struct->resolveImageLayout; + loadOp = in_struct->loadOp; + storeOp = in_struct->storeOp; + clearValue = in_struct->clearValue; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkRenderingAttachmentInfo::initialize(const safe_VkRenderingAttachmentInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + imageView = copy_src->imageView; + imageLayout = copy_src->imageLayout; + resolveMode = copy_src->resolveMode; + resolveImageView = copy_src->resolveImageView; + resolveImageLayout = copy_src->resolveImageLayout; + loadOp = copy_src->loadOp; + storeOp = copy_src->storeOp; + clearValue = copy_src->clearValue; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkRenderingInfo::safe_VkRenderingInfo(const VkRenderingInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + renderArea(in_struct->renderArea), + layerCount(in_struct->layerCount), + viewMask(in_struct->viewMask), + colorAttachmentCount(in_struct->colorAttachmentCount), + pColorAttachments(nullptr), + pDepthAttachment(nullptr), + pStencilAttachment(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (colorAttachmentCount && in_struct->pColorAttachments) { + pColorAttachments = new safe_VkRenderingAttachmentInfo[colorAttachmentCount]; + for (uint32_t i = 0; i < colorAttachmentCount; ++i) { + pColorAttachments[i].initialize(&in_struct->pColorAttachments[i]); + } + } + if (in_struct->pDepthAttachment) pDepthAttachment = new safe_VkRenderingAttachmentInfo(in_struct->pDepthAttachment); + if (in_struct->pStencilAttachment) pStencilAttachment = new safe_VkRenderingAttachmentInfo(in_struct->pStencilAttachment); +} + +safe_VkRenderingInfo::safe_VkRenderingInfo() + : sType(VK_STRUCTURE_TYPE_RENDERING_INFO), + pNext(nullptr), + flags(), + renderArea(), + layerCount(), + viewMask(), + colorAttachmentCount(), + pColorAttachments(nullptr), + pDepthAttachment(nullptr), + pStencilAttachment(nullptr) {} + +safe_VkRenderingInfo::safe_VkRenderingInfo(const safe_VkRenderingInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + renderArea = copy_src.renderArea; + layerCount = copy_src.layerCount; + viewMask = copy_src.viewMask; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachments = nullptr; + pDepthAttachment = nullptr; + pStencilAttachment = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (colorAttachmentCount && copy_src.pColorAttachments) { + pColorAttachments = new safe_VkRenderingAttachmentInfo[colorAttachmentCount]; + for (uint32_t i = 0; i < colorAttachmentCount; ++i) { + pColorAttachments[i].initialize(©_src.pColorAttachments[i]); + } + } + if (copy_src.pDepthAttachment) pDepthAttachment = new safe_VkRenderingAttachmentInfo(*copy_src.pDepthAttachment); + if (copy_src.pStencilAttachment) pStencilAttachment = new safe_VkRenderingAttachmentInfo(*copy_src.pStencilAttachment); +} + +safe_VkRenderingInfo& safe_VkRenderingInfo::operator=(const safe_VkRenderingInfo& copy_src) { + if (©_src == this) return *this; + + if (pColorAttachments) delete[] pColorAttachments; + if (pDepthAttachment) delete pDepthAttachment; + if (pStencilAttachment) delete pStencilAttachment; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + renderArea = copy_src.renderArea; + layerCount = copy_src.layerCount; + viewMask = copy_src.viewMask; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachments = nullptr; + pDepthAttachment = nullptr; + pStencilAttachment = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (colorAttachmentCount && copy_src.pColorAttachments) { + pColorAttachments = new safe_VkRenderingAttachmentInfo[colorAttachmentCount]; + for (uint32_t i = 0; i < colorAttachmentCount; ++i) { + pColorAttachments[i].initialize(©_src.pColorAttachments[i]); + } + } + if (copy_src.pDepthAttachment) pDepthAttachment = new safe_VkRenderingAttachmentInfo(*copy_src.pDepthAttachment); + if (copy_src.pStencilAttachment) pStencilAttachment = new safe_VkRenderingAttachmentInfo(*copy_src.pStencilAttachment); + + return *this; +} + +safe_VkRenderingInfo::~safe_VkRenderingInfo() { + if (pColorAttachments) delete[] pColorAttachments; + if (pDepthAttachment) delete pDepthAttachment; + if (pStencilAttachment) delete pStencilAttachment; + FreePnextChain(pNext); +} + +void safe_VkRenderingInfo::initialize(const VkRenderingInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pColorAttachments) delete[] pColorAttachments; + if (pDepthAttachment) delete pDepthAttachment; + if (pStencilAttachment) delete pStencilAttachment; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + renderArea = in_struct->renderArea; + layerCount = in_struct->layerCount; + viewMask = in_struct->viewMask; + colorAttachmentCount = in_struct->colorAttachmentCount; + pColorAttachments = nullptr; + pDepthAttachment = nullptr; + pStencilAttachment = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (colorAttachmentCount && in_struct->pColorAttachments) { + pColorAttachments = new safe_VkRenderingAttachmentInfo[colorAttachmentCount]; + for (uint32_t i = 0; i < colorAttachmentCount; ++i) { + pColorAttachments[i].initialize(&in_struct->pColorAttachments[i]); + } + } + if (in_struct->pDepthAttachment) pDepthAttachment = new safe_VkRenderingAttachmentInfo(in_struct->pDepthAttachment); + if (in_struct->pStencilAttachment) pStencilAttachment = new safe_VkRenderingAttachmentInfo(in_struct->pStencilAttachment); +} + +void safe_VkRenderingInfo::initialize(const safe_VkRenderingInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + renderArea = copy_src->renderArea; + layerCount = copy_src->layerCount; + viewMask = copy_src->viewMask; + colorAttachmentCount = copy_src->colorAttachmentCount; + pColorAttachments = nullptr; + pDepthAttachment = nullptr; + pStencilAttachment = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (colorAttachmentCount && copy_src->pColorAttachments) { + pColorAttachments = new safe_VkRenderingAttachmentInfo[colorAttachmentCount]; + for (uint32_t i = 0; i < colorAttachmentCount; ++i) { + pColorAttachments[i].initialize(©_src->pColorAttachments[i]); + } + } + if (copy_src->pDepthAttachment) pDepthAttachment = new safe_VkRenderingAttachmentInfo(*copy_src->pDepthAttachment); + if (copy_src->pStencilAttachment) pStencilAttachment = new safe_VkRenderingAttachmentInfo(*copy_src->pStencilAttachment); +} + +safe_VkPipelineRenderingCreateInfo::safe_VkPipelineRenderingCreateInfo(const VkPipelineRenderingCreateInfo* 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); + } + bool custom_init = copy_state && copy_state->init; + if (custom_init) { + custom_init = + copy_state->init(reinterpret_cast(this), reinterpret_cast(in_struct)); + } + if (!custom_init) { + // The custom iniitalization was not used, so do the regular initialization + if (in_struct->pColorAttachmentFormats) { + pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount]; + memcpy((void*)pColorAttachmentFormats, (void*)in_struct->pColorAttachmentFormats, + sizeof(VkFormat) * in_struct->colorAttachmentCount); + } + } +} + +safe_VkPipelineRenderingCreateInfo::safe_VkPipelineRenderingCreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO), + pNext(nullptr), + viewMask(), + colorAttachmentCount(), + pColorAttachmentFormats(nullptr), + depthAttachmentFormat(), + stencilAttachmentFormat() {} + +safe_VkPipelineRenderingCreateInfo::safe_VkPipelineRenderingCreateInfo(const safe_VkPipelineRenderingCreateInfo& copy_src) { + sType = copy_src.sType; + viewMask = copy_src.viewMask; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachmentFormats = nullptr; + depthAttachmentFormat = copy_src.depthAttachmentFormat; + stencilAttachmentFormat = copy_src.stencilAttachmentFormat; + + if (copy_src.pColorAttachmentFormats) { + pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount]; + memcpy((void*)pColorAttachmentFormats, (void*)copy_src.pColorAttachmentFormats, + sizeof(VkFormat) * copy_src.colorAttachmentCount); + } +} + +safe_VkPipelineRenderingCreateInfo& safe_VkPipelineRenderingCreateInfo::operator=( + const safe_VkPipelineRenderingCreateInfo& 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; + + 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_VkPipelineRenderingCreateInfo::~safe_VkPipelineRenderingCreateInfo() { + if (pColorAttachmentFormats) delete[] pColorAttachmentFormats; + FreePnextChain(pNext); +} + +void safe_VkPipelineRenderingCreateInfo::initialize(const VkPipelineRenderingCreateInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pColorAttachmentFormats) delete[] pColorAttachmentFormats; + FreePnextChain(pNext); + sType = in_struct->sType; + viewMask = in_struct->viewMask; + colorAttachmentCount = in_struct->colorAttachmentCount; + pColorAttachmentFormats = nullptr; + depthAttachmentFormat = in_struct->depthAttachmentFormat; + stencilAttachmentFormat = in_struct->stencilAttachmentFormat; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + bool custom_init = copy_state && copy_state->init; + if (custom_init) { + custom_init = + copy_state->init(reinterpret_cast(this), reinterpret_cast(in_struct)); + } + if (!custom_init) { + // The custom iniitalization was not used, so do the regular initialization + if (in_struct->pColorAttachmentFormats) { + pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount]; + memcpy((void*)pColorAttachmentFormats, (void*)in_struct->pColorAttachmentFormats, + sizeof(VkFormat) * in_struct->colorAttachmentCount); + } + } +} + +void safe_VkPipelineRenderingCreateInfo::initialize(const safe_VkPipelineRenderingCreateInfo* 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; + + if (copy_src->pColorAttachmentFormats) { + pColorAttachmentFormats = new VkFormat[copy_src->colorAttachmentCount]; + memcpy((void*)pColorAttachmentFormats, (void*)copy_src->pColorAttachmentFormats, + sizeof(VkFormat) * copy_src->colorAttachmentCount); + } +} + +safe_VkPhysicalDeviceDynamicRenderingFeatures::safe_VkPhysicalDeviceDynamicRenderingFeatures( + const VkPhysicalDeviceDynamicRenderingFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), dynamicRendering(in_struct->dynamicRendering) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDynamicRenderingFeatures::safe_VkPhysicalDeviceDynamicRenderingFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES), pNext(nullptr), dynamicRendering() {} + +safe_VkPhysicalDeviceDynamicRenderingFeatures::safe_VkPhysicalDeviceDynamicRenderingFeatures( + const safe_VkPhysicalDeviceDynamicRenderingFeatures& copy_src) { + sType = copy_src.sType; + dynamicRendering = copy_src.dynamicRendering; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDynamicRenderingFeatures& safe_VkPhysicalDeviceDynamicRenderingFeatures::operator=( + const safe_VkPhysicalDeviceDynamicRenderingFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + dynamicRendering = copy_src.dynamicRendering; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDynamicRenderingFeatures::~safe_VkPhysicalDeviceDynamicRenderingFeatures() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceDynamicRenderingFeatures::initialize(const VkPhysicalDeviceDynamicRenderingFeatures* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + dynamicRendering = in_struct->dynamicRendering; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDynamicRenderingFeatures::initialize(const safe_VkPhysicalDeviceDynamicRenderingFeatures* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + dynamicRendering = copy_src->dynamicRendering; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCommandBufferInheritanceRenderingInfo::safe_VkCommandBufferInheritanceRenderingInfo( + const VkCommandBufferInheritanceRenderingInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + viewMask(in_struct->viewMask), + colorAttachmentCount(in_struct->colorAttachmentCount), + pColorAttachmentFormats(nullptr), + depthAttachmentFormat(in_struct->depthAttachmentFormat), + stencilAttachmentFormat(in_struct->stencilAttachmentFormat), + rasterizationSamples(in_struct->rasterizationSamples) { + 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_VkCommandBufferInheritanceRenderingInfo::safe_VkCommandBufferInheritanceRenderingInfo() + : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO), + pNext(nullptr), + flags(), + viewMask(), + colorAttachmentCount(), + pColorAttachmentFormats(nullptr), + depthAttachmentFormat(), + stencilAttachmentFormat(), + rasterizationSamples() {} + +safe_VkCommandBufferInheritanceRenderingInfo::safe_VkCommandBufferInheritanceRenderingInfo( + const safe_VkCommandBufferInheritanceRenderingInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + viewMask = copy_src.viewMask; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachmentFormats = nullptr; + depthAttachmentFormat = copy_src.depthAttachmentFormat; + stencilAttachmentFormat = copy_src.stencilAttachmentFormat; + rasterizationSamples = copy_src.rasterizationSamples; + 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_VkCommandBufferInheritanceRenderingInfo& safe_VkCommandBufferInheritanceRenderingInfo::operator=( + const safe_VkCommandBufferInheritanceRenderingInfo& copy_src) { + if (©_src == this) return *this; + + if (pColorAttachmentFormats) delete[] pColorAttachmentFormats; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + viewMask = copy_src.viewMask; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachmentFormats = nullptr; + depthAttachmentFormat = copy_src.depthAttachmentFormat; + stencilAttachmentFormat = copy_src.stencilAttachmentFormat; + rasterizationSamples = copy_src.rasterizationSamples; + 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_VkCommandBufferInheritanceRenderingInfo::~safe_VkCommandBufferInheritanceRenderingInfo() { + if (pColorAttachmentFormats) delete[] pColorAttachmentFormats; + FreePnextChain(pNext); +} + +void safe_VkCommandBufferInheritanceRenderingInfo::initialize(const VkCommandBufferInheritanceRenderingInfo* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pColorAttachmentFormats) delete[] pColorAttachmentFormats; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + viewMask = in_struct->viewMask; + colorAttachmentCount = in_struct->colorAttachmentCount; + pColorAttachmentFormats = nullptr; + depthAttachmentFormat = in_struct->depthAttachmentFormat; + stencilAttachmentFormat = in_struct->stencilAttachmentFormat; + rasterizationSamples = in_struct->rasterizationSamples; + 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_VkCommandBufferInheritanceRenderingInfo::initialize(const safe_VkCommandBufferInheritanceRenderingInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + viewMask = copy_src->viewMask; + colorAttachmentCount = copy_src->colorAttachmentCount; + pColorAttachmentFormats = nullptr; + depthAttachmentFormat = copy_src->depthAttachmentFormat; + stencilAttachmentFormat = copy_src->stencilAttachmentFormat; + rasterizationSamples = copy_src->rasterizationSamples; + 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_VkPhysicalDeviceShaderIntegerDotProductFeatures::safe_VkPhysicalDeviceShaderIntegerDotProductFeatures( + const VkPhysicalDeviceShaderIntegerDotProductFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), shaderIntegerDotProduct(in_struct->shaderIntegerDotProduct) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderIntegerDotProductFeatures::safe_VkPhysicalDeviceShaderIntegerDotProductFeatures() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES), pNext(nullptr), shaderIntegerDotProduct() {} + +safe_VkPhysicalDeviceShaderIntegerDotProductFeatures::safe_VkPhysicalDeviceShaderIntegerDotProductFeatures( + const safe_VkPhysicalDeviceShaderIntegerDotProductFeatures& copy_src) { + sType = copy_src.sType; + shaderIntegerDotProduct = copy_src.shaderIntegerDotProduct; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderIntegerDotProductFeatures& safe_VkPhysicalDeviceShaderIntegerDotProductFeatures::operator=( + const safe_VkPhysicalDeviceShaderIntegerDotProductFeatures& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderIntegerDotProduct = copy_src.shaderIntegerDotProduct; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderIntegerDotProductFeatures::~safe_VkPhysicalDeviceShaderIntegerDotProductFeatures() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderIntegerDotProductFeatures::initialize( + const VkPhysicalDeviceShaderIntegerDotProductFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderIntegerDotProduct = in_struct->shaderIntegerDotProduct; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderIntegerDotProductFeatures::initialize( + const safe_VkPhysicalDeviceShaderIntegerDotProductFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderIntegerDotProduct = copy_src->shaderIntegerDotProduct; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderIntegerDotProductProperties::safe_VkPhysicalDeviceShaderIntegerDotProductProperties( + const VkPhysicalDeviceShaderIntegerDotProductProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + integerDotProduct8BitUnsignedAccelerated(in_struct->integerDotProduct8BitUnsignedAccelerated), + integerDotProduct8BitSignedAccelerated(in_struct->integerDotProduct8BitSignedAccelerated), + integerDotProduct8BitMixedSignednessAccelerated(in_struct->integerDotProduct8BitMixedSignednessAccelerated), + integerDotProduct4x8BitPackedUnsignedAccelerated(in_struct->integerDotProduct4x8BitPackedUnsignedAccelerated), + integerDotProduct4x8BitPackedSignedAccelerated(in_struct->integerDotProduct4x8BitPackedSignedAccelerated), + integerDotProduct4x8BitPackedMixedSignednessAccelerated(in_struct->integerDotProduct4x8BitPackedMixedSignednessAccelerated), + integerDotProduct16BitUnsignedAccelerated(in_struct->integerDotProduct16BitUnsignedAccelerated), + integerDotProduct16BitSignedAccelerated(in_struct->integerDotProduct16BitSignedAccelerated), + integerDotProduct16BitMixedSignednessAccelerated(in_struct->integerDotProduct16BitMixedSignednessAccelerated), + integerDotProduct32BitUnsignedAccelerated(in_struct->integerDotProduct32BitUnsignedAccelerated), + integerDotProduct32BitSignedAccelerated(in_struct->integerDotProduct32BitSignedAccelerated), + integerDotProduct32BitMixedSignednessAccelerated(in_struct->integerDotProduct32BitMixedSignednessAccelerated), + integerDotProduct64BitUnsignedAccelerated(in_struct->integerDotProduct64BitUnsignedAccelerated), + integerDotProduct64BitSignedAccelerated(in_struct->integerDotProduct64BitSignedAccelerated), + integerDotProduct64BitMixedSignednessAccelerated(in_struct->integerDotProduct64BitMixedSignednessAccelerated), + integerDotProductAccumulatingSaturating8BitUnsignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated), + integerDotProductAccumulatingSaturating8BitSignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating8BitSignedAccelerated), + integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated( + in_struct->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated), + integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated), + integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated), + integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated( + in_struct->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated), + integerDotProductAccumulatingSaturating16BitUnsignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated), + integerDotProductAccumulatingSaturating16BitSignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating16BitSignedAccelerated), + integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated( + in_struct->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated), + integerDotProductAccumulatingSaturating32BitUnsignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated), + integerDotProductAccumulatingSaturating32BitSignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating32BitSignedAccelerated), + integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated( + in_struct->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated), + integerDotProductAccumulatingSaturating64BitUnsignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated), + integerDotProductAccumulatingSaturating64BitSignedAccelerated( + in_struct->integerDotProductAccumulatingSaturating64BitSignedAccelerated), + integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated( + in_struct->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderIntegerDotProductProperties::safe_VkPhysicalDeviceShaderIntegerDotProductProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES), + pNext(nullptr), + integerDotProduct8BitUnsignedAccelerated(), + integerDotProduct8BitSignedAccelerated(), + integerDotProduct8BitMixedSignednessAccelerated(), + integerDotProduct4x8BitPackedUnsignedAccelerated(), + integerDotProduct4x8BitPackedSignedAccelerated(), + integerDotProduct4x8BitPackedMixedSignednessAccelerated(), + integerDotProduct16BitUnsignedAccelerated(), + integerDotProduct16BitSignedAccelerated(), + integerDotProduct16BitMixedSignednessAccelerated(), + integerDotProduct32BitUnsignedAccelerated(), + integerDotProduct32BitSignedAccelerated(), + integerDotProduct32BitMixedSignednessAccelerated(), + integerDotProduct64BitUnsignedAccelerated(), + integerDotProduct64BitSignedAccelerated(), + integerDotProduct64BitMixedSignednessAccelerated(), + integerDotProductAccumulatingSaturating8BitUnsignedAccelerated(), + integerDotProductAccumulatingSaturating8BitSignedAccelerated(), + integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated(), + integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated(), + integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated(), + integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated(), + integerDotProductAccumulatingSaturating16BitUnsignedAccelerated(), + integerDotProductAccumulatingSaturating16BitSignedAccelerated(), + integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated(), + integerDotProductAccumulatingSaturating32BitUnsignedAccelerated(), + integerDotProductAccumulatingSaturating32BitSignedAccelerated(), + integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated(), + integerDotProductAccumulatingSaturating64BitUnsignedAccelerated(), + integerDotProductAccumulatingSaturating64BitSignedAccelerated(), + integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated() {} + +safe_VkPhysicalDeviceShaderIntegerDotProductProperties::safe_VkPhysicalDeviceShaderIntegerDotProductProperties( + const safe_VkPhysicalDeviceShaderIntegerDotProductProperties& copy_src) { + sType = copy_src.sType; + integerDotProduct8BitUnsignedAccelerated = copy_src.integerDotProduct8BitUnsignedAccelerated; + integerDotProduct8BitSignedAccelerated = copy_src.integerDotProduct8BitSignedAccelerated; + integerDotProduct8BitMixedSignednessAccelerated = copy_src.integerDotProduct8BitMixedSignednessAccelerated; + integerDotProduct4x8BitPackedUnsignedAccelerated = copy_src.integerDotProduct4x8BitPackedUnsignedAccelerated; + integerDotProduct4x8BitPackedSignedAccelerated = copy_src.integerDotProduct4x8BitPackedSignedAccelerated; + integerDotProduct4x8BitPackedMixedSignednessAccelerated = copy_src.integerDotProduct4x8BitPackedMixedSignednessAccelerated; + integerDotProduct16BitUnsignedAccelerated = copy_src.integerDotProduct16BitUnsignedAccelerated; + integerDotProduct16BitSignedAccelerated = copy_src.integerDotProduct16BitSignedAccelerated; + integerDotProduct16BitMixedSignednessAccelerated = copy_src.integerDotProduct16BitMixedSignednessAccelerated; + integerDotProduct32BitUnsignedAccelerated = copy_src.integerDotProduct32BitUnsignedAccelerated; + integerDotProduct32BitSignedAccelerated = copy_src.integerDotProduct32BitSignedAccelerated; + integerDotProduct32BitMixedSignednessAccelerated = copy_src.integerDotProduct32BitMixedSignednessAccelerated; + integerDotProduct64BitUnsignedAccelerated = copy_src.integerDotProduct64BitUnsignedAccelerated; + integerDotProduct64BitSignedAccelerated = copy_src.integerDotProduct64BitSignedAccelerated; + integerDotProduct64BitMixedSignednessAccelerated = copy_src.integerDotProduct64BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating8BitSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating8BitSignedAccelerated; + integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating16BitSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating16BitSignedAccelerated; + integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating32BitSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating32BitSignedAccelerated; + integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating64BitSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating64BitSignedAccelerated; + integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderIntegerDotProductProperties& safe_VkPhysicalDeviceShaderIntegerDotProductProperties::operator=( + const safe_VkPhysicalDeviceShaderIntegerDotProductProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + integerDotProduct8BitUnsignedAccelerated = copy_src.integerDotProduct8BitUnsignedAccelerated; + integerDotProduct8BitSignedAccelerated = copy_src.integerDotProduct8BitSignedAccelerated; + integerDotProduct8BitMixedSignednessAccelerated = copy_src.integerDotProduct8BitMixedSignednessAccelerated; + integerDotProduct4x8BitPackedUnsignedAccelerated = copy_src.integerDotProduct4x8BitPackedUnsignedAccelerated; + integerDotProduct4x8BitPackedSignedAccelerated = copy_src.integerDotProduct4x8BitPackedSignedAccelerated; + integerDotProduct4x8BitPackedMixedSignednessAccelerated = copy_src.integerDotProduct4x8BitPackedMixedSignednessAccelerated; + integerDotProduct16BitUnsignedAccelerated = copy_src.integerDotProduct16BitUnsignedAccelerated; + integerDotProduct16BitSignedAccelerated = copy_src.integerDotProduct16BitSignedAccelerated; + integerDotProduct16BitMixedSignednessAccelerated = copy_src.integerDotProduct16BitMixedSignednessAccelerated; + integerDotProduct32BitUnsignedAccelerated = copy_src.integerDotProduct32BitUnsignedAccelerated; + integerDotProduct32BitSignedAccelerated = copy_src.integerDotProduct32BitSignedAccelerated; + integerDotProduct32BitMixedSignednessAccelerated = copy_src.integerDotProduct32BitMixedSignednessAccelerated; + integerDotProduct64BitUnsignedAccelerated = copy_src.integerDotProduct64BitUnsignedAccelerated; + integerDotProduct64BitSignedAccelerated = copy_src.integerDotProduct64BitSignedAccelerated; + integerDotProduct64BitMixedSignednessAccelerated = copy_src.integerDotProduct64BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating8BitSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating8BitSignedAccelerated; + integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating16BitSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating16BitSignedAccelerated; + integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating32BitSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating32BitSignedAccelerated; + integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating64BitSignedAccelerated = + copy_src.integerDotProductAccumulatingSaturating64BitSignedAccelerated; + integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = + copy_src.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderIntegerDotProductProperties::~safe_VkPhysicalDeviceShaderIntegerDotProductProperties() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderIntegerDotProductProperties::initialize( + const VkPhysicalDeviceShaderIntegerDotProductProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + integerDotProduct8BitUnsignedAccelerated = in_struct->integerDotProduct8BitUnsignedAccelerated; + integerDotProduct8BitSignedAccelerated = in_struct->integerDotProduct8BitSignedAccelerated; + integerDotProduct8BitMixedSignednessAccelerated = in_struct->integerDotProduct8BitMixedSignednessAccelerated; + integerDotProduct4x8BitPackedUnsignedAccelerated = in_struct->integerDotProduct4x8BitPackedUnsignedAccelerated; + integerDotProduct4x8BitPackedSignedAccelerated = in_struct->integerDotProduct4x8BitPackedSignedAccelerated; + integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_struct->integerDotProduct4x8BitPackedMixedSignednessAccelerated; + integerDotProduct16BitUnsignedAccelerated = in_struct->integerDotProduct16BitUnsignedAccelerated; + integerDotProduct16BitSignedAccelerated = in_struct->integerDotProduct16BitSignedAccelerated; + integerDotProduct16BitMixedSignednessAccelerated = in_struct->integerDotProduct16BitMixedSignednessAccelerated; + integerDotProduct32BitUnsignedAccelerated = in_struct->integerDotProduct32BitUnsignedAccelerated; + integerDotProduct32BitSignedAccelerated = in_struct->integerDotProduct32BitSignedAccelerated; + integerDotProduct32BitMixedSignednessAccelerated = in_struct->integerDotProduct32BitMixedSignednessAccelerated; + integerDotProduct64BitUnsignedAccelerated = in_struct->integerDotProduct64BitUnsignedAccelerated; + integerDotProduct64BitSignedAccelerated = in_struct->integerDotProduct64BitSignedAccelerated; + integerDotProduct64BitMixedSignednessAccelerated = in_struct->integerDotProduct64BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating8BitSignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating8BitSignedAccelerated; + integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = + in_struct->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = + in_struct->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating16BitSignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating16BitSignedAccelerated; + integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = + in_struct->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating32BitSignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating32BitSignedAccelerated; + integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = + in_struct->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating64BitSignedAccelerated = + in_struct->integerDotProductAccumulatingSaturating64BitSignedAccelerated; + integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = + in_struct->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderIntegerDotProductProperties::initialize( + const safe_VkPhysicalDeviceShaderIntegerDotProductProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + integerDotProduct8BitUnsignedAccelerated = copy_src->integerDotProduct8BitUnsignedAccelerated; + integerDotProduct8BitSignedAccelerated = copy_src->integerDotProduct8BitSignedAccelerated; + integerDotProduct8BitMixedSignednessAccelerated = copy_src->integerDotProduct8BitMixedSignednessAccelerated; + integerDotProduct4x8BitPackedUnsignedAccelerated = copy_src->integerDotProduct4x8BitPackedUnsignedAccelerated; + integerDotProduct4x8BitPackedSignedAccelerated = copy_src->integerDotProduct4x8BitPackedSignedAccelerated; + integerDotProduct4x8BitPackedMixedSignednessAccelerated = copy_src->integerDotProduct4x8BitPackedMixedSignednessAccelerated; + integerDotProduct16BitUnsignedAccelerated = copy_src->integerDotProduct16BitUnsignedAccelerated; + integerDotProduct16BitSignedAccelerated = copy_src->integerDotProduct16BitSignedAccelerated; + integerDotProduct16BitMixedSignednessAccelerated = copy_src->integerDotProduct16BitMixedSignednessAccelerated; + integerDotProduct32BitUnsignedAccelerated = copy_src->integerDotProduct32BitUnsignedAccelerated; + integerDotProduct32BitSignedAccelerated = copy_src->integerDotProduct32BitSignedAccelerated; + integerDotProduct32BitMixedSignednessAccelerated = copy_src->integerDotProduct32BitMixedSignednessAccelerated; + integerDotProduct64BitUnsignedAccelerated = copy_src->integerDotProduct64BitUnsignedAccelerated; + integerDotProduct64BitSignedAccelerated = copy_src->integerDotProduct64BitSignedAccelerated; + integerDotProduct64BitMixedSignednessAccelerated = copy_src->integerDotProduct64BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating8BitSignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating8BitSignedAccelerated; + integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = + copy_src->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = + copy_src->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating16BitSignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating16BitSignedAccelerated; + integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = + copy_src->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating32BitSignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating32BitSignedAccelerated; + integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = + copy_src->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + integerDotProductAccumulatingSaturating64BitSignedAccelerated = + copy_src->integerDotProductAccumulatingSaturating64BitSignedAccelerated; + integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = + copy_src->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceTexelBufferAlignmentProperties::safe_VkPhysicalDeviceTexelBufferAlignmentProperties( + const VkPhysicalDeviceTexelBufferAlignmentProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + storageTexelBufferOffsetAlignmentBytes(in_struct->storageTexelBufferOffsetAlignmentBytes), + storageTexelBufferOffsetSingleTexelAlignment(in_struct->storageTexelBufferOffsetSingleTexelAlignment), + uniformTexelBufferOffsetAlignmentBytes(in_struct->uniformTexelBufferOffsetAlignmentBytes), + uniformTexelBufferOffsetSingleTexelAlignment(in_struct->uniformTexelBufferOffsetSingleTexelAlignment) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceTexelBufferAlignmentProperties::safe_VkPhysicalDeviceTexelBufferAlignmentProperties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES), + pNext(nullptr), + storageTexelBufferOffsetAlignmentBytes(), + storageTexelBufferOffsetSingleTexelAlignment(), + uniformTexelBufferOffsetAlignmentBytes(), + uniformTexelBufferOffsetSingleTexelAlignment() {} + +safe_VkPhysicalDeviceTexelBufferAlignmentProperties::safe_VkPhysicalDeviceTexelBufferAlignmentProperties( + const safe_VkPhysicalDeviceTexelBufferAlignmentProperties& copy_src) { + sType = copy_src.sType; + storageTexelBufferOffsetAlignmentBytes = copy_src.storageTexelBufferOffsetAlignmentBytes; + storageTexelBufferOffsetSingleTexelAlignment = copy_src.storageTexelBufferOffsetSingleTexelAlignment; + uniformTexelBufferOffsetAlignmentBytes = copy_src.uniformTexelBufferOffsetAlignmentBytes; + uniformTexelBufferOffsetSingleTexelAlignment = copy_src.uniformTexelBufferOffsetSingleTexelAlignment; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceTexelBufferAlignmentProperties& safe_VkPhysicalDeviceTexelBufferAlignmentProperties::operator=( + const safe_VkPhysicalDeviceTexelBufferAlignmentProperties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + storageTexelBufferOffsetAlignmentBytes = copy_src.storageTexelBufferOffsetAlignmentBytes; + storageTexelBufferOffsetSingleTexelAlignment = copy_src.storageTexelBufferOffsetSingleTexelAlignment; + uniformTexelBufferOffsetAlignmentBytes = copy_src.uniformTexelBufferOffsetAlignmentBytes; + uniformTexelBufferOffsetSingleTexelAlignment = copy_src.uniformTexelBufferOffsetSingleTexelAlignment; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceTexelBufferAlignmentProperties::~safe_VkPhysicalDeviceTexelBufferAlignmentProperties() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceTexelBufferAlignmentProperties::initialize( + const VkPhysicalDeviceTexelBufferAlignmentProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + storageTexelBufferOffsetAlignmentBytes = in_struct->storageTexelBufferOffsetAlignmentBytes; + storageTexelBufferOffsetSingleTexelAlignment = in_struct->storageTexelBufferOffsetSingleTexelAlignment; + uniformTexelBufferOffsetAlignmentBytes = in_struct->uniformTexelBufferOffsetAlignmentBytes; + uniformTexelBufferOffsetSingleTexelAlignment = in_struct->uniformTexelBufferOffsetSingleTexelAlignment; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceTexelBufferAlignmentProperties::initialize( + const safe_VkPhysicalDeviceTexelBufferAlignmentProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + storageTexelBufferOffsetAlignmentBytes = copy_src->storageTexelBufferOffsetAlignmentBytes; + storageTexelBufferOffsetSingleTexelAlignment = copy_src->storageTexelBufferOffsetSingleTexelAlignment; + uniformTexelBufferOffsetAlignmentBytes = copy_src->uniformTexelBufferOffsetAlignmentBytes; + uniformTexelBufferOffsetSingleTexelAlignment = copy_src->uniformTexelBufferOffsetSingleTexelAlignment; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkFormatProperties3::safe_VkFormatProperties3(const VkFormatProperties3* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + linearTilingFeatures(in_struct->linearTilingFeatures), + optimalTilingFeatures(in_struct->optimalTilingFeatures), + bufferFeatures(in_struct->bufferFeatures) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkFormatProperties3::safe_VkFormatProperties3() + : sType(VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3), + pNext(nullptr), + linearTilingFeatures(), + optimalTilingFeatures(), + bufferFeatures() {} + +safe_VkFormatProperties3::safe_VkFormatProperties3(const safe_VkFormatProperties3& copy_src) { + sType = copy_src.sType; + linearTilingFeatures = copy_src.linearTilingFeatures; + optimalTilingFeatures = copy_src.optimalTilingFeatures; + bufferFeatures = copy_src.bufferFeatures; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkFormatProperties3& safe_VkFormatProperties3::operator=(const safe_VkFormatProperties3& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + linearTilingFeatures = copy_src.linearTilingFeatures; + optimalTilingFeatures = copy_src.optimalTilingFeatures; + bufferFeatures = copy_src.bufferFeatures; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkFormatProperties3::~safe_VkFormatProperties3() { FreePnextChain(pNext); } + +void safe_VkFormatProperties3::initialize(const VkFormatProperties3* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + linearTilingFeatures = in_struct->linearTilingFeatures; + optimalTilingFeatures = in_struct->optimalTilingFeatures; + bufferFeatures = in_struct->bufferFeatures; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkFormatProperties3::initialize(const safe_VkFormatProperties3* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + linearTilingFeatures = copy_src->linearTilingFeatures; + optimalTilingFeatures = copy_src->optimalTilingFeatures; + bufferFeatures = copy_src->bufferFeatures; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMaintenance4Features::safe_VkPhysicalDeviceMaintenance4Features( + const VkPhysicalDeviceMaintenance4Features* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), maintenance4(in_struct->maintenance4) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMaintenance4Features::safe_VkPhysicalDeviceMaintenance4Features() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES), pNext(nullptr), maintenance4() {} + +safe_VkPhysicalDeviceMaintenance4Features::safe_VkPhysicalDeviceMaintenance4Features( + const safe_VkPhysicalDeviceMaintenance4Features& copy_src) { + sType = copy_src.sType; + maintenance4 = copy_src.maintenance4; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMaintenance4Features& safe_VkPhysicalDeviceMaintenance4Features::operator=( + const safe_VkPhysicalDeviceMaintenance4Features& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maintenance4 = copy_src.maintenance4; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMaintenance4Features::~safe_VkPhysicalDeviceMaintenance4Features() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMaintenance4Features::initialize(const VkPhysicalDeviceMaintenance4Features* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maintenance4 = in_struct->maintenance4; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMaintenance4Features::initialize(const safe_VkPhysicalDeviceMaintenance4Features* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maintenance4 = copy_src->maintenance4; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMaintenance4Properties::safe_VkPhysicalDeviceMaintenance4Properties( + const VkPhysicalDeviceMaintenance4Properties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), maxBufferSize(in_struct->maxBufferSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMaintenance4Properties::safe_VkPhysicalDeviceMaintenance4Properties() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES), pNext(nullptr), maxBufferSize() {} + +safe_VkPhysicalDeviceMaintenance4Properties::safe_VkPhysicalDeviceMaintenance4Properties( + const safe_VkPhysicalDeviceMaintenance4Properties& copy_src) { + sType = copy_src.sType; + maxBufferSize = copy_src.maxBufferSize; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMaintenance4Properties& safe_VkPhysicalDeviceMaintenance4Properties::operator=( + const safe_VkPhysicalDeviceMaintenance4Properties& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxBufferSize = copy_src.maxBufferSize; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMaintenance4Properties::~safe_VkPhysicalDeviceMaintenance4Properties() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMaintenance4Properties::initialize(const VkPhysicalDeviceMaintenance4Properties* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxBufferSize = in_struct->maxBufferSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMaintenance4Properties::initialize(const safe_VkPhysicalDeviceMaintenance4Properties* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxBufferSize = copy_src->maxBufferSize; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDeviceBufferMemoryRequirements::safe_VkDeviceBufferMemoryRequirements(const VkDeviceBufferMemoryRequirements* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), pCreateInfo(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pCreateInfo) pCreateInfo = new safe_VkBufferCreateInfo(in_struct->pCreateInfo); +} + +safe_VkDeviceBufferMemoryRequirements::safe_VkDeviceBufferMemoryRequirements() + : sType(VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS), pNext(nullptr), pCreateInfo(nullptr) {} + +safe_VkDeviceBufferMemoryRequirements::safe_VkDeviceBufferMemoryRequirements( + const safe_VkDeviceBufferMemoryRequirements& copy_src) { + sType = copy_src.sType; + pCreateInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pCreateInfo) pCreateInfo = new safe_VkBufferCreateInfo(*copy_src.pCreateInfo); +} + +safe_VkDeviceBufferMemoryRequirements& safe_VkDeviceBufferMemoryRequirements::operator=( + const safe_VkDeviceBufferMemoryRequirements& copy_src) { + if (©_src == this) return *this; + + if (pCreateInfo) delete pCreateInfo; + FreePnextChain(pNext); + + sType = copy_src.sType; + pCreateInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pCreateInfo) pCreateInfo = new safe_VkBufferCreateInfo(*copy_src.pCreateInfo); + + return *this; +} + +safe_VkDeviceBufferMemoryRequirements::~safe_VkDeviceBufferMemoryRequirements() { + if (pCreateInfo) delete pCreateInfo; + FreePnextChain(pNext); +} + +void safe_VkDeviceBufferMemoryRequirements::initialize(const VkDeviceBufferMemoryRequirements* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pCreateInfo) delete pCreateInfo; + FreePnextChain(pNext); + sType = in_struct->sType; + pCreateInfo = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (in_struct->pCreateInfo) pCreateInfo = new safe_VkBufferCreateInfo(in_struct->pCreateInfo); +} + +void safe_VkDeviceBufferMemoryRequirements::initialize(const safe_VkDeviceBufferMemoryRequirements* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pCreateInfo = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (copy_src->pCreateInfo) pCreateInfo = new safe_VkBufferCreateInfo(*copy_src->pCreateInfo); +} + +safe_VkDeviceImageMemoryRequirements::safe_VkDeviceImageMemoryRequirements(const VkDeviceImageMemoryRequirements* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), pCreateInfo(nullptr), planeAspect(in_struct->planeAspect) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(in_struct->pCreateInfo); +} + +safe_VkDeviceImageMemoryRequirements::safe_VkDeviceImageMemoryRequirements() + : sType(VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS), pNext(nullptr), pCreateInfo(nullptr), planeAspect() {} + +safe_VkDeviceImageMemoryRequirements::safe_VkDeviceImageMemoryRequirements(const safe_VkDeviceImageMemoryRequirements& copy_src) { + sType = copy_src.sType; + pCreateInfo = nullptr; + planeAspect = copy_src.planeAspect; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src.pCreateInfo); +} + +safe_VkDeviceImageMemoryRequirements& safe_VkDeviceImageMemoryRequirements::operator=( + const safe_VkDeviceImageMemoryRequirements& copy_src) { + if (©_src == this) return *this; + + if (pCreateInfo) delete pCreateInfo; + FreePnextChain(pNext); + + sType = copy_src.sType; + pCreateInfo = nullptr; + planeAspect = copy_src.planeAspect; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src.pCreateInfo); + + return *this; +} + +safe_VkDeviceImageMemoryRequirements::~safe_VkDeviceImageMemoryRequirements() { + if (pCreateInfo) delete pCreateInfo; + FreePnextChain(pNext); +} + +void safe_VkDeviceImageMemoryRequirements::initialize(const VkDeviceImageMemoryRequirements* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pCreateInfo) delete pCreateInfo; + FreePnextChain(pNext); + sType = in_struct->sType; + pCreateInfo = nullptr; + planeAspect = in_struct->planeAspect; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (in_struct->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(in_struct->pCreateInfo); +} + +void safe_VkDeviceImageMemoryRequirements::initialize(const safe_VkDeviceImageMemoryRequirements* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pCreateInfo = nullptr; + planeAspect = copy_src->planeAspect; + pNext = SafePnextCopy(copy_src->pNext); + if (copy_src->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src->pCreateInfo); +} + +} // namespace vku + +// NOLINTEND diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp new file mode 100644 index 0000000..0f65c58 --- /dev/null +++ b/src/vulkan/vk_safe_struct_ext.cpp @@ -0,0 +1,15447 @@ +// *** THIS FILE IS GENERATED - DO NOT EDIT *** +// See safe_struct_generator.py for modifications + +/*************************************************************************** + * + * Copyright (c) 2015-2024 The Khronos Group Inc. + * Copyright (c) 2015-2024 Valve Corporation + * Copyright (c) 2015-2024 LunarG, Inc. + * Copyright (c) 2015-2024 Google Inc. + * + * SPDX-License-Identifier: Apache-2.0 + * + ****************************************************************************/ + +// NOLINTBEGIN + +#include +#include + +#include + +namespace vku { + +safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::safe_VkRenderingFragmentDensityMapAttachmentInfoEXT( + const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), imageView(in_struct->imageView), imageLayout(in_struct->imageLayout) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::safe_VkRenderingFragmentDensityMapAttachmentInfoEXT() + : sType(VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT), pNext(nullptr), imageView(), imageLayout() {} + +safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::safe_VkRenderingFragmentDensityMapAttachmentInfoEXT( + const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& copy_src) { + sType = copy_src.sType; + imageView = copy_src.imageView; + imageLayout = copy_src.imageLayout; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::operator=( + const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + imageView = copy_src.imageView; + imageLayout = copy_src.imageLayout; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::~safe_VkRenderingFragmentDensityMapAttachmentInfoEXT() { + FreePnextChain(pNext); +} + +void safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::initialize( + const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + imageView = in_struct->imageView; + imageLayout = in_struct->imageLayout; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::initialize( + const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + imageView = copy_src->imageView; + imageLayout = copy_src->imageLayout; + 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) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDebugReportCallbackCreateInfoEXT::safe_VkDebugReportCallbackCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT), pNext(nullptr), flags(), pfnCallback(), pUserData(nullptr) {} + +safe_VkDebugReportCallbackCreateInfoEXT::safe_VkDebugReportCallbackCreateInfoEXT( + const safe_VkDebugReportCallbackCreateInfoEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pfnCallback = copy_src.pfnCallback; + pUserData = copy_src.pUserData; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDebugReportCallbackCreateInfoEXT& safe_VkDebugReportCallbackCreateInfoEXT::operator=( + const safe_VkDebugReportCallbackCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pfnCallback = copy_src.pfnCallback; + pUserData = copy_src.pUserData; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDebugReportCallbackCreateInfoEXT::~safe_VkDebugReportCallbackCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkDebugReportCallbackCreateInfoEXT::initialize(const VkDebugReportCallbackCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pfnCallback = in_struct->pfnCallback; + pUserData = in_struct->pUserData; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDebugReportCallbackCreateInfoEXT::initialize(const safe_VkDebugReportCallbackCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pfnCallback = copy_src->pfnCallback; + pUserData = copy_src->pUserData; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDebugMarkerObjectNameInfoEXT::safe_VkDebugMarkerObjectNameInfoEXT(const VkDebugMarkerObjectNameInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), objectType(in_struct->objectType), object(in_struct->object) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + pObjectName = SafeStringCopy(in_struct->pObjectName); +} + +safe_VkDebugMarkerObjectNameInfoEXT::safe_VkDebugMarkerObjectNameInfoEXT() + : sType(VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT), pNext(nullptr), objectType(), object(), pObjectName(nullptr) {} + +safe_VkDebugMarkerObjectNameInfoEXT::safe_VkDebugMarkerObjectNameInfoEXT(const safe_VkDebugMarkerObjectNameInfoEXT& copy_src) { + sType = copy_src.sType; + objectType = copy_src.objectType; + object = copy_src.object; + pNext = SafePnextCopy(copy_src.pNext); + pObjectName = SafeStringCopy(copy_src.pObjectName); +} + +safe_VkDebugMarkerObjectNameInfoEXT& safe_VkDebugMarkerObjectNameInfoEXT::operator=( + const safe_VkDebugMarkerObjectNameInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pObjectName) delete[] pObjectName; + FreePnextChain(pNext); + + sType = copy_src.sType; + objectType = copy_src.objectType; + object = copy_src.object; + pNext = SafePnextCopy(copy_src.pNext); + pObjectName = SafeStringCopy(copy_src.pObjectName); + + return *this; +} + +safe_VkDebugMarkerObjectNameInfoEXT::~safe_VkDebugMarkerObjectNameInfoEXT() { + if (pObjectName) delete[] pObjectName; + FreePnextChain(pNext); +} + +void safe_VkDebugMarkerObjectNameInfoEXT::initialize(const VkDebugMarkerObjectNameInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pObjectName) delete[] pObjectName; + FreePnextChain(pNext); + sType = in_struct->sType; + objectType = in_struct->objectType; + object = in_struct->object; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + pObjectName = SafeStringCopy(in_struct->pObjectName); +} + +void safe_VkDebugMarkerObjectNameInfoEXT::initialize(const safe_VkDebugMarkerObjectNameInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + objectType = copy_src->objectType; + object = copy_src->object; + pNext = SafePnextCopy(copy_src->pNext); + pObjectName = SafeStringCopy(copy_src->pObjectName); +} + +safe_VkDebugMarkerObjectTagInfoEXT::safe_VkDebugMarkerObjectTagInfoEXT(const VkDebugMarkerObjectTagInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + objectType(in_struct->objectType), + object(in_struct->object), + tagName(in_struct->tagName), + tagSize(in_struct->tagSize), + pTag(in_struct->pTag) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDebugMarkerObjectTagInfoEXT::safe_VkDebugMarkerObjectTagInfoEXT() + : sType(VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT), + pNext(nullptr), + objectType(), + object(), + tagName(), + tagSize(), + pTag(nullptr) {} + +safe_VkDebugMarkerObjectTagInfoEXT::safe_VkDebugMarkerObjectTagInfoEXT(const safe_VkDebugMarkerObjectTagInfoEXT& copy_src) { + sType = copy_src.sType; + objectType = copy_src.objectType; + object = copy_src.object; + tagName = copy_src.tagName; + tagSize = copy_src.tagSize; + pTag = copy_src.pTag; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDebugMarkerObjectTagInfoEXT& safe_VkDebugMarkerObjectTagInfoEXT::operator=( + const safe_VkDebugMarkerObjectTagInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + objectType = copy_src.objectType; + object = copy_src.object; + tagName = copy_src.tagName; + tagSize = copy_src.tagSize; + pTag = copy_src.pTag; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDebugMarkerObjectTagInfoEXT::~safe_VkDebugMarkerObjectTagInfoEXT() { FreePnextChain(pNext); } + +void safe_VkDebugMarkerObjectTagInfoEXT::initialize(const VkDebugMarkerObjectTagInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + objectType = in_struct->objectType; + object = in_struct->object; + tagName = in_struct->tagName; + tagSize = in_struct->tagSize; + pTag = in_struct->pTag; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDebugMarkerObjectTagInfoEXT::initialize(const safe_VkDebugMarkerObjectTagInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + objectType = copy_src->objectType; + object = copy_src->object; + tagName = copy_src->tagName; + tagSize = copy_src->tagSize; + pTag = copy_src->pTag; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDebugMarkerMarkerInfoEXT::safe_VkDebugMarkerMarkerInfoEXT(const VkDebugMarkerMarkerInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + pMarkerName = SafeStringCopy(in_struct->pMarkerName); + + for (uint32_t i = 0; i < 4; ++i) { + color[i] = in_struct->color[i]; + } +} + +safe_VkDebugMarkerMarkerInfoEXT::safe_VkDebugMarkerMarkerInfoEXT() + : sType(VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT), pNext(nullptr), pMarkerName(nullptr) {} + +safe_VkDebugMarkerMarkerInfoEXT::safe_VkDebugMarkerMarkerInfoEXT(const safe_VkDebugMarkerMarkerInfoEXT& copy_src) { + sType = copy_src.sType; + pNext = SafePnextCopy(copy_src.pNext); + pMarkerName = SafeStringCopy(copy_src.pMarkerName); + + for (uint32_t i = 0; i < 4; ++i) { + color[i] = copy_src.color[i]; + } +} + +safe_VkDebugMarkerMarkerInfoEXT& safe_VkDebugMarkerMarkerInfoEXT::operator=(const safe_VkDebugMarkerMarkerInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pMarkerName) delete[] pMarkerName; + FreePnextChain(pNext); + + sType = copy_src.sType; + pNext = SafePnextCopy(copy_src.pNext); + pMarkerName = SafeStringCopy(copy_src.pMarkerName); + + for (uint32_t i = 0; i < 4; ++i) { + color[i] = copy_src.color[i]; + } + + return *this; +} + +safe_VkDebugMarkerMarkerInfoEXT::~safe_VkDebugMarkerMarkerInfoEXT() { + if (pMarkerName) delete[] pMarkerName; + FreePnextChain(pNext); +} + +void safe_VkDebugMarkerMarkerInfoEXT::initialize(const VkDebugMarkerMarkerInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pMarkerName) delete[] pMarkerName; + FreePnextChain(pNext); + sType = in_struct->sType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + pMarkerName = SafeStringCopy(in_struct->pMarkerName); + + for (uint32_t i = 0; i < 4; ++i) { + color[i] = in_struct->color[i]; + } +} + +void safe_VkDebugMarkerMarkerInfoEXT::initialize(const safe_VkDebugMarkerMarkerInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pNext = SafePnextCopy(copy_src->pNext); + pMarkerName = SafeStringCopy(copy_src->pMarkerName); + + for (uint32_t i = 0; i < 4; ++i) { + color[i] = copy_src->color[i]; + } +} + +safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT( + const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), transformFeedback(in_struct->transformFeedback), geometryStreams(in_struct->geometryStreams) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT), + pNext(nullptr), + transformFeedback(), + geometryStreams() {} + +safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT( + const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& copy_src) { + sType = copy_src.sType; + transformFeedback = copy_src.transformFeedback; + geometryStreams = copy_src.geometryStreams; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::operator=( + const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + transformFeedback = copy_src.transformFeedback; + geometryStreams = copy_src.geometryStreams; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::~safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::initialize(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + transformFeedback = in_struct->transformFeedback; + geometryStreams = in_struct->geometryStreams; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::initialize( + const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + transformFeedback = copy_src->transformFeedback; + geometryStreams = copy_src->geometryStreams; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT( + const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + maxTransformFeedbackStreams(in_struct->maxTransformFeedbackStreams), + maxTransformFeedbackBuffers(in_struct->maxTransformFeedbackBuffers), + maxTransformFeedbackBufferSize(in_struct->maxTransformFeedbackBufferSize), + maxTransformFeedbackStreamDataSize(in_struct->maxTransformFeedbackStreamDataSize), + maxTransformFeedbackBufferDataSize(in_struct->maxTransformFeedbackBufferDataSize), + maxTransformFeedbackBufferDataStride(in_struct->maxTransformFeedbackBufferDataStride), + transformFeedbackQueries(in_struct->transformFeedbackQueries), + transformFeedbackStreamsLinesTriangles(in_struct->transformFeedbackStreamsLinesTriangles), + transformFeedbackRasterizationStreamSelect(in_struct->transformFeedbackRasterizationStreamSelect), + transformFeedbackDraw(in_struct->transformFeedbackDraw) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT), + pNext(nullptr), + maxTransformFeedbackStreams(), + maxTransformFeedbackBuffers(), + maxTransformFeedbackBufferSize(), + maxTransformFeedbackStreamDataSize(), + maxTransformFeedbackBufferDataSize(), + maxTransformFeedbackBufferDataStride(), + transformFeedbackQueries(), + transformFeedbackStreamsLinesTriangles(), + transformFeedbackRasterizationStreamSelect(), + transformFeedbackDraw() {} + +safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT( + const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& copy_src) { + sType = copy_src.sType; + maxTransformFeedbackStreams = copy_src.maxTransformFeedbackStreams; + maxTransformFeedbackBuffers = copy_src.maxTransformFeedbackBuffers; + maxTransformFeedbackBufferSize = copy_src.maxTransformFeedbackBufferSize; + maxTransformFeedbackStreamDataSize = copy_src.maxTransformFeedbackStreamDataSize; + maxTransformFeedbackBufferDataSize = copy_src.maxTransformFeedbackBufferDataSize; + maxTransformFeedbackBufferDataStride = copy_src.maxTransformFeedbackBufferDataStride; + transformFeedbackQueries = copy_src.transformFeedbackQueries; + transformFeedbackStreamsLinesTriangles = copy_src.transformFeedbackStreamsLinesTriangles; + transformFeedbackRasterizationStreamSelect = copy_src.transformFeedbackRasterizationStreamSelect; + transformFeedbackDraw = copy_src.transformFeedbackDraw; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::operator=( + const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxTransformFeedbackStreams = copy_src.maxTransformFeedbackStreams; + maxTransformFeedbackBuffers = copy_src.maxTransformFeedbackBuffers; + maxTransformFeedbackBufferSize = copy_src.maxTransformFeedbackBufferSize; + maxTransformFeedbackStreamDataSize = copy_src.maxTransformFeedbackStreamDataSize; + maxTransformFeedbackBufferDataSize = copy_src.maxTransformFeedbackBufferDataSize; + maxTransformFeedbackBufferDataStride = copy_src.maxTransformFeedbackBufferDataStride; + transformFeedbackQueries = copy_src.transformFeedbackQueries; + transformFeedbackStreamsLinesTriangles = copy_src.transformFeedbackStreamsLinesTriangles; + transformFeedbackRasterizationStreamSelect = copy_src.transformFeedbackRasterizationStreamSelect; + transformFeedbackDraw = copy_src.transformFeedbackDraw; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::~safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::initialize( + const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxTransformFeedbackStreams = in_struct->maxTransformFeedbackStreams; + maxTransformFeedbackBuffers = in_struct->maxTransformFeedbackBuffers; + maxTransformFeedbackBufferSize = in_struct->maxTransformFeedbackBufferSize; + maxTransformFeedbackStreamDataSize = in_struct->maxTransformFeedbackStreamDataSize; + maxTransformFeedbackBufferDataSize = in_struct->maxTransformFeedbackBufferDataSize; + maxTransformFeedbackBufferDataStride = in_struct->maxTransformFeedbackBufferDataStride; + transformFeedbackQueries = in_struct->transformFeedbackQueries; + transformFeedbackStreamsLinesTriangles = in_struct->transformFeedbackStreamsLinesTriangles; + transformFeedbackRasterizationStreamSelect = in_struct->transformFeedbackRasterizationStreamSelect; + transformFeedbackDraw = in_struct->transformFeedbackDraw; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::initialize( + const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxTransformFeedbackStreams = copy_src->maxTransformFeedbackStreams; + maxTransformFeedbackBuffers = copy_src->maxTransformFeedbackBuffers; + maxTransformFeedbackBufferSize = copy_src->maxTransformFeedbackBufferSize; + maxTransformFeedbackStreamDataSize = copy_src->maxTransformFeedbackStreamDataSize; + maxTransformFeedbackBufferDataSize = copy_src->maxTransformFeedbackBufferDataSize; + maxTransformFeedbackBufferDataStride = copy_src->maxTransformFeedbackBufferDataStride; + transformFeedbackQueries = copy_src->transformFeedbackQueries; + transformFeedbackStreamsLinesTriangles = copy_src->transformFeedbackStreamsLinesTriangles; + transformFeedbackRasterizationStreamSelect = copy_src->transformFeedbackRasterizationStreamSelect; + transformFeedbackDraw = copy_src->transformFeedbackDraw; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineRasterizationStateStreamCreateInfoEXT::safe_VkPipelineRasterizationStateStreamCreateInfoEXT( + const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), rasterizationStream(in_struct->rasterizationStream) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineRasterizationStateStreamCreateInfoEXT::safe_VkPipelineRasterizationStateStreamCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT), + pNext(nullptr), + flags(), + rasterizationStream() {} + +safe_VkPipelineRasterizationStateStreamCreateInfoEXT::safe_VkPipelineRasterizationStateStreamCreateInfoEXT( + const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + rasterizationStream = copy_src.rasterizationStream; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineRasterizationStateStreamCreateInfoEXT& safe_VkPipelineRasterizationStateStreamCreateInfoEXT::operator=( + const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + rasterizationStream = copy_src.rasterizationStream; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineRasterizationStateStreamCreateInfoEXT::~safe_VkPipelineRasterizationStateStreamCreateInfoEXT() { + FreePnextChain(pNext); +} + +void safe_VkPipelineRasterizationStateStreamCreateInfoEXT::initialize( + const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + rasterizationStream = in_struct->rasterizationStream; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineRasterizationStateStreamCreateInfoEXT::initialize( + const safe_VkPipelineRasterizationStateStreamCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + rasterizationStream = copy_src->rasterizationStream; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkValidationFlagsEXT::safe_VkValidationFlagsEXT(const VkValidationFlagsEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + disabledValidationCheckCount(in_struct->disabledValidationCheckCount), + pDisabledValidationChecks(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pDisabledValidationChecks) { + pDisabledValidationChecks = new VkValidationCheckEXT[in_struct->disabledValidationCheckCount]; + memcpy((void*)pDisabledValidationChecks, (void*)in_struct->pDisabledValidationChecks, + sizeof(VkValidationCheckEXT) * in_struct->disabledValidationCheckCount); + } +} + +safe_VkValidationFlagsEXT::safe_VkValidationFlagsEXT() + : sType(VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT), + pNext(nullptr), + disabledValidationCheckCount(), + pDisabledValidationChecks(nullptr) {} + +safe_VkValidationFlagsEXT::safe_VkValidationFlagsEXT(const safe_VkValidationFlagsEXT& copy_src) { + sType = copy_src.sType; + disabledValidationCheckCount = copy_src.disabledValidationCheckCount; + pDisabledValidationChecks = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDisabledValidationChecks) { + pDisabledValidationChecks = new VkValidationCheckEXT[copy_src.disabledValidationCheckCount]; + memcpy((void*)pDisabledValidationChecks, (void*)copy_src.pDisabledValidationChecks, + sizeof(VkValidationCheckEXT) * copy_src.disabledValidationCheckCount); + } +} + +safe_VkValidationFlagsEXT& safe_VkValidationFlagsEXT::operator=(const safe_VkValidationFlagsEXT& copy_src) { + if (©_src == this) return *this; + + if (pDisabledValidationChecks) delete[] pDisabledValidationChecks; + FreePnextChain(pNext); + + sType = copy_src.sType; + disabledValidationCheckCount = copy_src.disabledValidationCheckCount; + pDisabledValidationChecks = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDisabledValidationChecks) { + pDisabledValidationChecks = new VkValidationCheckEXT[copy_src.disabledValidationCheckCount]; + memcpy((void*)pDisabledValidationChecks, (void*)copy_src.pDisabledValidationChecks, + sizeof(VkValidationCheckEXT) * copy_src.disabledValidationCheckCount); + } + + return *this; +} + +safe_VkValidationFlagsEXT::~safe_VkValidationFlagsEXT() { + if (pDisabledValidationChecks) delete[] pDisabledValidationChecks; + FreePnextChain(pNext); +} + +void safe_VkValidationFlagsEXT::initialize(const VkValidationFlagsEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pDisabledValidationChecks) delete[] pDisabledValidationChecks; + FreePnextChain(pNext); + sType = in_struct->sType; + disabledValidationCheckCount = in_struct->disabledValidationCheckCount; + pDisabledValidationChecks = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pDisabledValidationChecks) { + pDisabledValidationChecks = new VkValidationCheckEXT[in_struct->disabledValidationCheckCount]; + memcpy((void*)pDisabledValidationChecks, (void*)in_struct->pDisabledValidationChecks, + sizeof(VkValidationCheckEXT) * in_struct->disabledValidationCheckCount); + } +} + +void safe_VkValidationFlagsEXT::initialize(const safe_VkValidationFlagsEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + disabledValidationCheckCount = copy_src->disabledValidationCheckCount; + pDisabledValidationChecks = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pDisabledValidationChecks) { + pDisabledValidationChecks = new VkValidationCheckEXT[copy_src->disabledValidationCheckCount]; + memcpy((void*)pDisabledValidationChecks, (void*)copy_src->pDisabledValidationChecks, + sizeof(VkValidationCheckEXT) * copy_src->disabledValidationCheckCount); + } +} + +safe_VkImageViewASTCDecodeModeEXT::safe_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), decodeMode(in_struct->decodeMode) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageViewASTCDecodeModeEXT::safe_VkImageViewASTCDecodeModeEXT() + : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT), pNext(nullptr), decodeMode() {} + +safe_VkImageViewASTCDecodeModeEXT::safe_VkImageViewASTCDecodeModeEXT(const safe_VkImageViewASTCDecodeModeEXT& copy_src) { + sType = copy_src.sType; + decodeMode = copy_src.decodeMode; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageViewASTCDecodeModeEXT& safe_VkImageViewASTCDecodeModeEXT::operator=(const safe_VkImageViewASTCDecodeModeEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + decodeMode = copy_src.decodeMode; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageViewASTCDecodeModeEXT::~safe_VkImageViewASTCDecodeModeEXT() { FreePnextChain(pNext); } + +void safe_VkImageViewASTCDecodeModeEXT::initialize(const VkImageViewASTCDecodeModeEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + decodeMode = in_struct->decodeMode; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageViewASTCDecodeModeEXT::initialize(const safe_VkImageViewASTCDecodeModeEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + decodeMode = copy_src->decodeMode; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::safe_VkPhysicalDeviceASTCDecodeFeaturesEXT( + const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), decodeModeSharedExponent(in_struct->decodeModeSharedExponent) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::safe_VkPhysicalDeviceASTCDecodeFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT), pNext(nullptr), decodeModeSharedExponent() {} + +safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::safe_VkPhysicalDeviceASTCDecodeFeaturesEXT( + const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& copy_src) { + sType = copy_src.sType; + decodeModeSharedExponent = copy_src.decodeModeSharedExponent; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::operator=( + const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + decodeModeSharedExponent = copy_src.decodeModeSharedExponent; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::~safe_VkPhysicalDeviceASTCDecodeFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::initialize(const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + decodeModeSharedExponent = in_struct->decodeModeSharedExponent; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::initialize(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + decodeModeSharedExponent = copy_src->decodeModeSharedExponent; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT( + const VkPhysicalDevicePipelineRobustnessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pipelineRobustness(in_struct->pipelineRobustness) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT), pNext(nullptr), pipelineRobustness() {} + +safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT( + const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& copy_src) { + sType = copy_src.sType; + pipelineRobustness = copy_src.pipelineRobustness; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::operator=( + const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pipelineRobustness = copy_src.pipelineRobustness; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::~safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::initialize(const VkPhysicalDevicePipelineRobustnessFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pipelineRobustness = in_struct->pipelineRobustness; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::initialize( + const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipelineRobustness = copy_src->pipelineRobustness; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT( + const VkPhysicalDevicePipelineRobustnessPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + defaultRobustnessStorageBuffers(in_struct->defaultRobustnessStorageBuffers), + defaultRobustnessUniformBuffers(in_struct->defaultRobustnessUniformBuffers), + defaultRobustnessVertexInputs(in_struct->defaultRobustnessVertexInputs), + defaultRobustnessImages(in_struct->defaultRobustnessImages) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT), + pNext(nullptr), + defaultRobustnessStorageBuffers(), + defaultRobustnessUniformBuffers(), + defaultRobustnessVertexInputs(), + defaultRobustnessImages() {} + +safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT( + const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& copy_src) { + sType = copy_src.sType; + defaultRobustnessStorageBuffers = copy_src.defaultRobustnessStorageBuffers; + defaultRobustnessUniformBuffers = copy_src.defaultRobustnessUniformBuffers; + defaultRobustnessVertexInputs = copy_src.defaultRobustnessVertexInputs; + defaultRobustnessImages = copy_src.defaultRobustnessImages; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::operator=( + const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + defaultRobustnessStorageBuffers = copy_src.defaultRobustnessStorageBuffers; + defaultRobustnessUniformBuffers = copy_src.defaultRobustnessUniformBuffers; + defaultRobustnessVertexInputs = copy_src.defaultRobustnessVertexInputs; + defaultRobustnessImages = copy_src.defaultRobustnessImages; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::~safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::initialize( + const VkPhysicalDevicePipelineRobustnessPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + defaultRobustnessStorageBuffers = in_struct->defaultRobustnessStorageBuffers; + defaultRobustnessUniformBuffers = in_struct->defaultRobustnessUniformBuffers; + defaultRobustnessVertexInputs = in_struct->defaultRobustnessVertexInputs; + defaultRobustnessImages = in_struct->defaultRobustnessImages; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::initialize( + const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + defaultRobustnessStorageBuffers = copy_src->defaultRobustnessStorageBuffers; + defaultRobustnessUniformBuffers = copy_src->defaultRobustnessUniformBuffers; + defaultRobustnessVertexInputs = copy_src->defaultRobustnessVertexInputs; + defaultRobustnessImages = copy_src->defaultRobustnessImages; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineRobustnessCreateInfoEXT::safe_VkPipelineRobustnessCreateInfoEXT(const VkPipelineRobustnessCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + storageBuffers(in_struct->storageBuffers), + uniformBuffers(in_struct->uniformBuffers), + vertexInputs(in_struct->vertexInputs), + images(in_struct->images) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineRobustnessCreateInfoEXT::safe_VkPipelineRobustnessCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT), + pNext(nullptr), + storageBuffers(), + uniformBuffers(), + vertexInputs(), + images() {} + +safe_VkPipelineRobustnessCreateInfoEXT::safe_VkPipelineRobustnessCreateInfoEXT( + const safe_VkPipelineRobustnessCreateInfoEXT& copy_src) { + sType = copy_src.sType; + storageBuffers = copy_src.storageBuffers; + uniformBuffers = copy_src.uniformBuffers; + vertexInputs = copy_src.vertexInputs; + images = copy_src.images; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineRobustnessCreateInfoEXT& safe_VkPipelineRobustnessCreateInfoEXT::operator=( + const safe_VkPipelineRobustnessCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + storageBuffers = copy_src.storageBuffers; + uniformBuffers = copy_src.uniformBuffers; + vertexInputs = copy_src.vertexInputs; + images = copy_src.images; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineRobustnessCreateInfoEXT::~safe_VkPipelineRobustnessCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkPipelineRobustnessCreateInfoEXT::initialize(const VkPipelineRobustnessCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + storageBuffers = in_struct->storageBuffers; + uniformBuffers = in_struct->uniformBuffers; + vertexInputs = in_struct->vertexInputs; + images = in_struct->images; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineRobustnessCreateInfoEXT::initialize(const safe_VkPipelineRobustnessCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + storageBuffers = copy_src->storageBuffers; + uniformBuffers = copy_src->uniformBuffers; + vertexInputs = copy_src->vertexInputs; + images = copy_src->images; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkConditionalRenderingBeginInfoEXT::safe_VkConditionalRenderingBeginInfoEXT( + const VkConditionalRenderingBeginInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), buffer(in_struct->buffer), offset(in_struct->offset), flags(in_struct->flags) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkConditionalRenderingBeginInfoEXT::safe_VkConditionalRenderingBeginInfoEXT() + : sType(VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT), pNext(nullptr), buffer(), offset(), flags() {} + +safe_VkConditionalRenderingBeginInfoEXT::safe_VkConditionalRenderingBeginInfoEXT( + const safe_VkConditionalRenderingBeginInfoEXT& copy_src) { + sType = copy_src.sType; + buffer = copy_src.buffer; + offset = copy_src.offset; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkConditionalRenderingBeginInfoEXT& safe_VkConditionalRenderingBeginInfoEXT::operator=( + const safe_VkConditionalRenderingBeginInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + buffer = copy_src.buffer; + offset = copy_src.offset; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkConditionalRenderingBeginInfoEXT::~safe_VkConditionalRenderingBeginInfoEXT() { FreePnextChain(pNext); } + +void safe_VkConditionalRenderingBeginInfoEXT::initialize(const VkConditionalRenderingBeginInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + buffer = in_struct->buffer; + offset = in_struct->offset; + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkConditionalRenderingBeginInfoEXT::initialize(const safe_VkConditionalRenderingBeginInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + buffer = copy_src->buffer; + offset = copy_src->offset; + flags = copy_src->flags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT( + const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + conditionalRendering(in_struct->conditionalRendering), + inheritedConditionalRendering(in_struct->inheritedConditionalRendering) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT), + pNext(nullptr), + conditionalRendering(), + inheritedConditionalRendering() {} + +safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT( + const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& copy_src) { + sType = copy_src.sType; + conditionalRendering = copy_src.conditionalRendering; + inheritedConditionalRendering = copy_src.inheritedConditionalRendering; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::operator=( + const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + conditionalRendering = copy_src.conditionalRendering; + inheritedConditionalRendering = copy_src.inheritedConditionalRendering; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::~safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::initialize( + const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + conditionalRendering = in_struct->conditionalRendering; + inheritedConditionalRendering = in_struct->inheritedConditionalRendering; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::initialize( + const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + conditionalRendering = copy_src->conditionalRendering; + inheritedConditionalRendering = copy_src->inheritedConditionalRendering; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT( + const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), conditionalRenderingEnable(in_struct->conditionalRenderingEnable) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT() + : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT), + pNext(nullptr), + conditionalRenderingEnable() {} + +safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT( + const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& copy_src) { + sType = copy_src.sType; + conditionalRenderingEnable = copy_src.conditionalRenderingEnable; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::operator=( + const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + conditionalRenderingEnable = copy_src.conditionalRenderingEnable; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::~safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT() { + FreePnextChain(pNext); +} + +void safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::initialize( + const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + conditionalRenderingEnable = in_struct->conditionalRenderingEnable; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::initialize( + const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + conditionalRenderingEnable = copy_src->conditionalRenderingEnable; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSurfaceCapabilities2EXT::safe_VkSurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + minImageCount(in_struct->minImageCount), + maxImageCount(in_struct->maxImageCount), + currentExtent(in_struct->currentExtent), + minImageExtent(in_struct->minImageExtent), + maxImageExtent(in_struct->maxImageExtent), + maxImageArrayLayers(in_struct->maxImageArrayLayers), + supportedTransforms(in_struct->supportedTransforms), + currentTransform(in_struct->currentTransform), + supportedCompositeAlpha(in_struct->supportedCompositeAlpha), + supportedUsageFlags(in_struct->supportedUsageFlags), + supportedSurfaceCounters(in_struct->supportedSurfaceCounters) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSurfaceCapabilities2EXT::safe_VkSurfaceCapabilities2EXT() + : sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT), + pNext(nullptr), + minImageCount(), + maxImageCount(), + currentExtent(), + minImageExtent(), + maxImageExtent(), + maxImageArrayLayers(), + supportedTransforms(), + currentTransform(), + supportedCompositeAlpha(), + supportedUsageFlags(), + supportedSurfaceCounters() {} + +safe_VkSurfaceCapabilities2EXT::safe_VkSurfaceCapabilities2EXT(const safe_VkSurfaceCapabilities2EXT& copy_src) { + sType = copy_src.sType; + minImageCount = copy_src.minImageCount; + maxImageCount = copy_src.maxImageCount; + currentExtent = copy_src.currentExtent; + minImageExtent = copy_src.minImageExtent; + maxImageExtent = copy_src.maxImageExtent; + maxImageArrayLayers = copy_src.maxImageArrayLayers; + supportedTransforms = copy_src.supportedTransforms; + currentTransform = copy_src.currentTransform; + supportedCompositeAlpha = copy_src.supportedCompositeAlpha; + supportedUsageFlags = copy_src.supportedUsageFlags; + supportedSurfaceCounters = copy_src.supportedSurfaceCounters; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSurfaceCapabilities2EXT& safe_VkSurfaceCapabilities2EXT::operator=(const safe_VkSurfaceCapabilities2EXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + minImageCount = copy_src.minImageCount; + maxImageCount = copy_src.maxImageCount; + currentExtent = copy_src.currentExtent; + minImageExtent = copy_src.minImageExtent; + maxImageExtent = copy_src.maxImageExtent; + maxImageArrayLayers = copy_src.maxImageArrayLayers; + supportedTransforms = copy_src.supportedTransforms; + currentTransform = copy_src.currentTransform; + supportedCompositeAlpha = copy_src.supportedCompositeAlpha; + supportedUsageFlags = copy_src.supportedUsageFlags; + supportedSurfaceCounters = copy_src.supportedSurfaceCounters; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSurfaceCapabilities2EXT::~safe_VkSurfaceCapabilities2EXT() { FreePnextChain(pNext); } + +void safe_VkSurfaceCapabilities2EXT::initialize(const VkSurfaceCapabilities2EXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + minImageCount = in_struct->minImageCount; + maxImageCount = in_struct->maxImageCount; + currentExtent = in_struct->currentExtent; + minImageExtent = in_struct->minImageExtent; + maxImageExtent = in_struct->maxImageExtent; + maxImageArrayLayers = in_struct->maxImageArrayLayers; + supportedTransforms = in_struct->supportedTransforms; + currentTransform = in_struct->currentTransform; + supportedCompositeAlpha = in_struct->supportedCompositeAlpha; + supportedUsageFlags = in_struct->supportedUsageFlags; + supportedSurfaceCounters = in_struct->supportedSurfaceCounters; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSurfaceCapabilities2EXT::initialize(const safe_VkSurfaceCapabilities2EXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + minImageCount = copy_src->minImageCount; + maxImageCount = copy_src->maxImageCount; + currentExtent = copy_src->currentExtent; + minImageExtent = copy_src->minImageExtent; + maxImageExtent = copy_src->maxImageExtent; + maxImageArrayLayers = copy_src->maxImageArrayLayers; + supportedTransforms = copy_src->supportedTransforms; + currentTransform = copy_src->currentTransform; + supportedCompositeAlpha = copy_src->supportedCompositeAlpha; + supportedUsageFlags = copy_src->supportedUsageFlags; + supportedSurfaceCounters = copy_src->supportedSurfaceCounters; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDisplayPowerInfoEXT::safe_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), powerState(in_struct->powerState) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDisplayPowerInfoEXT::safe_VkDisplayPowerInfoEXT() + : sType(VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT), pNext(nullptr), powerState() {} + +safe_VkDisplayPowerInfoEXT::safe_VkDisplayPowerInfoEXT(const safe_VkDisplayPowerInfoEXT& copy_src) { + sType = copy_src.sType; + powerState = copy_src.powerState; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDisplayPowerInfoEXT& safe_VkDisplayPowerInfoEXT::operator=(const safe_VkDisplayPowerInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + powerState = copy_src.powerState; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDisplayPowerInfoEXT::~safe_VkDisplayPowerInfoEXT() { FreePnextChain(pNext); } + +void safe_VkDisplayPowerInfoEXT::initialize(const VkDisplayPowerInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + powerState = in_struct->powerState; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDisplayPowerInfoEXT::initialize(const safe_VkDisplayPowerInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + powerState = copy_src->powerState; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDeviceEventInfoEXT::safe_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), deviceEvent(in_struct->deviceEvent) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDeviceEventInfoEXT::safe_VkDeviceEventInfoEXT() + : sType(VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT), pNext(nullptr), deviceEvent() {} + +safe_VkDeviceEventInfoEXT::safe_VkDeviceEventInfoEXT(const safe_VkDeviceEventInfoEXT& copy_src) { + sType = copy_src.sType; + deviceEvent = copy_src.deviceEvent; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDeviceEventInfoEXT& safe_VkDeviceEventInfoEXT::operator=(const safe_VkDeviceEventInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + deviceEvent = copy_src.deviceEvent; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDeviceEventInfoEXT::~safe_VkDeviceEventInfoEXT() { FreePnextChain(pNext); } + +void safe_VkDeviceEventInfoEXT::initialize(const VkDeviceEventInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + deviceEvent = in_struct->deviceEvent; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDeviceEventInfoEXT::initialize(const safe_VkDeviceEventInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + deviceEvent = copy_src->deviceEvent; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDisplayEventInfoEXT::safe_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), displayEvent(in_struct->displayEvent) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDisplayEventInfoEXT::safe_VkDisplayEventInfoEXT() + : sType(VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT), pNext(nullptr), displayEvent() {} + +safe_VkDisplayEventInfoEXT::safe_VkDisplayEventInfoEXT(const safe_VkDisplayEventInfoEXT& copy_src) { + sType = copy_src.sType; + displayEvent = copy_src.displayEvent; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDisplayEventInfoEXT& safe_VkDisplayEventInfoEXT::operator=(const safe_VkDisplayEventInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + displayEvent = copy_src.displayEvent; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDisplayEventInfoEXT::~safe_VkDisplayEventInfoEXT() { FreePnextChain(pNext); } + +void safe_VkDisplayEventInfoEXT::initialize(const VkDisplayEventInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + displayEvent = in_struct->displayEvent; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDisplayEventInfoEXT::initialize(const safe_VkDisplayEventInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + displayEvent = copy_src->displayEvent; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSwapchainCounterCreateInfoEXT::safe_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), surfaceCounters(in_struct->surfaceCounters) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSwapchainCounterCreateInfoEXT::safe_VkSwapchainCounterCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT), pNext(nullptr), surfaceCounters() {} + +safe_VkSwapchainCounterCreateInfoEXT::safe_VkSwapchainCounterCreateInfoEXT(const safe_VkSwapchainCounterCreateInfoEXT& copy_src) { + sType = copy_src.sType; + surfaceCounters = copy_src.surfaceCounters; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSwapchainCounterCreateInfoEXT& safe_VkSwapchainCounterCreateInfoEXT::operator=( + const safe_VkSwapchainCounterCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + surfaceCounters = copy_src.surfaceCounters; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSwapchainCounterCreateInfoEXT::~safe_VkSwapchainCounterCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkSwapchainCounterCreateInfoEXT::initialize(const VkSwapchainCounterCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + surfaceCounters = in_struct->surfaceCounters; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSwapchainCounterCreateInfoEXT::initialize(const safe_VkSwapchainCounterCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + surfaceCounters = copy_src->surfaceCounters; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT( + const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), maxDiscardRectangles(in_struct->maxDiscardRectangles) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT), pNext(nullptr), maxDiscardRectangles() {} + +safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT( + const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& copy_src) { + sType = copy_src.sType; + maxDiscardRectangles = copy_src.maxDiscardRectangles; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::operator=( + const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxDiscardRectangles = copy_src.maxDiscardRectangles; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::~safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::initialize(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxDiscardRectangles = in_struct->maxDiscardRectangles; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::initialize( + const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxDiscardRectangles = copy_src->maxDiscardRectangles; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineDiscardRectangleStateCreateInfoEXT::safe_VkPipelineDiscardRectangleStateCreateInfoEXT( + const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + discardRectangleMode(in_struct->discardRectangleMode), + discardRectangleCount(in_struct->discardRectangleCount), + pDiscardRectangles(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pDiscardRectangles) { + pDiscardRectangles = new VkRect2D[in_struct->discardRectangleCount]; + memcpy((void*)pDiscardRectangles, (void*)in_struct->pDiscardRectangles, + sizeof(VkRect2D) * in_struct->discardRectangleCount); + } +} + +safe_VkPipelineDiscardRectangleStateCreateInfoEXT::safe_VkPipelineDiscardRectangleStateCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT), + pNext(nullptr), + flags(), + discardRectangleMode(), + discardRectangleCount(), + pDiscardRectangles(nullptr) {} + +safe_VkPipelineDiscardRectangleStateCreateInfoEXT::safe_VkPipelineDiscardRectangleStateCreateInfoEXT( + const safe_VkPipelineDiscardRectangleStateCreateInfoEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + discardRectangleMode = copy_src.discardRectangleMode; + discardRectangleCount = copy_src.discardRectangleCount; + pDiscardRectangles = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDiscardRectangles) { + pDiscardRectangles = new VkRect2D[copy_src.discardRectangleCount]; + memcpy((void*)pDiscardRectangles, (void*)copy_src.pDiscardRectangles, sizeof(VkRect2D) * copy_src.discardRectangleCount); + } +} + +safe_VkPipelineDiscardRectangleStateCreateInfoEXT& safe_VkPipelineDiscardRectangleStateCreateInfoEXT::operator=( + const safe_VkPipelineDiscardRectangleStateCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pDiscardRectangles) delete[] pDiscardRectangles; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + discardRectangleMode = copy_src.discardRectangleMode; + discardRectangleCount = copy_src.discardRectangleCount; + pDiscardRectangles = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDiscardRectangles) { + pDiscardRectangles = new VkRect2D[copy_src.discardRectangleCount]; + memcpy((void*)pDiscardRectangles, (void*)copy_src.pDiscardRectangles, sizeof(VkRect2D) * copy_src.discardRectangleCount); + } + + return *this; +} + +safe_VkPipelineDiscardRectangleStateCreateInfoEXT::~safe_VkPipelineDiscardRectangleStateCreateInfoEXT() { + if (pDiscardRectangles) delete[] pDiscardRectangles; + FreePnextChain(pNext); +} + +void safe_VkPipelineDiscardRectangleStateCreateInfoEXT::initialize(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDiscardRectangles) delete[] pDiscardRectangles; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + discardRectangleMode = in_struct->discardRectangleMode; + discardRectangleCount = in_struct->discardRectangleCount; + pDiscardRectangles = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pDiscardRectangles) { + pDiscardRectangles = new VkRect2D[in_struct->discardRectangleCount]; + memcpy((void*)pDiscardRectangles, (void*)in_struct->pDiscardRectangles, + sizeof(VkRect2D) * in_struct->discardRectangleCount); + } +} + +void safe_VkPipelineDiscardRectangleStateCreateInfoEXT::initialize( + const safe_VkPipelineDiscardRectangleStateCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + discardRectangleMode = copy_src->discardRectangleMode; + discardRectangleCount = copy_src->discardRectangleCount; + pDiscardRectangles = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pDiscardRectangles) { + pDiscardRectangles = new VkRect2D[copy_src->discardRectangleCount]; + memcpy((void*)pDiscardRectangles, (void*)copy_src->pDiscardRectangles, sizeof(VkRect2D) * copy_src->discardRectangleCount); + } +} + +safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT( + const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + primitiveOverestimationSize(in_struct->primitiveOverestimationSize), + maxExtraPrimitiveOverestimationSize(in_struct->maxExtraPrimitiveOverestimationSize), + extraPrimitiveOverestimationSizeGranularity(in_struct->extraPrimitiveOverestimationSizeGranularity), + primitiveUnderestimation(in_struct->primitiveUnderestimation), + conservativePointAndLineRasterization(in_struct->conservativePointAndLineRasterization), + degenerateTrianglesRasterized(in_struct->degenerateTrianglesRasterized), + degenerateLinesRasterized(in_struct->degenerateLinesRasterized), + fullyCoveredFragmentShaderInputVariable(in_struct->fullyCoveredFragmentShaderInputVariable), + conservativeRasterizationPostDepthCoverage(in_struct->conservativeRasterizationPostDepthCoverage) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT), + pNext(nullptr), + primitiveOverestimationSize(), + maxExtraPrimitiveOverestimationSize(), + extraPrimitiveOverestimationSizeGranularity(), + primitiveUnderestimation(), + conservativePointAndLineRasterization(), + degenerateTrianglesRasterized(), + degenerateLinesRasterized(), + fullyCoveredFragmentShaderInputVariable(), + conservativeRasterizationPostDepthCoverage() {} + +safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT( + const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& copy_src) { + sType = copy_src.sType; + primitiveOverestimationSize = copy_src.primitiveOverestimationSize; + maxExtraPrimitiveOverestimationSize = copy_src.maxExtraPrimitiveOverestimationSize; + extraPrimitiveOverestimationSizeGranularity = copy_src.extraPrimitiveOverestimationSizeGranularity; + primitiveUnderestimation = copy_src.primitiveUnderestimation; + conservativePointAndLineRasterization = copy_src.conservativePointAndLineRasterization; + degenerateTrianglesRasterized = copy_src.degenerateTrianglesRasterized; + degenerateLinesRasterized = copy_src.degenerateLinesRasterized; + fullyCoveredFragmentShaderInputVariable = copy_src.fullyCoveredFragmentShaderInputVariable; + conservativeRasterizationPostDepthCoverage = copy_src.conservativeRasterizationPostDepthCoverage; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::operator=( + const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + primitiveOverestimationSize = copy_src.primitiveOverestimationSize; + maxExtraPrimitiveOverestimationSize = copy_src.maxExtraPrimitiveOverestimationSize; + extraPrimitiveOverestimationSizeGranularity = copy_src.extraPrimitiveOverestimationSizeGranularity; + primitiveUnderestimation = copy_src.primitiveUnderestimation; + conservativePointAndLineRasterization = copy_src.conservativePointAndLineRasterization; + degenerateTrianglesRasterized = copy_src.degenerateTrianglesRasterized; + degenerateLinesRasterized = copy_src.degenerateLinesRasterized; + fullyCoveredFragmentShaderInputVariable = copy_src.fullyCoveredFragmentShaderInputVariable; + conservativeRasterizationPostDepthCoverage = copy_src.conservativeRasterizationPostDepthCoverage; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::~safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::initialize( + const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + primitiveOverestimationSize = in_struct->primitiveOverestimationSize; + maxExtraPrimitiveOverestimationSize = in_struct->maxExtraPrimitiveOverestimationSize; + extraPrimitiveOverestimationSizeGranularity = in_struct->extraPrimitiveOverestimationSizeGranularity; + primitiveUnderestimation = in_struct->primitiveUnderestimation; + conservativePointAndLineRasterization = in_struct->conservativePointAndLineRasterization; + degenerateTrianglesRasterized = in_struct->degenerateTrianglesRasterized; + degenerateLinesRasterized = in_struct->degenerateLinesRasterized; + fullyCoveredFragmentShaderInputVariable = in_struct->fullyCoveredFragmentShaderInputVariable; + conservativeRasterizationPostDepthCoverage = in_struct->conservativeRasterizationPostDepthCoverage; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::initialize( + const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + primitiveOverestimationSize = copy_src->primitiveOverestimationSize; + maxExtraPrimitiveOverestimationSize = copy_src->maxExtraPrimitiveOverestimationSize; + extraPrimitiveOverestimationSizeGranularity = copy_src->extraPrimitiveOverestimationSizeGranularity; + primitiveUnderestimation = copy_src->primitiveUnderestimation; + conservativePointAndLineRasterization = copy_src->conservativePointAndLineRasterization; + degenerateTrianglesRasterized = copy_src->degenerateTrianglesRasterized; + degenerateLinesRasterized = copy_src->degenerateLinesRasterized; + fullyCoveredFragmentShaderInputVariable = copy_src->fullyCoveredFragmentShaderInputVariable; + conservativeRasterizationPostDepthCoverage = copy_src->conservativeRasterizationPostDepthCoverage; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::safe_VkPipelineRasterizationConservativeStateCreateInfoEXT( + const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + conservativeRasterizationMode(in_struct->conservativeRasterizationMode), + extraPrimitiveOverestimationSize(in_struct->extraPrimitiveOverestimationSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::safe_VkPipelineRasterizationConservativeStateCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT), + pNext(nullptr), + flags(), + conservativeRasterizationMode(), + extraPrimitiveOverestimationSize() {} + +safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::safe_VkPipelineRasterizationConservativeStateCreateInfoEXT( + const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + conservativeRasterizationMode = copy_src.conservativeRasterizationMode; + extraPrimitiveOverestimationSize = copy_src.extraPrimitiveOverestimationSize; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::operator=( + const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + conservativeRasterizationMode = copy_src.conservativeRasterizationMode; + extraPrimitiveOverestimationSize = copy_src.extraPrimitiveOverestimationSize; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::~safe_VkPipelineRasterizationConservativeStateCreateInfoEXT() { + FreePnextChain(pNext); +} + +void safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::initialize( + const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + conservativeRasterizationMode = in_struct->conservativeRasterizationMode; + extraPrimitiveOverestimationSize = in_struct->extraPrimitiveOverestimationSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::initialize( + const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + conservativeRasterizationMode = copy_src->conservativeRasterizationMode; + extraPrimitiveOverestimationSize = copy_src->extraPrimitiveOverestimationSize; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT( + const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), depthClipEnable(in_struct->depthClipEnable) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT), pNext(nullptr), depthClipEnable() {} + +safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT( + const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& copy_src) { + sType = copy_src.sType; + depthClipEnable = copy_src.depthClipEnable; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::operator=( + const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + depthClipEnable = copy_src.depthClipEnable; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::~safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::initialize(const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + depthClipEnable = in_struct->depthClipEnable; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::initialize(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + depthClipEnable = copy_src->depthClipEnable; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT( + const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), depthClipEnable(in_struct->depthClipEnable) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT), + pNext(nullptr), + flags(), + depthClipEnable() {} + +safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT( + const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + depthClipEnable = copy_src.depthClipEnable; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::operator=( + const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + depthClipEnable = copy_src.depthClipEnable; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::~safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT() { + FreePnextChain(pNext); +} + +void safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::initialize( + const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + depthClipEnable = in_struct->depthClipEnable; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::initialize( + const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + depthClipEnable = copy_src->depthClipEnable; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkHdrMetadataEXT::safe_VkHdrMetadataEXT(const VkHdrMetadataEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + displayPrimaryRed(in_struct->displayPrimaryRed), + displayPrimaryGreen(in_struct->displayPrimaryGreen), + displayPrimaryBlue(in_struct->displayPrimaryBlue), + whitePoint(in_struct->whitePoint), + maxLuminance(in_struct->maxLuminance), + minLuminance(in_struct->minLuminance), + maxContentLightLevel(in_struct->maxContentLightLevel), + maxFrameAverageLightLevel(in_struct->maxFrameAverageLightLevel) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkHdrMetadataEXT::safe_VkHdrMetadataEXT() + : sType(VK_STRUCTURE_TYPE_HDR_METADATA_EXT), + pNext(nullptr), + displayPrimaryRed(), + displayPrimaryGreen(), + displayPrimaryBlue(), + whitePoint(), + maxLuminance(), + minLuminance(), + maxContentLightLevel(), + maxFrameAverageLightLevel() {} + +safe_VkHdrMetadataEXT::safe_VkHdrMetadataEXT(const safe_VkHdrMetadataEXT& copy_src) { + sType = copy_src.sType; + displayPrimaryRed = copy_src.displayPrimaryRed; + displayPrimaryGreen = copy_src.displayPrimaryGreen; + displayPrimaryBlue = copy_src.displayPrimaryBlue; + whitePoint = copy_src.whitePoint; + maxLuminance = copy_src.maxLuminance; + minLuminance = copy_src.minLuminance; + maxContentLightLevel = copy_src.maxContentLightLevel; + maxFrameAverageLightLevel = copy_src.maxFrameAverageLightLevel; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkHdrMetadataEXT& safe_VkHdrMetadataEXT::operator=(const safe_VkHdrMetadataEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + displayPrimaryRed = copy_src.displayPrimaryRed; + displayPrimaryGreen = copy_src.displayPrimaryGreen; + displayPrimaryBlue = copy_src.displayPrimaryBlue; + whitePoint = copy_src.whitePoint; + maxLuminance = copy_src.maxLuminance; + minLuminance = copy_src.minLuminance; + maxContentLightLevel = copy_src.maxContentLightLevel; + maxFrameAverageLightLevel = copy_src.maxFrameAverageLightLevel; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkHdrMetadataEXT::~safe_VkHdrMetadataEXT() { FreePnextChain(pNext); } + +void safe_VkHdrMetadataEXT::initialize(const VkHdrMetadataEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + displayPrimaryRed = in_struct->displayPrimaryRed; + displayPrimaryGreen = in_struct->displayPrimaryGreen; + displayPrimaryBlue = in_struct->displayPrimaryBlue; + whitePoint = in_struct->whitePoint; + maxLuminance = in_struct->maxLuminance; + minLuminance = in_struct->minLuminance; + maxContentLightLevel = in_struct->maxContentLightLevel; + maxFrameAverageLightLevel = in_struct->maxFrameAverageLightLevel; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkHdrMetadataEXT::initialize(const safe_VkHdrMetadataEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + displayPrimaryRed = copy_src->displayPrimaryRed; + displayPrimaryGreen = copy_src->displayPrimaryGreen; + displayPrimaryBlue = copy_src->displayPrimaryBlue; + whitePoint = copy_src->whitePoint; + maxLuminance = copy_src->maxLuminance; + minLuminance = copy_src->minLuminance; + maxContentLightLevel = copy_src->maxContentLightLevel; + maxFrameAverageLightLevel = copy_src->maxFrameAverageLightLevel; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDebugUtilsLabelEXT::safe_VkDebugUtilsLabelEXT(const VkDebugUtilsLabelEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + pLabelName = SafeStringCopy(in_struct->pLabelName); + + for (uint32_t i = 0; i < 4; ++i) { + color[i] = in_struct->color[i]; + } +} + +safe_VkDebugUtilsLabelEXT::safe_VkDebugUtilsLabelEXT() + : sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT), pNext(nullptr), pLabelName(nullptr) {} + +safe_VkDebugUtilsLabelEXT::safe_VkDebugUtilsLabelEXT(const safe_VkDebugUtilsLabelEXT& copy_src) { + sType = copy_src.sType; + pNext = SafePnextCopy(copy_src.pNext); + pLabelName = SafeStringCopy(copy_src.pLabelName); + + for (uint32_t i = 0; i < 4; ++i) { + color[i] = copy_src.color[i]; + } +} + +safe_VkDebugUtilsLabelEXT& safe_VkDebugUtilsLabelEXT::operator=(const safe_VkDebugUtilsLabelEXT& copy_src) { + if (©_src == this) return *this; + + if (pLabelName) delete[] pLabelName; + FreePnextChain(pNext); + + sType = copy_src.sType; + pNext = SafePnextCopy(copy_src.pNext); + pLabelName = SafeStringCopy(copy_src.pLabelName); + + for (uint32_t i = 0; i < 4; ++i) { + color[i] = copy_src.color[i]; + } + + return *this; +} + +safe_VkDebugUtilsLabelEXT::~safe_VkDebugUtilsLabelEXT() { + if (pLabelName) delete[] pLabelName; + FreePnextChain(pNext); +} + +void safe_VkDebugUtilsLabelEXT::initialize(const VkDebugUtilsLabelEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pLabelName) delete[] pLabelName; + FreePnextChain(pNext); + sType = in_struct->sType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + pLabelName = SafeStringCopy(in_struct->pLabelName); + + for (uint32_t i = 0; i < 4; ++i) { + color[i] = in_struct->color[i]; + } +} + +void safe_VkDebugUtilsLabelEXT::initialize(const safe_VkDebugUtilsLabelEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pNext = SafePnextCopy(copy_src->pNext); + pLabelName = SafeStringCopy(copy_src->pLabelName); + + for (uint32_t i = 0; i < 4; ++i) { + color[i] = copy_src->color[i]; + } +} + +safe_VkDebugUtilsObjectNameInfoEXT::safe_VkDebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), objectType(in_struct->objectType), objectHandle(in_struct->objectHandle) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + pObjectName = SafeStringCopy(in_struct->pObjectName); +} + +safe_VkDebugUtilsObjectNameInfoEXT::safe_VkDebugUtilsObjectNameInfoEXT() + : sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT), + pNext(nullptr), + objectType(), + objectHandle(), + pObjectName(nullptr) {} + +safe_VkDebugUtilsObjectNameInfoEXT::safe_VkDebugUtilsObjectNameInfoEXT(const safe_VkDebugUtilsObjectNameInfoEXT& copy_src) { + sType = copy_src.sType; + objectType = copy_src.objectType; + objectHandle = copy_src.objectHandle; + pNext = SafePnextCopy(copy_src.pNext); + pObjectName = SafeStringCopy(copy_src.pObjectName); +} + +safe_VkDebugUtilsObjectNameInfoEXT& safe_VkDebugUtilsObjectNameInfoEXT::operator=( + const safe_VkDebugUtilsObjectNameInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pObjectName) delete[] pObjectName; + FreePnextChain(pNext); + + sType = copy_src.sType; + objectType = copy_src.objectType; + objectHandle = copy_src.objectHandle; + pNext = SafePnextCopy(copy_src.pNext); + pObjectName = SafeStringCopy(copy_src.pObjectName); + + return *this; +} + +safe_VkDebugUtilsObjectNameInfoEXT::~safe_VkDebugUtilsObjectNameInfoEXT() { + if (pObjectName) delete[] pObjectName; + FreePnextChain(pNext); +} + +void safe_VkDebugUtilsObjectNameInfoEXT::initialize(const VkDebugUtilsObjectNameInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pObjectName) delete[] pObjectName; + FreePnextChain(pNext); + sType = in_struct->sType; + objectType = in_struct->objectType; + objectHandle = in_struct->objectHandle; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + pObjectName = SafeStringCopy(in_struct->pObjectName); +} + +void safe_VkDebugUtilsObjectNameInfoEXT::initialize(const safe_VkDebugUtilsObjectNameInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + objectType = copy_src->objectType; + objectHandle = copy_src->objectHandle; + pNext = SafePnextCopy(copy_src->pNext); + pObjectName = SafeStringCopy(copy_src->pObjectName); +} + +safe_VkDebugUtilsMessengerCallbackDataEXT::safe_VkDebugUtilsMessengerCallbackDataEXT( + const VkDebugUtilsMessengerCallbackDataEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + messageIdNumber(in_struct->messageIdNumber), + queueLabelCount(in_struct->queueLabelCount), + pQueueLabels(nullptr), + cmdBufLabelCount(in_struct->cmdBufLabelCount), + pCmdBufLabels(nullptr), + objectCount(in_struct->objectCount), + pObjects(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + pMessageIdName = SafeStringCopy(in_struct->pMessageIdName); + pMessage = SafeStringCopy(in_struct->pMessage); + if (queueLabelCount && in_struct->pQueueLabels) { + pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount]; + for (uint32_t i = 0; i < queueLabelCount; ++i) { + pQueueLabels[i].initialize(&in_struct->pQueueLabels[i]); + } + } + if (cmdBufLabelCount && in_struct->pCmdBufLabels) { + pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount]; + for (uint32_t i = 0; i < cmdBufLabelCount; ++i) { + pCmdBufLabels[i].initialize(&in_struct->pCmdBufLabels[i]); + } + } + if (objectCount && in_struct->pObjects) { + pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount]; + for (uint32_t i = 0; i < objectCount; ++i) { + pObjects[i].initialize(&in_struct->pObjects[i]); + } + } +} + +safe_VkDebugUtilsMessengerCallbackDataEXT::safe_VkDebugUtilsMessengerCallbackDataEXT() + : sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT), + pNext(nullptr), + flags(), + pMessageIdName(nullptr), + messageIdNumber(), + pMessage(nullptr), + queueLabelCount(), + pQueueLabels(nullptr), + cmdBufLabelCount(), + pCmdBufLabels(nullptr), + objectCount(), + pObjects(nullptr) {} + +safe_VkDebugUtilsMessengerCallbackDataEXT::safe_VkDebugUtilsMessengerCallbackDataEXT( + const safe_VkDebugUtilsMessengerCallbackDataEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + messageIdNumber = copy_src.messageIdNumber; + queueLabelCount = copy_src.queueLabelCount; + pQueueLabels = nullptr; + cmdBufLabelCount = copy_src.cmdBufLabelCount; + pCmdBufLabels = nullptr; + objectCount = copy_src.objectCount; + pObjects = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + pMessageIdName = SafeStringCopy(copy_src.pMessageIdName); + pMessage = SafeStringCopy(copy_src.pMessage); + if (queueLabelCount && copy_src.pQueueLabels) { + pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount]; + for (uint32_t i = 0; i < queueLabelCount; ++i) { + pQueueLabels[i].initialize(©_src.pQueueLabels[i]); + } + } + if (cmdBufLabelCount && copy_src.pCmdBufLabels) { + pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount]; + for (uint32_t i = 0; i < cmdBufLabelCount; ++i) { + pCmdBufLabels[i].initialize(©_src.pCmdBufLabels[i]); + } + } + if (objectCount && copy_src.pObjects) { + pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount]; + for (uint32_t i = 0; i < objectCount; ++i) { + pObjects[i].initialize(©_src.pObjects[i]); + } + } +} + +safe_VkDebugUtilsMessengerCallbackDataEXT& safe_VkDebugUtilsMessengerCallbackDataEXT::operator=( + const safe_VkDebugUtilsMessengerCallbackDataEXT& copy_src) { + if (©_src == this) return *this; + + if (pMessageIdName) delete[] pMessageIdName; + if (pMessage) delete[] pMessage; + if (pQueueLabels) delete[] pQueueLabels; + if (pCmdBufLabels) delete[] pCmdBufLabels; + if (pObjects) delete[] pObjects; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + messageIdNumber = copy_src.messageIdNumber; + queueLabelCount = copy_src.queueLabelCount; + pQueueLabels = nullptr; + cmdBufLabelCount = copy_src.cmdBufLabelCount; + pCmdBufLabels = nullptr; + objectCount = copy_src.objectCount; + pObjects = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + pMessageIdName = SafeStringCopy(copy_src.pMessageIdName); + pMessage = SafeStringCopy(copy_src.pMessage); + if (queueLabelCount && copy_src.pQueueLabels) { + pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount]; + for (uint32_t i = 0; i < queueLabelCount; ++i) { + pQueueLabels[i].initialize(©_src.pQueueLabels[i]); + } + } + if (cmdBufLabelCount && copy_src.pCmdBufLabels) { + pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount]; + for (uint32_t i = 0; i < cmdBufLabelCount; ++i) { + pCmdBufLabels[i].initialize(©_src.pCmdBufLabels[i]); + } + } + if (objectCount && copy_src.pObjects) { + pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount]; + for (uint32_t i = 0; i < objectCount; ++i) { + pObjects[i].initialize(©_src.pObjects[i]); + } + } + + return *this; +} + +safe_VkDebugUtilsMessengerCallbackDataEXT::~safe_VkDebugUtilsMessengerCallbackDataEXT() { + if (pMessageIdName) delete[] pMessageIdName; + if (pMessage) delete[] pMessage; + if (pQueueLabels) delete[] pQueueLabels; + if (pCmdBufLabels) delete[] pCmdBufLabels; + if (pObjects) delete[] pObjects; + FreePnextChain(pNext); +} + +void safe_VkDebugUtilsMessengerCallbackDataEXT::initialize(const VkDebugUtilsMessengerCallbackDataEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pMessageIdName) delete[] pMessageIdName; + if (pMessage) delete[] pMessage; + if (pQueueLabels) delete[] pQueueLabels; + if (pCmdBufLabels) delete[] pCmdBufLabels; + if (pObjects) delete[] pObjects; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + messageIdNumber = in_struct->messageIdNumber; + queueLabelCount = in_struct->queueLabelCount; + pQueueLabels = nullptr; + cmdBufLabelCount = in_struct->cmdBufLabelCount; + pCmdBufLabels = nullptr; + objectCount = in_struct->objectCount; + pObjects = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + pMessageIdName = SafeStringCopy(in_struct->pMessageIdName); + pMessage = SafeStringCopy(in_struct->pMessage); + if (queueLabelCount && in_struct->pQueueLabels) { + pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount]; + for (uint32_t i = 0; i < queueLabelCount; ++i) { + pQueueLabels[i].initialize(&in_struct->pQueueLabels[i]); + } + } + if (cmdBufLabelCount && in_struct->pCmdBufLabels) { + pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount]; + for (uint32_t i = 0; i < cmdBufLabelCount; ++i) { + pCmdBufLabels[i].initialize(&in_struct->pCmdBufLabels[i]); + } + } + if (objectCount && in_struct->pObjects) { + pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount]; + for (uint32_t i = 0; i < objectCount; ++i) { + pObjects[i].initialize(&in_struct->pObjects[i]); + } + } +} + +void safe_VkDebugUtilsMessengerCallbackDataEXT::initialize(const safe_VkDebugUtilsMessengerCallbackDataEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + messageIdNumber = copy_src->messageIdNumber; + queueLabelCount = copy_src->queueLabelCount; + pQueueLabels = nullptr; + cmdBufLabelCount = copy_src->cmdBufLabelCount; + pCmdBufLabels = nullptr; + objectCount = copy_src->objectCount; + pObjects = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + pMessageIdName = SafeStringCopy(copy_src->pMessageIdName); + pMessage = SafeStringCopy(copy_src->pMessage); + if (queueLabelCount && copy_src->pQueueLabels) { + pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount]; + for (uint32_t i = 0; i < queueLabelCount; ++i) { + pQueueLabels[i].initialize(©_src->pQueueLabels[i]); + } + } + if (cmdBufLabelCount && copy_src->pCmdBufLabels) { + pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount]; + for (uint32_t i = 0; i < cmdBufLabelCount; ++i) { + pCmdBufLabels[i].initialize(©_src->pCmdBufLabels[i]); + } + } + if (objectCount && copy_src->pObjects) { + pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount]; + for (uint32_t i = 0; i < objectCount; ++i) { + pObjects[i].initialize(©_src->pObjects[i]); + } + } +} + +safe_VkDebugUtilsMessengerCreateInfoEXT::safe_VkDebugUtilsMessengerCreateInfoEXT( + const VkDebugUtilsMessengerCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + messageSeverity(in_struct->messageSeverity), + messageType(in_struct->messageType), + pfnUserCallback(in_struct->pfnUserCallback), + pUserData(in_struct->pUserData) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDebugUtilsMessengerCreateInfoEXT::safe_VkDebugUtilsMessengerCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT), + pNext(nullptr), + flags(), + messageSeverity(), + messageType(), + pfnUserCallback(), + pUserData(nullptr) {} + +safe_VkDebugUtilsMessengerCreateInfoEXT::safe_VkDebugUtilsMessengerCreateInfoEXT( + const safe_VkDebugUtilsMessengerCreateInfoEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + messageSeverity = copy_src.messageSeverity; + messageType = copy_src.messageType; + pfnUserCallback = copy_src.pfnUserCallback; + pUserData = copy_src.pUserData; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDebugUtilsMessengerCreateInfoEXT& safe_VkDebugUtilsMessengerCreateInfoEXT::operator=( + const safe_VkDebugUtilsMessengerCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + messageSeverity = copy_src.messageSeverity; + messageType = copy_src.messageType; + pfnUserCallback = copy_src.pfnUserCallback; + pUserData = copy_src.pUserData; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDebugUtilsMessengerCreateInfoEXT::~safe_VkDebugUtilsMessengerCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkDebugUtilsMessengerCreateInfoEXT::initialize(const VkDebugUtilsMessengerCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + messageSeverity = in_struct->messageSeverity; + messageType = in_struct->messageType; + pfnUserCallback = in_struct->pfnUserCallback; + pUserData = in_struct->pUserData; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDebugUtilsMessengerCreateInfoEXT::initialize(const safe_VkDebugUtilsMessengerCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + messageSeverity = copy_src->messageSeverity; + messageType = copy_src->messageType; + pfnUserCallback = copy_src->pfnUserCallback; + pUserData = copy_src->pUserData; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDebugUtilsObjectTagInfoEXT::safe_VkDebugUtilsObjectTagInfoEXT(const VkDebugUtilsObjectTagInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + objectType(in_struct->objectType), + objectHandle(in_struct->objectHandle), + tagName(in_struct->tagName), + tagSize(in_struct->tagSize), + pTag(in_struct->pTag) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDebugUtilsObjectTagInfoEXT::safe_VkDebugUtilsObjectTagInfoEXT() + : sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT), + pNext(nullptr), + objectType(), + objectHandle(), + tagName(), + tagSize(), + pTag(nullptr) {} + +safe_VkDebugUtilsObjectTagInfoEXT::safe_VkDebugUtilsObjectTagInfoEXT(const safe_VkDebugUtilsObjectTagInfoEXT& copy_src) { + sType = copy_src.sType; + objectType = copy_src.objectType; + objectHandle = copy_src.objectHandle; + tagName = copy_src.tagName; + tagSize = copy_src.tagSize; + pTag = copy_src.pTag; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDebugUtilsObjectTagInfoEXT& safe_VkDebugUtilsObjectTagInfoEXT::operator=(const safe_VkDebugUtilsObjectTagInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + objectType = copy_src.objectType; + objectHandle = copy_src.objectHandle; + tagName = copy_src.tagName; + tagSize = copy_src.tagSize; + pTag = copy_src.pTag; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDebugUtilsObjectTagInfoEXT::~safe_VkDebugUtilsObjectTagInfoEXT() { FreePnextChain(pNext); } + +void safe_VkDebugUtilsObjectTagInfoEXT::initialize(const VkDebugUtilsObjectTagInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + objectType = in_struct->objectType; + objectHandle = in_struct->objectHandle; + tagName = in_struct->tagName; + tagSize = in_struct->tagSize; + pTag = in_struct->pTag; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDebugUtilsObjectTagInfoEXT::initialize(const safe_VkDebugUtilsObjectTagInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + objectType = copy_src->objectType; + objectHandle = copy_src->objectHandle; + tagName = copy_src->tagName; + tagSize = copy_src->tagSize; + pTag = copy_src->pTag; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSampleLocationsInfoEXT::safe_VkSampleLocationsInfoEXT(const VkSampleLocationsInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + sampleLocationsPerPixel(in_struct->sampleLocationsPerPixel), + sampleLocationGridSize(in_struct->sampleLocationGridSize), + sampleLocationsCount(in_struct->sampleLocationsCount), + pSampleLocations(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pSampleLocations) { + pSampleLocations = new VkSampleLocationEXT[in_struct->sampleLocationsCount]; + memcpy((void*)pSampleLocations, (void*)in_struct->pSampleLocations, + sizeof(VkSampleLocationEXT) * in_struct->sampleLocationsCount); + } +} + +safe_VkSampleLocationsInfoEXT::safe_VkSampleLocationsInfoEXT() + : sType(VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT), + pNext(nullptr), + sampleLocationsPerPixel(), + sampleLocationGridSize(), + sampleLocationsCount(), + pSampleLocations(nullptr) {} + +safe_VkSampleLocationsInfoEXT::safe_VkSampleLocationsInfoEXT(const safe_VkSampleLocationsInfoEXT& copy_src) { + sType = copy_src.sType; + sampleLocationsPerPixel = copy_src.sampleLocationsPerPixel; + sampleLocationGridSize = copy_src.sampleLocationGridSize; + sampleLocationsCount = copy_src.sampleLocationsCount; + pSampleLocations = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pSampleLocations) { + pSampleLocations = new VkSampleLocationEXT[copy_src.sampleLocationsCount]; + memcpy((void*)pSampleLocations, (void*)copy_src.pSampleLocations, + sizeof(VkSampleLocationEXT) * copy_src.sampleLocationsCount); + } +} + +safe_VkSampleLocationsInfoEXT& safe_VkSampleLocationsInfoEXT::operator=(const safe_VkSampleLocationsInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pSampleLocations) delete[] pSampleLocations; + FreePnextChain(pNext); + + sType = copy_src.sType; + sampleLocationsPerPixel = copy_src.sampleLocationsPerPixel; + sampleLocationGridSize = copy_src.sampleLocationGridSize; + sampleLocationsCount = copy_src.sampleLocationsCount; + pSampleLocations = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pSampleLocations) { + pSampleLocations = new VkSampleLocationEXT[copy_src.sampleLocationsCount]; + memcpy((void*)pSampleLocations, (void*)copy_src.pSampleLocations, + sizeof(VkSampleLocationEXT) * copy_src.sampleLocationsCount); + } + + return *this; +} + +safe_VkSampleLocationsInfoEXT::~safe_VkSampleLocationsInfoEXT() { + if (pSampleLocations) delete[] pSampleLocations; + FreePnextChain(pNext); +} + +void safe_VkSampleLocationsInfoEXT::initialize(const VkSampleLocationsInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pSampleLocations) delete[] pSampleLocations; + FreePnextChain(pNext); + sType = in_struct->sType; + sampleLocationsPerPixel = in_struct->sampleLocationsPerPixel; + sampleLocationGridSize = in_struct->sampleLocationGridSize; + sampleLocationsCount = in_struct->sampleLocationsCount; + pSampleLocations = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pSampleLocations) { + pSampleLocations = new VkSampleLocationEXT[in_struct->sampleLocationsCount]; + memcpy((void*)pSampleLocations, (void*)in_struct->pSampleLocations, + sizeof(VkSampleLocationEXT) * in_struct->sampleLocationsCount); + } +} + +void safe_VkSampleLocationsInfoEXT::initialize(const safe_VkSampleLocationsInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + sampleLocationsPerPixel = copy_src->sampleLocationsPerPixel; + sampleLocationGridSize = copy_src->sampleLocationGridSize; + sampleLocationsCount = copy_src->sampleLocationsCount; + pSampleLocations = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pSampleLocations) { + pSampleLocations = new VkSampleLocationEXT[copy_src->sampleLocationsCount]; + memcpy((void*)pSampleLocations, (void*)copy_src->pSampleLocations, + sizeof(VkSampleLocationEXT) * copy_src->sampleLocationsCount); + } +} + +safe_VkRenderPassSampleLocationsBeginInfoEXT::safe_VkRenderPassSampleLocationsBeginInfoEXT( + const VkRenderPassSampleLocationsBeginInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + attachmentInitialSampleLocationsCount(in_struct->attachmentInitialSampleLocationsCount), + pAttachmentInitialSampleLocations(nullptr), + postSubpassSampleLocationsCount(in_struct->postSubpassSampleLocationsCount), + pPostSubpassSampleLocations(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pAttachmentInitialSampleLocations) { + pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[in_struct->attachmentInitialSampleLocationsCount]; + memcpy((void*)pAttachmentInitialSampleLocations, (void*)in_struct->pAttachmentInitialSampleLocations, + sizeof(VkAttachmentSampleLocationsEXT) * in_struct->attachmentInitialSampleLocationsCount); + } + + if (in_struct->pPostSubpassSampleLocations) { + pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[in_struct->postSubpassSampleLocationsCount]; + memcpy((void*)pPostSubpassSampleLocations, (void*)in_struct->pPostSubpassSampleLocations, + sizeof(VkSubpassSampleLocationsEXT) * in_struct->postSubpassSampleLocationsCount); + } +} + +safe_VkRenderPassSampleLocationsBeginInfoEXT::safe_VkRenderPassSampleLocationsBeginInfoEXT() + : sType(VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT), + pNext(nullptr), + attachmentInitialSampleLocationsCount(), + pAttachmentInitialSampleLocations(nullptr), + postSubpassSampleLocationsCount(), + pPostSubpassSampleLocations(nullptr) {} + +safe_VkRenderPassSampleLocationsBeginInfoEXT::safe_VkRenderPassSampleLocationsBeginInfoEXT( + const safe_VkRenderPassSampleLocationsBeginInfoEXT& copy_src) { + sType = copy_src.sType; + attachmentInitialSampleLocationsCount = copy_src.attachmentInitialSampleLocationsCount; + pAttachmentInitialSampleLocations = nullptr; + postSubpassSampleLocationsCount = copy_src.postSubpassSampleLocationsCount; + pPostSubpassSampleLocations = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pAttachmentInitialSampleLocations) { + pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[copy_src.attachmentInitialSampleLocationsCount]; + memcpy((void*)pAttachmentInitialSampleLocations, (void*)copy_src.pAttachmentInitialSampleLocations, + sizeof(VkAttachmentSampleLocationsEXT) * copy_src.attachmentInitialSampleLocationsCount); + } + + if (copy_src.pPostSubpassSampleLocations) { + pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[copy_src.postSubpassSampleLocationsCount]; + memcpy((void*)pPostSubpassSampleLocations, (void*)copy_src.pPostSubpassSampleLocations, + sizeof(VkSubpassSampleLocationsEXT) * copy_src.postSubpassSampleLocationsCount); + } +} + +safe_VkRenderPassSampleLocationsBeginInfoEXT& safe_VkRenderPassSampleLocationsBeginInfoEXT::operator=( + const safe_VkRenderPassSampleLocationsBeginInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pAttachmentInitialSampleLocations) delete[] pAttachmentInitialSampleLocations; + if (pPostSubpassSampleLocations) delete[] pPostSubpassSampleLocations; + FreePnextChain(pNext); + + sType = copy_src.sType; + attachmentInitialSampleLocationsCount = copy_src.attachmentInitialSampleLocationsCount; + pAttachmentInitialSampleLocations = nullptr; + postSubpassSampleLocationsCount = copy_src.postSubpassSampleLocationsCount; + pPostSubpassSampleLocations = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pAttachmentInitialSampleLocations) { + pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[copy_src.attachmentInitialSampleLocationsCount]; + memcpy((void*)pAttachmentInitialSampleLocations, (void*)copy_src.pAttachmentInitialSampleLocations, + sizeof(VkAttachmentSampleLocationsEXT) * copy_src.attachmentInitialSampleLocationsCount); + } + + if (copy_src.pPostSubpassSampleLocations) { + pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[copy_src.postSubpassSampleLocationsCount]; + memcpy((void*)pPostSubpassSampleLocations, (void*)copy_src.pPostSubpassSampleLocations, + sizeof(VkSubpassSampleLocationsEXT) * copy_src.postSubpassSampleLocationsCount); + } + + return *this; +} + +safe_VkRenderPassSampleLocationsBeginInfoEXT::~safe_VkRenderPassSampleLocationsBeginInfoEXT() { + if (pAttachmentInitialSampleLocations) delete[] pAttachmentInitialSampleLocations; + if (pPostSubpassSampleLocations) delete[] pPostSubpassSampleLocations; + FreePnextChain(pNext); +} + +void safe_VkRenderPassSampleLocationsBeginInfoEXT::initialize(const VkRenderPassSampleLocationsBeginInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pAttachmentInitialSampleLocations) delete[] pAttachmentInitialSampleLocations; + if (pPostSubpassSampleLocations) delete[] pPostSubpassSampleLocations; + FreePnextChain(pNext); + sType = in_struct->sType; + attachmentInitialSampleLocationsCount = in_struct->attachmentInitialSampleLocationsCount; + pAttachmentInitialSampleLocations = nullptr; + postSubpassSampleLocationsCount = in_struct->postSubpassSampleLocationsCount; + pPostSubpassSampleLocations = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pAttachmentInitialSampleLocations) { + pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[in_struct->attachmentInitialSampleLocationsCount]; + memcpy((void*)pAttachmentInitialSampleLocations, (void*)in_struct->pAttachmentInitialSampleLocations, + sizeof(VkAttachmentSampleLocationsEXT) * in_struct->attachmentInitialSampleLocationsCount); + } + + if (in_struct->pPostSubpassSampleLocations) { + pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[in_struct->postSubpassSampleLocationsCount]; + memcpy((void*)pPostSubpassSampleLocations, (void*)in_struct->pPostSubpassSampleLocations, + sizeof(VkSubpassSampleLocationsEXT) * in_struct->postSubpassSampleLocationsCount); + } +} + +void safe_VkRenderPassSampleLocationsBeginInfoEXT::initialize(const safe_VkRenderPassSampleLocationsBeginInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + attachmentInitialSampleLocationsCount = copy_src->attachmentInitialSampleLocationsCount; + pAttachmentInitialSampleLocations = nullptr; + postSubpassSampleLocationsCount = copy_src->postSubpassSampleLocationsCount; + pPostSubpassSampleLocations = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pAttachmentInitialSampleLocations) { + pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[copy_src->attachmentInitialSampleLocationsCount]; + memcpy((void*)pAttachmentInitialSampleLocations, (void*)copy_src->pAttachmentInitialSampleLocations, + sizeof(VkAttachmentSampleLocationsEXT) * copy_src->attachmentInitialSampleLocationsCount); + } + + if (copy_src->pPostSubpassSampleLocations) { + pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[copy_src->postSubpassSampleLocationsCount]; + memcpy((void*)pPostSubpassSampleLocations, (void*)copy_src->pPostSubpassSampleLocations, + sizeof(VkSubpassSampleLocationsEXT) * copy_src->postSubpassSampleLocationsCount); + } +} + +safe_VkPipelineSampleLocationsStateCreateInfoEXT::safe_VkPipelineSampleLocationsStateCreateInfoEXT( + const VkPipelineSampleLocationsStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + sampleLocationsEnable(in_struct->sampleLocationsEnable), + sampleLocationsInfo(&in_struct->sampleLocationsInfo) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineSampleLocationsStateCreateInfoEXT::safe_VkPipelineSampleLocationsStateCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT), pNext(nullptr), sampleLocationsEnable() {} + +safe_VkPipelineSampleLocationsStateCreateInfoEXT::safe_VkPipelineSampleLocationsStateCreateInfoEXT( + const safe_VkPipelineSampleLocationsStateCreateInfoEXT& copy_src) { + sType = copy_src.sType; + sampleLocationsEnable = copy_src.sampleLocationsEnable; + sampleLocationsInfo.initialize(©_src.sampleLocationsInfo); + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineSampleLocationsStateCreateInfoEXT& safe_VkPipelineSampleLocationsStateCreateInfoEXT::operator=( + const safe_VkPipelineSampleLocationsStateCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + sampleLocationsEnable = copy_src.sampleLocationsEnable; + sampleLocationsInfo.initialize(©_src.sampleLocationsInfo); + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineSampleLocationsStateCreateInfoEXT::~safe_VkPipelineSampleLocationsStateCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkPipelineSampleLocationsStateCreateInfoEXT::initialize(const VkPipelineSampleLocationsStateCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + sampleLocationsEnable = in_struct->sampleLocationsEnable; + sampleLocationsInfo.initialize(&in_struct->sampleLocationsInfo); + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineSampleLocationsStateCreateInfoEXT::initialize(const safe_VkPipelineSampleLocationsStateCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + sampleLocationsEnable = copy_src->sampleLocationsEnable; + sampleLocationsInfo.initialize(©_src->sampleLocationsInfo); + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::safe_VkPhysicalDeviceSampleLocationsPropertiesEXT( + const VkPhysicalDeviceSampleLocationsPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + sampleLocationSampleCounts(in_struct->sampleLocationSampleCounts), + maxSampleLocationGridSize(in_struct->maxSampleLocationGridSize), + sampleLocationSubPixelBits(in_struct->sampleLocationSubPixelBits), + variableSampleLocations(in_struct->variableSampleLocations) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < 2; ++i) { + sampleLocationCoordinateRange[i] = in_struct->sampleLocationCoordinateRange[i]; + } +} + +safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::safe_VkPhysicalDeviceSampleLocationsPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT), + pNext(nullptr), + sampleLocationSampleCounts(), + maxSampleLocationGridSize(), + sampleLocationSubPixelBits(), + variableSampleLocations() {} + +safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::safe_VkPhysicalDeviceSampleLocationsPropertiesEXT( + const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& copy_src) { + sType = copy_src.sType; + sampleLocationSampleCounts = copy_src.sampleLocationSampleCounts; + maxSampleLocationGridSize = copy_src.maxSampleLocationGridSize; + sampleLocationSubPixelBits = copy_src.sampleLocationSubPixelBits; + variableSampleLocations = copy_src.variableSampleLocations; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < 2; ++i) { + sampleLocationCoordinateRange[i] = copy_src.sampleLocationCoordinateRange[i]; + } +} + +safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::operator=( + const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + sampleLocationSampleCounts = copy_src.sampleLocationSampleCounts; + maxSampleLocationGridSize = copy_src.maxSampleLocationGridSize; + sampleLocationSubPixelBits = copy_src.sampleLocationSubPixelBits; + variableSampleLocations = copy_src.variableSampleLocations; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < 2; ++i) { + sampleLocationCoordinateRange[i] = copy_src.sampleLocationCoordinateRange[i]; + } + + return *this; +} + +safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::~safe_VkPhysicalDeviceSampleLocationsPropertiesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::initialize(const VkPhysicalDeviceSampleLocationsPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + sampleLocationSampleCounts = in_struct->sampleLocationSampleCounts; + maxSampleLocationGridSize = in_struct->maxSampleLocationGridSize; + sampleLocationSubPixelBits = in_struct->sampleLocationSubPixelBits; + variableSampleLocations = in_struct->variableSampleLocations; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < 2; ++i) { + sampleLocationCoordinateRange[i] = in_struct->sampleLocationCoordinateRange[i]; + } +} + +void safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::initialize( + const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + sampleLocationSampleCounts = copy_src->sampleLocationSampleCounts; + maxSampleLocationGridSize = copy_src->maxSampleLocationGridSize; + sampleLocationSubPixelBits = copy_src->sampleLocationSubPixelBits; + variableSampleLocations = copy_src->variableSampleLocations; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < 2; ++i) { + sampleLocationCoordinateRange[i] = copy_src->sampleLocationCoordinateRange[i]; + } +} + +safe_VkMultisamplePropertiesEXT::safe_VkMultisamplePropertiesEXT(const VkMultisamplePropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), maxSampleLocationGridSize(in_struct->maxSampleLocationGridSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMultisamplePropertiesEXT::safe_VkMultisamplePropertiesEXT() + : sType(VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT), pNext(nullptr), maxSampleLocationGridSize() {} + +safe_VkMultisamplePropertiesEXT::safe_VkMultisamplePropertiesEXT(const safe_VkMultisamplePropertiesEXT& copy_src) { + sType = copy_src.sType; + maxSampleLocationGridSize = copy_src.maxSampleLocationGridSize; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMultisamplePropertiesEXT& safe_VkMultisamplePropertiesEXT::operator=(const safe_VkMultisamplePropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxSampleLocationGridSize = copy_src.maxSampleLocationGridSize; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMultisamplePropertiesEXT::~safe_VkMultisamplePropertiesEXT() { FreePnextChain(pNext); } + +void safe_VkMultisamplePropertiesEXT::initialize(const VkMultisamplePropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxSampleLocationGridSize = in_struct->maxSampleLocationGridSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMultisamplePropertiesEXT::initialize(const safe_VkMultisamplePropertiesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxSampleLocationGridSize = copy_src->maxSampleLocationGridSize; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT( + const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), advancedBlendCoherentOperations(in_struct->advancedBlendCoherentOperations) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT), + pNext(nullptr), + advancedBlendCoherentOperations() {} + +safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT( + const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& copy_src) { + sType = copy_src.sType; + advancedBlendCoherentOperations = copy_src.advancedBlendCoherentOperations; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::operator=( + const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + advancedBlendCoherentOperations = copy_src.advancedBlendCoherentOperations; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::~safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::initialize( + const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + advancedBlendCoherentOperations = in_struct->advancedBlendCoherentOperations; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::initialize( + const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + advancedBlendCoherentOperations = copy_src->advancedBlendCoherentOperations; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT( + const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + advancedBlendMaxColorAttachments(in_struct->advancedBlendMaxColorAttachments), + advancedBlendIndependentBlend(in_struct->advancedBlendIndependentBlend), + advancedBlendNonPremultipliedSrcColor(in_struct->advancedBlendNonPremultipliedSrcColor), + advancedBlendNonPremultipliedDstColor(in_struct->advancedBlendNonPremultipliedDstColor), + advancedBlendCorrelatedOverlap(in_struct->advancedBlendCorrelatedOverlap), + advancedBlendAllOperations(in_struct->advancedBlendAllOperations) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT), + pNext(nullptr), + advancedBlendMaxColorAttachments(), + advancedBlendIndependentBlend(), + advancedBlendNonPremultipliedSrcColor(), + advancedBlendNonPremultipliedDstColor(), + advancedBlendCorrelatedOverlap(), + advancedBlendAllOperations() {} + +safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT( + const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& copy_src) { + sType = copy_src.sType; + advancedBlendMaxColorAttachments = copy_src.advancedBlendMaxColorAttachments; + advancedBlendIndependentBlend = copy_src.advancedBlendIndependentBlend; + advancedBlendNonPremultipliedSrcColor = copy_src.advancedBlendNonPremultipliedSrcColor; + advancedBlendNonPremultipliedDstColor = copy_src.advancedBlendNonPremultipliedDstColor; + advancedBlendCorrelatedOverlap = copy_src.advancedBlendCorrelatedOverlap; + advancedBlendAllOperations = copy_src.advancedBlendAllOperations; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::operator=( + const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + advancedBlendMaxColorAttachments = copy_src.advancedBlendMaxColorAttachments; + advancedBlendIndependentBlend = copy_src.advancedBlendIndependentBlend; + advancedBlendNonPremultipliedSrcColor = copy_src.advancedBlendNonPremultipliedSrcColor; + advancedBlendNonPremultipliedDstColor = copy_src.advancedBlendNonPremultipliedDstColor; + advancedBlendCorrelatedOverlap = copy_src.advancedBlendCorrelatedOverlap; + advancedBlendAllOperations = copy_src.advancedBlendAllOperations; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::~safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::initialize( + const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + advancedBlendMaxColorAttachments = in_struct->advancedBlendMaxColorAttachments; + advancedBlendIndependentBlend = in_struct->advancedBlendIndependentBlend; + advancedBlendNonPremultipliedSrcColor = in_struct->advancedBlendNonPremultipliedSrcColor; + advancedBlendNonPremultipliedDstColor = in_struct->advancedBlendNonPremultipliedDstColor; + advancedBlendCorrelatedOverlap = in_struct->advancedBlendCorrelatedOverlap; + advancedBlendAllOperations = in_struct->advancedBlendAllOperations; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::initialize( + const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + advancedBlendMaxColorAttachments = copy_src->advancedBlendMaxColorAttachments; + advancedBlendIndependentBlend = copy_src->advancedBlendIndependentBlend; + advancedBlendNonPremultipliedSrcColor = copy_src->advancedBlendNonPremultipliedSrcColor; + advancedBlendNonPremultipliedDstColor = copy_src->advancedBlendNonPremultipliedDstColor; + advancedBlendCorrelatedOverlap = copy_src->advancedBlendCorrelatedOverlap; + advancedBlendAllOperations = copy_src->advancedBlendAllOperations; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT( + const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + srcPremultiplied(in_struct->srcPremultiplied), + dstPremultiplied(in_struct->dstPremultiplied), + blendOverlap(in_struct->blendOverlap) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT), + pNext(nullptr), + srcPremultiplied(), + dstPremultiplied(), + blendOverlap() {} + +safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT( + const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& copy_src) { + sType = copy_src.sType; + srcPremultiplied = copy_src.srcPremultiplied; + dstPremultiplied = copy_src.dstPremultiplied; + blendOverlap = copy_src.blendOverlap; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::operator=( + const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + srcPremultiplied = copy_src.srcPremultiplied; + dstPremultiplied = copy_src.dstPremultiplied; + blendOverlap = copy_src.blendOverlap; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::~safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT() { + FreePnextChain(pNext); +} + +void safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::initialize( + const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + srcPremultiplied = in_struct->srcPremultiplied; + dstPremultiplied = in_struct->dstPremultiplied; + blendOverlap = in_struct->blendOverlap; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::initialize( + const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcPremultiplied = copy_src->srcPremultiplied; + dstPremultiplied = copy_src->dstPremultiplied; + blendOverlap = copy_src->blendOverlap; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDrmFormatModifierPropertiesListEXT::safe_VkDrmFormatModifierPropertiesListEXT( + const VkDrmFormatModifierPropertiesListEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), drmFormatModifierCount(in_struct->drmFormatModifierCount), pDrmFormatModifierProperties(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pDrmFormatModifierProperties) { + pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[in_struct->drmFormatModifierCount]; + memcpy((void*)pDrmFormatModifierProperties, (void*)in_struct->pDrmFormatModifierProperties, + sizeof(VkDrmFormatModifierPropertiesEXT) * in_struct->drmFormatModifierCount); + } +} + +safe_VkDrmFormatModifierPropertiesListEXT::safe_VkDrmFormatModifierPropertiesListEXT() + : sType(VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT), + pNext(nullptr), + drmFormatModifierCount(), + pDrmFormatModifierProperties(nullptr) {} + +safe_VkDrmFormatModifierPropertiesListEXT::safe_VkDrmFormatModifierPropertiesListEXT( + const safe_VkDrmFormatModifierPropertiesListEXT& copy_src) { + sType = copy_src.sType; + drmFormatModifierCount = copy_src.drmFormatModifierCount; + pDrmFormatModifierProperties = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDrmFormatModifierProperties) { + pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[copy_src.drmFormatModifierCount]; + memcpy((void*)pDrmFormatModifierProperties, (void*)copy_src.pDrmFormatModifierProperties, + sizeof(VkDrmFormatModifierPropertiesEXT) * copy_src.drmFormatModifierCount); + } +} + +safe_VkDrmFormatModifierPropertiesListEXT& safe_VkDrmFormatModifierPropertiesListEXT::operator=( + const safe_VkDrmFormatModifierPropertiesListEXT& copy_src) { + if (©_src == this) return *this; + + if (pDrmFormatModifierProperties) delete[] pDrmFormatModifierProperties; + FreePnextChain(pNext); + + sType = copy_src.sType; + drmFormatModifierCount = copy_src.drmFormatModifierCount; + pDrmFormatModifierProperties = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDrmFormatModifierProperties) { + pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[copy_src.drmFormatModifierCount]; + memcpy((void*)pDrmFormatModifierProperties, (void*)copy_src.pDrmFormatModifierProperties, + sizeof(VkDrmFormatModifierPropertiesEXT) * copy_src.drmFormatModifierCount); + } + + return *this; +} + +safe_VkDrmFormatModifierPropertiesListEXT::~safe_VkDrmFormatModifierPropertiesListEXT() { + if (pDrmFormatModifierProperties) delete[] pDrmFormatModifierProperties; + FreePnextChain(pNext); +} + +void safe_VkDrmFormatModifierPropertiesListEXT::initialize(const VkDrmFormatModifierPropertiesListEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDrmFormatModifierProperties) delete[] pDrmFormatModifierProperties; + FreePnextChain(pNext); + sType = in_struct->sType; + drmFormatModifierCount = in_struct->drmFormatModifierCount; + pDrmFormatModifierProperties = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pDrmFormatModifierProperties) { + pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[in_struct->drmFormatModifierCount]; + memcpy((void*)pDrmFormatModifierProperties, (void*)in_struct->pDrmFormatModifierProperties, + sizeof(VkDrmFormatModifierPropertiesEXT) * in_struct->drmFormatModifierCount); + } +} + +void safe_VkDrmFormatModifierPropertiesListEXT::initialize(const safe_VkDrmFormatModifierPropertiesListEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + drmFormatModifierCount = copy_src->drmFormatModifierCount; + pDrmFormatModifierProperties = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pDrmFormatModifierProperties) { + pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[copy_src->drmFormatModifierCount]; + memcpy((void*)pDrmFormatModifierProperties, (void*)copy_src->pDrmFormatModifierProperties, + sizeof(VkDrmFormatModifierPropertiesEXT) * copy_src->drmFormatModifierCount); + } +} + +safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT( + const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + drmFormatModifier(in_struct->drmFormatModifier), + sharingMode(in_struct->sharingMode), + queueFamilyIndexCount(0), + pQueueFamilyIndices(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices, + sizeof(uint32_t) * in_struct->queueFamilyIndexCount); + queueFamilyIndexCount = in_struct->queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT), + pNext(nullptr), + drmFormatModifier(), + sharingMode(), + queueFamilyIndexCount(), + pQueueFamilyIndices(nullptr) {} + +safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT( + const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& copy_src) { + sType = copy_src.sType; + drmFormatModifier = copy_src.drmFormatModifier; + sharingMode = copy_src.sharingMode; + pQueueFamilyIndices = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount); + queueFamilyIndexCount = copy_src.queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::operator=( + const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pQueueFamilyIndices) delete[] pQueueFamilyIndices; + FreePnextChain(pNext); + + sType = copy_src.sType; + drmFormatModifier = copy_src.drmFormatModifier; + sharingMode = copy_src.sharingMode; + pQueueFamilyIndices = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount); + queueFamilyIndexCount = copy_src.queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } + + return *this; +} + +safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::~safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT() { + if (pQueueFamilyIndices) delete[] pQueueFamilyIndices; + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::initialize(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pQueueFamilyIndices) delete[] pQueueFamilyIndices; + FreePnextChain(pNext); + sType = in_struct->sType; + drmFormatModifier = in_struct->drmFormatModifier; + sharingMode = in_struct->sharingMode; + pQueueFamilyIndices = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices, + sizeof(uint32_t) * in_struct->queueFamilyIndexCount); + queueFamilyIndexCount = in_struct->queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +void safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::initialize( + const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + drmFormatModifier = copy_src->drmFormatModifier; + sharingMode = copy_src->sharingMode; + pQueueFamilyIndices = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if ((copy_src->sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src->pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[copy_src->queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)copy_src->pQueueFamilyIndices, + sizeof(uint32_t) * copy_src->queueFamilyIndexCount); + queueFamilyIndexCount = copy_src->queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +safe_VkImageDrmFormatModifierListCreateInfoEXT::safe_VkImageDrmFormatModifierListCreateInfoEXT( + const VkImageDrmFormatModifierListCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), drmFormatModifierCount(in_struct->drmFormatModifierCount), pDrmFormatModifiers(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pDrmFormatModifiers) { + pDrmFormatModifiers = new uint64_t[in_struct->drmFormatModifierCount]; + memcpy((void*)pDrmFormatModifiers, (void*)in_struct->pDrmFormatModifiers, + sizeof(uint64_t) * in_struct->drmFormatModifierCount); + } +} + +safe_VkImageDrmFormatModifierListCreateInfoEXT::safe_VkImageDrmFormatModifierListCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT), + pNext(nullptr), + drmFormatModifierCount(), + pDrmFormatModifiers(nullptr) {} + +safe_VkImageDrmFormatModifierListCreateInfoEXT::safe_VkImageDrmFormatModifierListCreateInfoEXT( + const safe_VkImageDrmFormatModifierListCreateInfoEXT& copy_src) { + sType = copy_src.sType; + drmFormatModifierCount = copy_src.drmFormatModifierCount; + pDrmFormatModifiers = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDrmFormatModifiers) { + pDrmFormatModifiers = new uint64_t[copy_src.drmFormatModifierCount]; + memcpy((void*)pDrmFormatModifiers, (void*)copy_src.pDrmFormatModifiers, sizeof(uint64_t) * copy_src.drmFormatModifierCount); + } +} + +safe_VkImageDrmFormatModifierListCreateInfoEXT& safe_VkImageDrmFormatModifierListCreateInfoEXT::operator=( + const safe_VkImageDrmFormatModifierListCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pDrmFormatModifiers) delete[] pDrmFormatModifiers; + FreePnextChain(pNext); + + sType = copy_src.sType; + drmFormatModifierCount = copy_src.drmFormatModifierCount; + pDrmFormatModifiers = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDrmFormatModifiers) { + pDrmFormatModifiers = new uint64_t[copy_src.drmFormatModifierCount]; + memcpy((void*)pDrmFormatModifiers, (void*)copy_src.pDrmFormatModifiers, sizeof(uint64_t) * copy_src.drmFormatModifierCount); + } + + return *this; +} + +safe_VkImageDrmFormatModifierListCreateInfoEXT::~safe_VkImageDrmFormatModifierListCreateInfoEXT() { + if (pDrmFormatModifiers) delete[] pDrmFormatModifiers; + FreePnextChain(pNext); +} + +void safe_VkImageDrmFormatModifierListCreateInfoEXT::initialize(const VkImageDrmFormatModifierListCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDrmFormatModifiers) delete[] pDrmFormatModifiers; + FreePnextChain(pNext); + sType = in_struct->sType; + drmFormatModifierCount = in_struct->drmFormatModifierCount; + pDrmFormatModifiers = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pDrmFormatModifiers) { + pDrmFormatModifiers = new uint64_t[in_struct->drmFormatModifierCount]; + memcpy((void*)pDrmFormatModifiers, (void*)in_struct->pDrmFormatModifiers, + sizeof(uint64_t) * in_struct->drmFormatModifierCount); + } +} + +void safe_VkImageDrmFormatModifierListCreateInfoEXT::initialize(const safe_VkImageDrmFormatModifierListCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + drmFormatModifierCount = copy_src->drmFormatModifierCount; + pDrmFormatModifiers = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pDrmFormatModifiers) { + pDrmFormatModifiers = new uint64_t[copy_src->drmFormatModifierCount]; + memcpy((void*)pDrmFormatModifiers, (void*)copy_src->pDrmFormatModifiers, + sizeof(uint64_t) * copy_src->drmFormatModifierCount); + } +} + +safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::safe_VkImageDrmFormatModifierExplicitCreateInfoEXT( + const VkImageDrmFormatModifierExplicitCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + drmFormatModifier(in_struct->drmFormatModifier), + drmFormatModifierPlaneCount(in_struct->drmFormatModifierPlaneCount), + pPlaneLayouts(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pPlaneLayouts) { + pPlaneLayouts = new VkSubresourceLayout[in_struct->drmFormatModifierPlaneCount]; + memcpy((void*)pPlaneLayouts, (void*)in_struct->pPlaneLayouts, + sizeof(VkSubresourceLayout) * in_struct->drmFormatModifierPlaneCount); + } +} + +safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::safe_VkImageDrmFormatModifierExplicitCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT), + pNext(nullptr), + drmFormatModifier(), + drmFormatModifierPlaneCount(), + pPlaneLayouts(nullptr) {} + +safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::safe_VkImageDrmFormatModifierExplicitCreateInfoEXT( + const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& copy_src) { + sType = copy_src.sType; + drmFormatModifier = copy_src.drmFormatModifier; + drmFormatModifierPlaneCount = copy_src.drmFormatModifierPlaneCount; + pPlaneLayouts = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPlaneLayouts) { + pPlaneLayouts = new VkSubresourceLayout[copy_src.drmFormatModifierPlaneCount]; + memcpy((void*)pPlaneLayouts, (void*)copy_src.pPlaneLayouts, + sizeof(VkSubresourceLayout) * copy_src.drmFormatModifierPlaneCount); + } +} + +safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::operator=( + const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pPlaneLayouts) delete[] pPlaneLayouts; + FreePnextChain(pNext); + + sType = copy_src.sType; + drmFormatModifier = copy_src.drmFormatModifier; + drmFormatModifierPlaneCount = copy_src.drmFormatModifierPlaneCount; + pPlaneLayouts = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPlaneLayouts) { + pPlaneLayouts = new VkSubresourceLayout[copy_src.drmFormatModifierPlaneCount]; + memcpy((void*)pPlaneLayouts, (void*)copy_src.pPlaneLayouts, + sizeof(VkSubresourceLayout) * copy_src.drmFormatModifierPlaneCount); + } + + return *this; +} + +safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::~safe_VkImageDrmFormatModifierExplicitCreateInfoEXT() { + if (pPlaneLayouts) delete[] pPlaneLayouts; + FreePnextChain(pNext); +} + +void safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::initialize(const VkImageDrmFormatModifierExplicitCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPlaneLayouts) delete[] pPlaneLayouts; + FreePnextChain(pNext); + sType = in_struct->sType; + drmFormatModifier = in_struct->drmFormatModifier; + drmFormatModifierPlaneCount = in_struct->drmFormatModifierPlaneCount; + pPlaneLayouts = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pPlaneLayouts) { + pPlaneLayouts = new VkSubresourceLayout[in_struct->drmFormatModifierPlaneCount]; + memcpy((void*)pPlaneLayouts, (void*)in_struct->pPlaneLayouts, + sizeof(VkSubresourceLayout) * in_struct->drmFormatModifierPlaneCount); + } +} + +void safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::initialize( + const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + drmFormatModifier = copy_src->drmFormatModifier; + drmFormatModifierPlaneCount = copy_src->drmFormatModifierPlaneCount; + pPlaneLayouts = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pPlaneLayouts) { + pPlaneLayouts = new VkSubresourceLayout[copy_src->drmFormatModifierPlaneCount]; + memcpy((void*)pPlaneLayouts, (void*)copy_src->pPlaneLayouts, + sizeof(VkSubresourceLayout) * copy_src->drmFormatModifierPlaneCount); + } +} + +safe_VkImageDrmFormatModifierPropertiesEXT::safe_VkImageDrmFormatModifierPropertiesEXT( + const VkImageDrmFormatModifierPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), drmFormatModifier(in_struct->drmFormatModifier) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageDrmFormatModifierPropertiesEXT::safe_VkImageDrmFormatModifierPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT), pNext(nullptr), drmFormatModifier() {} + +safe_VkImageDrmFormatModifierPropertiesEXT::safe_VkImageDrmFormatModifierPropertiesEXT( + const safe_VkImageDrmFormatModifierPropertiesEXT& copy_src) { + sType = copy_src.sType; + drmFormatModifier = copy_src.drmFormatModifier; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageDrmFormatModifierPropertiesEXT& safe_VkImageDrmFormatModifierPropertiesEXT::operator=( + const safe_VkImageDrmFormatModifierPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + drmFormatModifier = copy_src.drmFormatModifier; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageDrmFormatModifierPropertiesEXT::~safe_VkImageDrmFormatModifierPropertiesEXT() { FreePnextChain(pNext); } + +void safe_VkImageDrmFormatModifierPropertiesEXT::initialize(const VkImageDrmFormatModifierPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + drmFormatModifier = in_struct->drmFormatModifier; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageDrmFormatModifierPropertiesEXT::initialize(const safe_VkImageDrmFormatModifierPropertiesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + drmFormatModifier = copy_src->drmFormatModifier; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDrmFormatModifierPropertiesList2EXT::safe_VkDrmFormatModifierPropertiesList2EXT( + const VkDrmFormatModifierPropertiesList2EXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), drmFormatModifierCount(in_struct->drmFormatModifierCount), pDrmFormatModifierProperties(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pDrmFormatModifierProperties) { + pDrmFormatModifierProperties = new VkDrmFormatModifierProperties2EXT[in_struct->drmFormatModifierCount]; + memcpy((void*)pDrmFormatModifierProperties, (void*)in_struct->pDrmFormatModifierProperties, + sizeof(VkDrmFormatModifierProperties2EXT) * in_struct->drmFormatModifierCount); + } +} + +safe_VkDrmFormatModifierPropertiesList2EXT::safe_VkDrmFormatModifierPropertiesList2EXT() + : sType(VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT), + pNext(nullptr), + drmFormatModifierCount(), + pDrmFormatModifierProperties(nullptr) {} + +safe_VkDrmFormatModifierPropertiesList2EXT::safe_VkDrmFormatModifierPropertiesList2EXT( + const safe_VkDrmFormatModifierPropertiesList2EXT& copy_src) { + sType = copy_src.sType; + drmFormatModifierCount = copy_src.drmFormatModifierCount; + pDrmFormatModifierProperties = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDrmFormatModifierProperties) { + pDrmFormatModifierProperties = new VkDrmFormatModifierProperties2EXT[copy_src.drmFormatModifierCount]; + memcpy((void*)pDrmFormatModifierProperties, (void*)copy_src.pDrmFormatModifierProperties, + sizeof(VkDrmFormatModifierProperties2EXT) * copy_src.drmFormatModifierCount); + } +} + +safe_VkDrmFormatModifierPropertiesList2EXT& safe_VkDrmFormatModifierPropertiesList2EXT::operator=( + const safe_VkDrmFormatModifierPropertiesList2EXT& copy_src) { + if (©_src == this) return *this; + + if (pDrmFormatModifierProperties) delete[] pDrmFormatModifierProperties; + FreePnextChain(pNext); + + sType = copy_src.sType; + drmFormatModifierCount = copy_src.drmFormatModifierCount; + pDrmFormatModifierProperties = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDrmFormatModifierProperties) { + pDrmFormatModifierProperties = new VkDrmFormatModifierProperties2EXT[copy_src.drmFormatModifierCount]; + memcpy((void*)pDrmFormatModifierProperties, (void*)copy_src.pDrmFormatModifierProperties, + sizeof(VkDrmFormatModifierProperties2EXT) * copy_src.drmFormatModifierCount); + } + + return *this; +} + +safe_VkDrmFormatModifierPropertiesList2EXT::~safe_VkDrmFormatModifierPropertiesList2EXT() { + if (pDrmFormatModifierProperties) delete[] pDrmFormatModifierProperties; + FreePnextChain(pNext); +} + +void safe_VkDrmFormatModifierPropertiesList2EXT::initialize(const VkDrmFormatModifierPropertiesList2EXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDrmFormatModifierProperties) delete[] pDrmFormatModifierProperties; + FreePnextChain(pNext); + sType = in_struct->sType; + drmFormatModifierCount = in_struct->drmFormatModifierCount; + pDrmFormatModifierProperties = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pDrmFormatModifierProperties) { + pDrmFormatModifierProperties = new VkDrmFormatModifierProperties2EXT[in_struct->drmFormatModifierCount]; + memcpy((void*)pDrmFormatModifierProperties, (void*)in_struct->pDrmFormatModifierProperties, + sizeof(VkDrmFormatModifierProperties2EXT) * in_struct->drmFormatModifierCount); + } +} + +void safe_VkDrmFormatModifierPropertiesList2EXT::initialize(const safe_VkDrmFormatModifierPropertiesList2EXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + drmFormatModifierCount = copy_src->drmFormatModifierCount; + pDrmFormatModifierProperties = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pDrmFormatModifierProperties) { + pDrmFormatModifierProperties = new VkDrmFormatModifierProperties2EXT[copy_src->drmFormatModifierCount]; + memcpy((void*)pDrmFormatModifierProperties, (void*)copy_src->pDrmFormatModifierProperties, + sizeof(VkDrmFormatModifierProperties2EXT) * copy_src->drmFormatModifierCount); + } +} + +safe_VkValidationCacheCreateInfoEXT::safe_VkValidationCacheCreateInfoEXT(const VkValidationCacheCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + initialDataSize(in_struct->initialDataSize), + pInitialData(in_struct->pInitialData) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkValidationCacheCreateInfoEXT::safe_VkValidationCacheCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT), + pNext(nullptr), + flags(), + initialDataSize(), + pInitialData(nullptr) {} + +safe_VkValidationCacheCreateInfoEXT::safe_VkValidationCacheCreateInfoEXT(const safe_VkValidationCacheCreateInfoEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + initialDataSize = copy_src.initialDataSize; + pInitialData = copy_src.pInitialData; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkValidationCacheCreateInfoEXT& safe_VkValidationCacheCreateInfoEXT::operator=( + const safe_VkValidationCacheCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + initialDataSize = copy_src.initialDataSize; + pInitialData = copy_src.pInitialData; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkValidationCacheCreateInfoEXT::~safe_VkValidationCacheCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkValidationCacheCreateInfoEXT::initialize(const VkValidationCacheCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + initialDataSize = in_struct->initialDataSize; + pInitialData = in_struct->pInitialData; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkValidationCacheCreateInfoEXT::initialize(const safe_VkValidationCacheCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + initialDataSize = copy_src->initialDataSize; + pInitialData = copy_src->pInitialData; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkShaderModuleValidationCacheCreateInfoEXT::safe_VkShaderModuleValidationCacheCreateInfoEXT( + const VkShaderModuleValidationCacheCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), validationCache(in_struct->validationCache) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkShaderModuleValidationCacheCreateInfoEXT::safe_VkShaderModuleValidationCacheCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT), pNext(nullptr), validationCache() {} + +safe_VkShaderModuleValidationCacheCreateInfoEXT::safe_VkShaderModuleValidationCacheCreateInfoEXT( + const safe_VkShaderModuleValidationCacheCreateInfoEXT& copy_src) { + sType = copy_src.sType; + validationCache = copy_src.validationCache; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkShaderModuleValidationCacheCreateInfoEXT& safe_VkShaderModuleValidationCacheCreateInfoEXT::operator=( + const safe_VkShaderModuleValidationCacheCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + validationCache = copy_src.validationCache; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkShaderModuleValidationCacheCreateInfoEXT::~safe_VkShaderModuleValidationCacheCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkShaderModuleValidationCacheCreateInfoEXT::initialize(const VkShaderModuleValidationCacheCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + validationCache = in_struct->validationCache; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkShaderModuleValidationCacheCreateInfoEXT::initialize(const safe_VkShaderModuleValidationCacheCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + validationCache = copy_src->validationCache; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::safe_VkPhysicalDeviceImageViewImageFormatInfoEXT( + const VkPhysicalDeviceImageViewImageFormatInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), imageViewType(in_struct->imageViewType) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::safe_VkPhysicalDeviceImageViewImageFormatInfoEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT), pNext(nullptr), imageViewType() {} + +safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::safe_VkPhysicalDeviceImageViewImageFormatInfoEXT( + const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& copy_src) { + sType = copy_src.sType; + imageViewType = copy_src.imageViewType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::operator=( + const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + imageViewType = copy_src.imageViewType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::~safe_VkPhysicalDeviceImageViewImageFormatInfoEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::initialize(const VkPhysicalDeviceImageViewImageFormatInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + imageViewType = in_struct->imageViewType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::initialize(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + imageViewType = copy_src->imageViewType; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkFilterCubicImageViewImageFormatPropertiesEXT::safe_VkFilterCubicImageViewImageFormatPropertiesEXT( + const VkFilterCubicImageViewImageFormatPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), filterCubic(in_struct->filterCubic), filterCubicMinmax(in_struct->filterCubicMinmax) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkFilterCubicImageViewImageFormatPropertiesEXT::safe_VkFilterCubicImageViewImageFormatPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT), + pNext(nullptr), + filterCubic(), + filterCubicMinmax() {} + +safe_VkFilterCubicImageViewImageFormatPropertiesEXT::safe_VkFilterCubicImageViewImageFormatPropertiesEXT( + const safe_VkFilterCubicImageViewImageFormatPropertiesEXT& copy_src) { + sType = copy_src.sType; + filterCubic = copy_src.filterCubic; + filterCubicMinmax = copy_src.filterCubicMinmax; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkFilterCubicImageViewImageFormatPropertiesEXT& safe_VkFilterCubicImageViewImageFormatPropertiesEXT::operator=( + const safe_VkFilterCubicImageViewImageFormatPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + filterCubic = copy_src.filterCubic; + filterCubicMinmax = copy_src.filterCubicMinmax; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkFilterCubicImageViewImageFormatPropertiesEXT::~safe_VkFilterCubicImageViewImageFormatPropertiesEXT() { + FreePnextChain(pNext); +} + +void safe_VkFilterCubicImageViewImageFormatPropertiesEXT::initialize( + const VkFilterCubicImageViewImageFormatPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + filterCubic = in_struct->filterCubic; + filterCubicMinmax = in_struct->filterCubicMinmax; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkFilterCubicImageViewImageFormatPropertiesEXT::initialize( + const safe_VkFilterCubicImageViewImageFormatPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + filterCubic = copy_src->filterCubic; + filterCubicMinmax = copy_src->filterCubicMinmax; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImportMemoryHostPointerInfoEXT::safe_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), handleType(in_struct->handleType), pHostPointer(in_struct->pHostPointer) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImportMemoryHostPointerInfoEXT::safe_VkImportMemoryHostPointerInfoEXT() + : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT), pNext(nullptr), handleType(), pHostPointer(nullptr) {} + +safe_VkImportMemoryHostPointerInfoEXT::safe_VkImportMemoryHostPointerInfoEXT( + const safe_VkImportMemoryHostPointerInfoEXT& copy_src) { + sType = copy_src.sType; + handleType = copy_src.handleType; + pHostPointer = copy_src.pHostPointer; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImportMemoryHostPointerInfoEXT& safe_VkImportMemoryHostPointerInfoEXT::operator=( + const safe_VkImportMemoryHostPointerInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + handleType = copy_src.handleType; + pHostPointer = copy_src.pHostPointer; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImportMemoryHostPointerInfoEXT::~safe_VkImportMemoryHostPointerInfoEXT() { FreePnextChain(pNext); } + +void safe_VkImportMemoryHostPointerInfoEXT::initialize(const VkImportMemoryHostPointerInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + handleType = in_struct->handleType; + pHostPointer = in_struct->pHostPointer; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImportMemoryHostPointerInfoEXT::initialize(const safe_VkImportMemoryHostPointerInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + handleType = copy_src->handleType; + pHostPointer = copy_src->pHostPointer; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMemoryHostPointerPropertiesEXT::safe_VkMemoryHostPointerPropertiesEXT(const VkMemoryHostPointerPropertiesEXT* 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_VkMemoryHostPointerPropertiesEXT::safe_VkMemoryHostPointerPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT), pNext(nullptr), memoryTypeBits() {} + +safe_VkMemoryHostPointerPropertiesEXT::safe_VkMemoryHostPointerPropertiesEXT( + const safe_VkMemoryHostPointerPropertiesEXT& copy_src) { + sType = copy_src.sType; + memoryTypeBits = copy_src.memoryTypeBits; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryHostPointerPropertiesEXT& safe_VkMemoryHostPointerPropertiesEXT::operator=( + const safe_VkMemoryHostPointerPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memoryTypeBits = copy_src.memoryTypeBits; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryHostPointerPropertiesEXT::~safe_VkMemoryHostPointerPropertiesEXT() { FreePnextChain(pNext); } + +void safe_VkMemoryHostPointerPropertiesEXT::initialize(const VkMemoryHostPointerPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memoryTypeBits = in_struct->memoryTypeBits; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryHostPointerPropertiesEXT::initialize(const safe_VkMemoryHostPointerPropertiesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memoryTypeBits = copy_src->memoryTypeBits; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT( + const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), minImportedHostPointerAlignment(in_struct->minImportedHostPointerAlignment) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT), + pNext(nullptr), + minImportedHostPointerAlignment() {} + +safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT( + const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& copy_src) { + sType = copy_src.sType; + minImportedHostPointerAlignment = copy_src.minImportedHostPointerAlignment; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::operator=( + const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + minImportedHostPointerAlignment = copy_src.minImportedHostPointerAlignment; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::~safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::initialize( + const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + minImportedHostPointerAlignment = in_struct->minImportedHostPointerAlignment; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::initialize( + const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + minImportedHostPointerAlignment = copy_src->minImportedHostPointerAlignment; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT( + const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), maxVertexAttribDivisor(in_struct->maxVertexAttribDivisor) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT), pNext(nullptr), maxVertexAttribDivisor() {} + +safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT( + const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& copy_src) { + sType = copy_src.sType; + maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::operator=( + const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::~safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::initialize( + const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxVertexAttribDivisor = in_struct->maxVertexAttribDivisor; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::initialize( + const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxVertexAttribDivisor = copy_src->maxVertexAttribDivisor; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::safe_VkPhysicalDevicePCIBusInfoPropertiesEXT( + const VkPhysicalDevicePCIBusInfoPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + pciDomain(in_struct->pciDomain), + pciBus(in_struct->pciBus), + pciDevice(in_struct->pciDevice), + pciFunction(in_struct->pciFunction) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::safe_VkPhysicalDevicePCIBusInfoPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT), + pNext(nullptr), + pciDomain(), + pciBus(), + pciDevice(), + pciFunction() {} + +safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::safe_VkPhysicalDevicePCIBusInfoPropertiesEXT( + const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& copy_src) { + sType = copy_src.sType; + pciDomain = copy_src.pciDomain; + pciBus = copy_src.pciBus; + pciDevice = copy_src.pciDevice; + pciFunction = copy_src.pciFunction; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::operator=( + const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pciDomain = copy_src.pciDomain; + pciBus = copy_src.pciBus; + pciDevice = copy_src.pciDevice; + pciFunction = copy_src.pciFunction; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::~safe_VkPhysicalDevicePCIBusInfoPropertiesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::initialize(const VkPhysicalDevicePCIBusInfoPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pciDomain = in_struct->pciDomain; + pciBus = in_struct->pciBus; + pciDevice = in_struct->pciDevice; + pciFunction = in_struct->pciFunction; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::initialize(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pciDomain = copy_src->pciDomain; + pciBus = copy_src->pciBus; + pciDevice = copy_src->pciDevice; + pciFunction = copy_src->pciFunction; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT( + const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + fragmentDensityMap(in_struct->fragmentDensityMap), + fragmentDensityMapDynamic(in_struct->fragmentDensityMapDynamic), + fragmentDensityMapNonSubsampledImages(in_struct->fragmentDensityMapNonSubsampledImages) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT), + pNext(nullptr), + fragmentDensityMap(), + fragmentDensityMapDynamic(), + fragmentDensityMapNonSubsampledImages() {} + +safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT( + const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& copy_src) { + sType = copy_src.sType; + fragmentDensityMap = copy_src.fragmentDensityMap; + fragmentDensityMapDynamic = copy_src.fragmentDensityMapDynamic; + fragmentDensityMapNonSubsampledImages = copy_src.fragmentDensityMapNonSubsampledImages; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::operator=( + const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + fragmentDensityMap = copy_src.fragmentDensityMap; + fragmentDensityMapDynamic = copy_src.fragmentDensityMapDynamic; + fragmentDensityMapNonSubsampledImages = copy_src.fragmentDensityMapNonSubsampledImages; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::~safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::initialize(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + fragmentDensityMap = in_struct->fragmentDensityMap; + fragmentDensityMapDynamic = in_struct->fragmentDensityMapDynamic; + fragmentDensityMapNonSubsampledImages = in_struct->fragmentDensityMapNonSubsampledImages; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::initialize( + const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + fragmentDensityMap = copy_src->fragmentDensityMap; + fragmentDensityMapDynamic = copy_src->fragmentDensityMapDynamic; + fragmentDensityMapNonSubsampledImages = copy_src->fragmentDensityMapNonSubsampledImages; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT( + const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + minFragmentDensityTexelSize(in_struct->minFragmentDensityTexelSize), + maxFragmentDensityTexelSize(in_struct->maxFragmentDensityTexelSize), + fragmentDensityInvocations(in_struct->fragmentDensityInvocations) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT), + pNext(nullptr), + minFragmentDensityTexelSize(), + maxFragmentDensityTexelSize(), + fragmentDensityInvocations() {} + +safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT( + const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& copy_src) { + sType = copy_src.sType; + minFragmentDensityTexelSize = copy_src.minFragmentDensityTexelSize; + maxFragmentDensityTexelSize = copy_src.maxFragmentDensityTexelSize; + fragmentDensityInvocations = copy_src.fragmentDensityInvocations; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::operator=( + const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + minFragmentDensityTexelSize = copy_src.minFragmentDensityTexelSize; + maxFragmentDensityTexelSize = copy_src.maxFragmentDensityTexelSize; + fragmentDensityInvocations = copy_src.fragmentDensityInvocations; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::~safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::initialize( + const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + minFragmentDensityTexelSize = in_struct->minFragmentDensityTexelSize; + maxFragmentDensityTexelSize = in_struct->maxFragmentDensityTexelSize; + fragmentDensityInvocations = in_struct->fragmentDensityInvocations; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::initialize( + const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + minFragmentDensityTexelSize = copy_src->minFragmentDensityTexelSize; + maxFragmentDensityTexelSize = copy_src->maxFragmentDensityTexelSize; + fragmentDensityInvocations = copy_src->fragmentDensityInvocations; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkRenderPassFragmentDensityMapCreateInfoEXT::safe_VkRenderPassFragmentDensityMapCreateInfoEXT( + const VkRenderPassFragmentDensityMapCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), fragmentDensityMapAttachment(in_struct->fragmentDensityMapAttachment) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkRenderPassFragmentDensityMapCreateInfoEXT::safe_VkRenderPassFragmentDensityMapCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT), pNext(nullptr), fragmentDensityMapAttachment() {} + +safe_VkRenderPassFragmentDensityMapCreateInfoEXT::safe_VkRenderPassFragmentDensityMapCreateInfoEXT( + const safe_VkRenderPassFragmentDensityMapCreateInfoEXT& copy_src) { + sType = copy_src.sType; + fragmentDensityMapAttachment = copy_src.fragmentDensityMapAttachment; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkRenderPassFragmentDensityMapCreateInfoEXT& safe_VkRenderPassFragmentDensityMapCreateInfoEXT::operator=( + const safe_VkRenderPassFragmentDensityMapCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + fragmentDensityMapAttachment = copy_src.fragmentDensityMapAttachment; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkRenderPassFragmentDensityMapCreateInfoEXT::~safe_VkRenderPassFragmentDensityMapCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkRenderPassFragmentDensityMapCreateInfoEXT::initialize(const VkRenderPassFragmentDensityMapCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + fragmentDensityMapAttachment = in_struct->fragmentDensityMapAttachment; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkRenderPassFragmentDensityMapCreateInfoEXT::initialize(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + fragmentDensityMapAttachment = copy_src->fragmentDensityMapAttachment; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT( + const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + shaderImageInt64Atomics(in_struct->shaderImageInt64Atomics), + sparseImageInt64Atomics(in_struct->sparseImageInt64Atomics) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT), + pNext(nullptr), + shaderImageInt64Atomics(), + sparseImageInt64Atomics() {} + +safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT( + const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& copy_src) { + sType = copy_src.sType; + shaderImageInt64Atomics = copy_src.shaderImageInt64Atomics; + sparseImageInt64Atomics = copy_src.sparseImageInt64Atomics; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::operator=( + const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderImageInt64Atomics = copy_src.shaderImageInt64Atomics; + sparseImageInt64Atomics = copy_src.sparseImageInt64Atomics; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::~safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::initialize( + const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderImageInt64Atomics = in_struct->shaderImageInt64Atomics; + sparseImageInt64Atomics = in_struct->sparseImageInt64Atomics; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::initialize( + const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderImageInt64Atomics = copy_src->shaderImageInt64Atomics; + sparseImageInt64Atomics = copy_src->sparseImageInt64Atomics; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT( + const VkPhysicalDeviceMemoryBudgetPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) { + heapBudget[i] = in_struct->heapBudget[i]; + } + + for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) { + heapUsage[i] = in_struct->heapUsage[i]; + } +} + +safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT), pNext(nullptr) {} + +safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT( + const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& copy_src) { + sType = copy_src.sType; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) { + heapBudget[i] = copy_src.heapBudget[i]; + } + + for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) { + heapUsage[i] = copy_src.heapUsage[i]; + } +} + +safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::operator=( + const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) { + heapBudget[i] = copy_src.heapBudget[i]; + } + + for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) { + heapUsage[i] = copy_src.heapUsage[i]; + } + + return *this; +} + +safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::~safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::initialize(const VkPhysicalDeviceMemoryBudgetPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) { + heapBudget[i] = in_struct->heapBudget[i]; + } + + for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) { + heapUsage[i] = in_struct->heapUsage[i]; + } +} + +void safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::initialize(const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) { + heapBudget[i] = copy_src->heapBudget[i]; + } + + for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) { + heapUsage[i] = copy_src->heapUsage[i]; + } +} + +safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT( + const VkPhysicalDeviceMemoryPriorityFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), memoryPriority(in_struct->memoryPriority) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT), pNext(nullptr), memoryPriority() {} + +safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT( + const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& copy_src) { + sType = copy_src.sType; + memoryPriority = copy_src.memoryPriority; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::operator=( + const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memoryPriority = copy_src.memoryPriority; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::~safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::initialize(const VkPhysicalDeviceMemoryPriorityFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memoryPriority = in_struct->memoryPriority; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::initialize(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memoryPriority = copy_src->memoryPriority; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMemoryPriorityAllocateInfoEXT::safe_VkMemoryPriorityAllocateInfoEXT(const VkMemoryPriorityAllocateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), priority(in_struct->priority) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMemoryPriorityAllocateInfoEXT::safe_VkMemoryPriorityAllocateInfoEXT() + : sType(VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT), pNext(nullptr), priority() {} + +safe_VkMemoryPriorityAllocateInfoEXT::safe_VkMemoryPriorityAllocateInfoEXT(const safe_VkMemoryPriorityAllocateInfoEXT& copy_src) { + sType = copy_src.sType; + priority = copy_src.priority; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryPriorityAllocateInfoEXT& safe_VkMemoryPriorityAllocateInfoEXT::operator=( + const safe_VkMemoryPriorityAllocateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + priority = copy_src.priority; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryPriorityAllocateInfoEXT::~safe_VkMemoryPriorityAllocateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkMemoryPriorityAllocateInfoEXT::initialize(const VkMemoryPriorityAllocateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + priority = in_struct->priority; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryPriorityAllocateInfoEXT::initialize(const safe_VkMemoryPriorityAllocateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + priority = copy_src->priority; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT( + const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + bufferDeviceAddress(in_struct->bufferDeviceAddress), + bufferDeviceAddressCaptureReplay(in_struct->bufferDeviceAddressCaptureReplay), + bufferDeviceAddressMultiDevice(in_struct->bufferDeviceAddressMultiDevice) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT), + pNext(nullptr), + bufferDeviceAddress(), + bufferDeviceAddressCaptureReplay(), + bufferDeviceAddressMultiDevice() {} + +safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT( + const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& copy_src) { + sType = copy_src.sType; + bufferDeviceAddress = copy_src.bufferDeviceAddress; + bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay; + bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::operator=( + const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + bufferDeviceAddress = copy_src.bufferDeviceAddress; + bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay; + bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::~safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::initialize( + const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + bufferDeviceAddress = in_struct->bufferDeviceAddress; + bufferDeviceAddressCaptureReplay = in_struct->bufferDeviceAddressCaptureReplay; + bufferDeviceAddressMultiDevice = in_struct->bufferDeviceAddressMultiDevice; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::initialize( + const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + bufferDeviceAddress = copy_src->bufferDeviceAddress; + bufferDeviceAddressCaptureReplay = copy_src->bufferDeviceAddressCaptureReplay; + bufferDeviceAddressMultiDevice = copy_src->bufferDeviceAddressMultiDevice; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBufferDeviceAddressCreateInfoEXT::safe_VkBufferDeviceAddressCreateInfoEXT( + const VkBufferDeviceAddressCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), deviceAddress(in_struct->deviceAddress) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBufferDeviceAddressCreateInfoEXT::safe_VkBufferDeviceAddressCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT), pNext(nullptr), deviceAddress() {} + +safe_VkBufferDeviceAddressCreateInfoEXT::safe_VkBufferDeviceAddressCreateInfoEXT( + const safe_VkBufferDeviceAddressCreateInfoEXT& copy_src) { + sType = copy_src.sType; + deviceAddress = copy_src.deviceAddress; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBufferDeviceAddressCreateInfoEXT& safe_VkBufferDeviceAddressCreateInfoEXT::operator=( + const safe_VkBufferDeviceAddressCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + deviceAddress = copy_src.deviceAddress; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBufferDeviceAddressCreateInfoEXT::~safe_VkBufferDeviceAddressCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkBufferDeviceAddressCreateInfoEXT::initialize(const VkBufferDeviceAddressCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + deviceAddress = in_struct->deviceAddress; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBufferDeviceAddressCreateInfoEXT::initialize(const safe_VkBufferDeviceAddressCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + deviceAddress = copy_src->deviceAddress; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkValidationFeaturesEXT::safe_VkValidationFeaturesEXT(const VkValidationFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + enabledValidationFeatureCount(in_struct->enabledValidationFeatureCount), + pEnabledValidationFeatures(nullptr), + disabledValidationFeatureCount(in_struct->disabledValidationFeatureCount), + pDisabledValidationFeatures(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pEnabledValidationFeatures) { + pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[in_struct->enabledValidationFeatureCount]; + memcpy((void*)pEnabledValidationFeatures, (void*)in_struct->pEnabledValidationFeatures, + sizeof(VkValidationFeatureEnableEXT) * in_struct->enabledValidationFeatureCount); + } + + if (in_struct->pDisabledValidationFeatures) { + pDisabledValidationFeatures = new VkValidationFeatureDisableEXT[in_struct->disabledValidationFeatureCount]; + memcpy((void*)pDisabledValidationFeatures, (void*)in_struct->pDisabledValidationFeatures, + sizeof(VkValidationFeatureDisableEXT) * in_struct->disabledValidationFeatureCount); + } +} + +safe_VkValidationFeaturesEXT::safe_VkValidationFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT), + pNext(nullptr), + enabledValidationFeatureCount(), + pEnabledValidationFeatures(nullptr), + disabledValidationFeatureCount(), + pDisabledValidationFeatures(nullptr) {} + +safe_VkValidationFeaturesEXT::safe_VkValidationFeaturesEXT(const safe_VkValidationFeaturesEXT& copy_src) { + sType = copy_src.sType; + enabledValidationFeatureCount = copy_src.enabledValidationFeatureCount; + pEnabledValidationFeatures = nullptr; + disabledValidationFeatureCount = copy_src.disabledValidationFeatureCount; + pDisabledValidationFeatures = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pEnabledValidationFeatures) { + pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[copy_src.enabledValidationFeatureCount]; + memcpy((void*)pEnabledValidationFeatures, (void*)copy_src.pEnabledValidationFeatures, + sizeof(VkValidationFeatureEnableEXT) * copy_src.enabledValidationFeatureCount); + } + + if (copy_src.pDisabledValidationFeatures) { + pDisabledValidationFeatures = new VkValidationFeatureDisableEXT[copy_src.disabledValidationFeatureCount]; + memcpy((void*)pDisabledValidationFeatures, (void*)copy_src.pDisabledValidationFeatures, + sizeof(VkValidationFeatureDisableEXT) * copy_src.disabledValidationFeatureCount); + } +} + +safe_VkValidationFeaturesEXT& safe_VkValidationFeaturesEXT::operator=(const safe_VkValidationFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + if (pEnabledValidationFeatures) delete[] pEnabledValidationFeatures; + if (pDisabledValidationFeatures) delete[] pDisabledValidationFeatures; + FreePnextChain(pNext); + + sType = copy_src.sType; + enabledValidationFeatureCount = copy_src.enabledValidationFeatureCount; + pEnabledValidationFeatures = nullptr; + disabledValidationFeatureCount = copy_src.disabledValidationFeatureCount; + pDisabledValidationFeatures = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pEnabledValidationFeatures) { + pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[copy_src.enabledValidationFeatureCount]; + memcpy((void*)pEnabledValidationFeatures, (void*)copy_src.pEnabledValidationFeatures, + sizeof(VkValidationFeatureEnableEXT) * copy_src.enabledValidationFeatureCount); + } + + if (copy_src.pDisabledValidationFeatures) { + pDisabledValidationFeatures = new VkValidationFeatureDisableEXT[copy_src.disabledValidationFeatureCount]; + memcpy((void*)pDisabledValidationFeatures, (void*)copy_src.pDisabledValidationFeatures, + sizeof(VkValidationFeatureDisableEXT) * copy_src.disabledValidationFeatureCount); + } + + return *this; +} + +safe_VkValidationFeaturesEXT::~safe_VkValidationFeaturesEXT() { + if (pEnabledValidationFeatures) delete[] pEnabledValidationFeatures; + if (pDisabledValidationFeatures) delete[] pDisabledValidationFeatures; + FreePnextChain(pNext); +} + +void safe_VkValidationFeaturesEXT::initialize(const VkValidationFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pEnabledValidationFeatures) delete[] pEnabledValidationFeatures; + if (pDisabledValidationFeatures) delete[] pDisabledValidationFeatures; + FreePnextChain(pNext); + sType = in_struct->sType; + enabledValidationFeatureCount = in_struct->enabledValidationFeatureCount; + pEnabledValidationFeatures = nullptr; + disabledValidationFeatureCount = in_struct->disabledValidationFeatureCount; + pDisabledValidationFeatures = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pEnabledValidationFeatures) { + pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[in_struct->enabledValidationFeatureCount]; + memcpy((void*)pEnabledValidationFeatures, (void*)in_struct->pEnabledValidationFeatures, + sizeof(VkValidationFeatureEnableEXT) * in_struct->enabledValidationFeatureCount); + } + + if (in_struct->pDisabledValidationFeatures) { + pDisabledValidationFeatures = new VkValidationFeatureDisableEXT[in_struct->disabledValidationFeatureCount]; + memcpy((void*)pDisabledValidationFeatures, (void*)in_struct->pDisabledValidationFeatures, + sizeof(VkValidationFeatureDisableEXT) * in_struct->disabledValidationFeatureCount); + } +} + +void safe_VkValidationFeaturesEXT::initialize(const safe_VkValidationFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + enabledValidationFeatureCount = copy_src->enabledValidationFeatureCount; + pEnabledValidationFeatures = nullptr; + disabledValidationFeatureCount = copy_src->disabledValidationFeatureCount; + pDisabledValidationFeatures = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pEnabledValidationFeatures) { + pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[copy_src->enabledValidationFeatureCount]; + memcpy((void*)pEnabledValidationFeatures, (void*)copy_src->pEnabledValidationFeatures, + sizeof(VkValidationFeatureEnableEXT) * copy_src->enabledValidationFeatureCount); + } + + if (copy_src->pDisabledValidationFeatures) { + pDisabledValidationFeatures = new VkValidationFeatureDisableEXT[copy_src->disabledValidationFeatureCount]; + memcpy((void*)pDisabledValidationFeatures, (void*)copy_src->pDisabledValidationFeatures, + sizeof(VkValidationFeatureDisableEXT) * copy_src->disabledValidationFeatureCount); + } +} + +safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT( + const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + fragmentShaderSampleInterlock(in_struct->fragmentShaderSampleInterlock), + fragmentShaderPixelInterlock(in_struct->fragmentShaderPixelInterlock), + fragmentShaderShadingRateInterlock(in_struct->fragmentShaderShadingRateInterlock) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT), + pNext(nullptr), + fragmentShaderSampleInterlock(), + fragmentShaderPixelInterlock(), + fragmentShaderShadingRateInterlock() {} + +safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT( + const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& copy_src) { + sType = copy_src.sType; + fragmentShaderSampleInterlock = copy_src.fragmentShaderSampleInterlock; + fragmentShaderPixelInterlock = copy_src.fragmentShaderPixelInterlock; + fragmentShaderShadingRateInterlock = copy_src.fragmentShaderShadingRateInterlock; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::operator=( + const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + fragmentShaderSampleInterlock = copy_src.fragmentShaderSampleInterlock; + fragmentShaderPixelInterlock = copy_src.fragmentShaderPixelInterlock; + fragmentShaderShadingRateInterlock = copy_src.fragmentShaderShadingRateInterlock; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::~safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::initialize( + const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + fragmentShaderSampleInterlock = in_struct->fragmentShaderSampleInterlock; + fragmentShaderPixelInterlock = in_struct->fragmentShaderPixelInterlock; + fragmentShaderShadingRateInterlock = in_struct->fragmentShaderShadingRateInterlock; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::initialize( + const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + fragmentShaderSampleInterlock = copy_src->fragmentShaderSampleInterlock; + fragmentShaderPixelInterlock = copy_src->fragmentShaderPixelInterlock; + fragmentShaderShadingRateInterlock = copy_src->fragmentShaderShadingRateInterlock; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT( + const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), ycbcrImageArrays(in_struct->ycbcrImageArrays) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT), pNext(nullptr), ycbcrImageArrays() {} + +safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT( + const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& copy_src) { + sType = copy_src.sType; + ycbcrImageArrays = copy_src.ycbcrImageArrays; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::operator=( + const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + ycbcrImageArrays = copy_src.ycbcrImageArrays; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::~safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::initialize(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + ycbcrImageArrays = in_struct->ycbcrImageArrays; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::initialize(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + ycbcrImageArrays = copy_src->ycbcrImageArrays; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::safe_VkPhysicalDeviceProvokingVertexFeaturesEXT( + const VkPhysicalDeviceProvokingVertexFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + provokingVertexLast(in_struct->provokingVertexLast), + transformFeedbackPreservesProvokingVertex(in_struct->transformFeedbackPreservesProvokingVertex) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::safe_VkPhysicalDeviceProvokingVertexFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT), + pNext(nullptr), + provokingVertexLast(), + transformFeedbackPreservesProvokingVertex() {} + +safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::safe_VkPhysicalDeviceProvokingVertexFeaturesEXT( + const safe_VkPhysicalDeviceProvokingVertexFeaturesEXT& copy_src) { + sType = copy_src.sType; + provokingVertexLast = copy_src.provokingVertexLast; + transformFeedbackPreservesProvokingVertex = copy_src.transformFeedbackPreservesProvokingVertex; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceProvokingVertexFeaturesEXT& safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::operator=( + const safe_VkPhysicalDeviceProvokingVertexFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + provokingVertexLast = copy_src.provokingVertexLast; + transformFeedbackPreservesProvokingVertex = copy_src.transformFeedbackPreservesProvokingVertex; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::~safe_VkPhysicalDeviceProvokingVertexFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::initialize(const VkPhysicalDeviceProvokingVertexFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + provokingVertexLast = in_struct->provokingVertexLast; + transformFeedbackPreservesProvokingVertex = in_struct->transformFeedbackPreservesProvokingVertex; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::initialize(const safe_VkPhysicalDeviceProvokingVertexFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + provokingVertexLast = copy_src->provokingVertexLast; + transformFeedbackPreservesProvokingVertex = copy_src->transformFeedbackPreservesProvokingVertex; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::safe_VkPhysicalDeviceProvokingVertexPropertiesEXT( + const VkPhysicalDeviceProvokingVertexPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + provokingVertexModePerPipeline(in_struct->provokingVertexModePerPipeline), + transformFeedbackPreservesTriangleFanProvokingVertex(in_struct->transformFeedbackPreservesTriangleFanProvokingVertex) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::safe_VkPhysicalDeviceProvokingVertexPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT), + pNext(nullptr), + provokingVertexModePerPipeline(), + transformFeedbackPreservesTriangleFanProvokingVertex() {} + +safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::safe_VkPhysicalDeviceProvokingVertexPropertiesEXT( + const safe_VkPhysicalDeviceProvokingVertexPropertiesEXT& copy_src) { + sType = copy_src.sType; + provokingVertexModePerPipeline = copy_src.provokingVertexModePerPipeline; + transformFeedbackPreservesTriangleFanProvokingVertex = copy_src.transformFeedbackPreservesTriangleFanProvokingVertex; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceProvokingVertexPropertiesEXT& safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::operator=( + const safe_VkPhysicalDeviceProvokingVertexPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + provokingVertexModePerPipeline = copy_src.provokingVertexModePerPipeline; + transformFeedbackPreservesTriangleFanProvokingVertex = copy_src.transformFeedbackPreservesTriangleFanProvokingVertex; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::~safe_VkPhysicalDeviceProvokingVertexPropertiesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::initialize(const VkPhysicalDeviceProvokingVertexPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + provokingVertexModePerPipeline = in_struct->provokingVertexModePerPipeline; + transformFeedbackPreservesTriangleFanProvokingVertex = in_struct->transformFeedbackPreservesTriangleFanProvokingVertex; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::initialize( + const safe_VkPhysicalDeviceProvokingVertexPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + provokingVertexModePerPipeline = copy_src->provokingVertexModePerPipeline; + transformFeedbackPreservesTriangleFanProvokingVertex = copy_src->transformFeedbackPreservesTriangleFanProvokingVertex; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT( + const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), provokingVertexMode(in_struct->provokingVertexMode) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT), + pNext(nullptr), + provokingVertexMode() {} + +safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT( + const safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& copy_src) { + sType = copy_src.sType; + provokingVertexMode = copy_src.provokingVertexMode; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& +safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::operator=( + const safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + provokingVertexMode = copy_src.provokingVertexMode; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::~safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT() { + FreePnextChain(pNext); +} + +void safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::initialize( + const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + provokingVertexMode = in_struct->provokingVertexMode; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::initialize( + const safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + provokingVertexMode = copy_src->provokingVertexMode; + pNext = SafePnextCopy(copy_src->pNext); +} +#ifdef VK_USE_PLATFORM_WIN32_KHR + +safe_VkSurfaceFullScreenExclusiveInfoEXT::safe_VkSurfaceFullScreenExclusiveInfoEXT( + const VkSurfaceFullScreenExclusiveInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), fullScreenExclusive(in_struct->fullScreenExclusive) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSurfaceFullScreenExclusiveInfoEXT::safe_VkSurfaceFullScreenExclusiveInfoEXT() + : sType(VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT), pNext(nullptr), fullScreenExclusive() {} + +safe_VkSurfaceFullScreenExclusiveInfoEXT::safe_VkSurfaceFullScreenExclusiveInfoEXT( + const safe_VkSurfaceFullScreenExclusiveInfoEXT& copy_src) { + sType = copy_src.sType; + fullScreenExclusive = copy_src.fullScreenExclusive; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSurfaceFullScreenExclusiveInfoEXT& safe_VkSurfaceFullScreenExclusiveInfoEXT::operator=( + const safe_VkSurfaceFullScreenExclusiveInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + fullScreenExclusive = copy_src.fullScreenExclusive; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSurfaceFullScreenExclusiveInfoEXT::~safe_VkSurfaceFullScreenExclusiveInfoEXT() { FreePnextChain(pNext); } + +void safe_VkSurfaceFullScreenExclusiveInfoEXT::initialize(const VkSurfaceFullScreenExclusiveInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + fullScreenExclusive = in_struct->fullScreenExclusive; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSurfaceFullScreenExclusiveInfoEXT::initialize(const safe_VkSurfaceFullScreenExclusiveInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + fullScreenExclusive = copy_src->fullScreenExclusive; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT( + const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), fullScreenExclusiveSupported(in_struct->fullScreenExclusiveSupported) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT() + : sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT), pNext(nullptr), fullScreenExclusiveSupported() {} + +safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT( + const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& copy_src) { + sType = copy_src.sType; + fullScreenExclusiveSupported = copy_src.fullScreenExclusiveSupported; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::operator=( + const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + fullScreenExclusiveSupported = copy_src.fullScreenExclusiveSupported; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::~safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT() { FreePnextChain(pNext); } + +void safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::initialize(const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + fullScreenExclusiveSupported = in_struct->fullScreenExclusiveSupported; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::initialize(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + fullScreenExclusiveSupported = copy_src->fullScreenExclusiveSupported; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::safe_VkSurfaceFullScreenExclusiveWin32InfoEXT( + const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), hmonitor(in_struct->hmonitor) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::safe_VkSurfaceFullScreenExclusiveWin32InfoEXT() + : sType(VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT), pNext(nullptr), hmonitor() {} + +safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::safe_VkSurfaceFullScreenExclusiveWin32InfoEXT( + const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& copy_src) { + sType = copy_src.sType; + hmonitor = copy_src.hmonitor; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::operator=( + const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + hmonitor = copy_src.hmonitor; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::~safe_VkSurfaceFullScreenExclusiveWin32InfoEXT() { FreePnextChain(pNext); } + +void safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::initialize(const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + hmonitor = in_struct->hmonitor; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::initialize(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + hmonitor = copy_src->hmonitor; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_WIN32_KHR + +safe_VkHeadlessSurfaceCreateInfoEXT::safe_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkHeadlessSurfaceCreateInfoEXT::safe_VkHeadlessSurfaceCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT), pNext(nullptr), flags() {} + +safe_VkHeadlessSurfaceCreateInfoEXT::safe_VkHeadlessSurfaceCreateInfoEXT(const safe_VkHeadlessSurfaceCreateInfoEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkHeadlessSurfaceCreateInfoEXT& safe_VkHeadlessSurfaceCreateInfoEXT::operator=( + const safe_VkHeadlessSurfaceCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkHeadlessSurfaceCreateInfoEXT::~safe_VkHeadlessSurfaceCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkHeadlessSurfaceCreateInfoEXT::initialize(const VkHeadlessSurfaceCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkHeadlessSurfaceCreateInfoEXT::initialize(const safe_VkHeadlessSurfaceCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT( + const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shaderBufferFloat32Atomics(in_struct->shaderBufferFloat32Atomics), + shaderBufferFloat32AtomicAdd(in_struct->shaderBufferFloat32AtomicAdd), + shaderBufferFloat64Atomics(in_struct->shaderBufferFloat64Atomics), + shaderBufferFloat64AtomicAdd(in_struct->shaderBufferFloat64AtomicAdd), + shaderSharedFloat32Atomics(in_struct->shaderSharedFloat32Atomics), + shaderSharedFloat32AtomicAdd(in_struct->shaderSharedFloat32AtomicAdd), + shaderSharedFloat64Atomics(in_struct->shaderSharedFloat64Atomics), + shaderSharedFloat64AtomicAdd(in_struct->shaderSharedFloat64AtomicAdd), + shaderImageFloat32Atomics(in_struct->shaderImageFloat32Atomics), + shaderImageFloat32AtomicAdd(in_struct->shaderImageFloat32AtomicAdd), + sparseImageFloat32Atomics(in_struct->sparseImageFloat32Atomics), + sparseImageFloat32AtomicAdd(in_struct->sparseImageFloat32AtomicAdd) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT), + pNext(nullptr), + shaderBufferFloat32Atomics(), + shaderBufferFloat32AtomicAdd(), + shaderBufferFloat64Atomics(), + shaderBufferFloat64AtomicAdd(), + shaderSharedFloat32Atomics(), + shaderSharedFloat32AtomicAdd(), + shaderSharedFloat64Atomics(), + shaderSharedFloat64AtomicAdd(), + shaderImageFloat32Atomics(), + shaderImageFloat32AtomicAdd(), + sparseImageFloat32Atomics(), + sparseImageFloat32AtomicAdd() {} + +safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT( + const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& copy_src) { + sType = copy_src.sType; + shaderBufferFloat32Atomics = copy_src.shaderBufferFloat32Atomics; + shaderBufferFloat32AtomicAdd = copy_src.shaderBufferFloat32AtomicAdd; + shaderBufferFloat64Atomics = copy_src.shaderBufferFloat64Atomics; + shaderBufferFloat64AtomicAdd = copy_src.shaderBufferFloat64AtomicAdd; + shaderSharedFloat32Atomics = copy_src.shaderSharedFloat32Atomics; + shaderSharedFloat32AtomicAdd = copy_src.shaderSharedFloat32AtomicAdd; + shaderSharedFloat64Atomics = copy_src.shaderSharedFloat64Atomics; + shaderSharedFloat64AtomicAdd = copy_src.shaderSharedFloat64AtomicAdd; + shaderImageFloat32Atomics = copy_src.shaderImageFloat32Atomics; + shaderImageFloat32AtomicAdd = copy_src.shaderImageFloat32AtomicAdd; + sparseImageFloat32Atomics = copy_src.sparseImageFloat32Atomics; + sparseImageFloat32AtomicAdd = copy_src.sparseImageFloat32AtomicAdd; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::operator=( + const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderBufferFloat32Atomics = copy_src.shaderBufferFloat32Atomics; + shaderBufferFloat32AtomicAdd = copy_src.shaderBufferFloat32AtomicAdd; + shaderBufferFloat64Atomics = copy_src.shaderBufferFloat64Atomics; + shaderBufferFloat64AtomicAdd = copy_src.shaderBufferFloat64AtomicAdd; + shaderSharedFloat32Atomics = copy_src.shaderSharedFloat32Atomics; + shaderSharedFloat32AtomicAdd = copy_src.shaderSharedFloat32AtomicAdd; + shaderSharedFloat64Atomics = copy_src.shaderSharedFloat64Atomics; + shaderSharedFloat64AtomicAdd = copy_src.shaderSharedFloat64AtomicAdd; + shaderImageFloat32Atomics = copy_src.shaderImageFloat32Atomics; + shaderImageFloat32AtomicAdd = copy_src.shaderImageFloat32AtomicAdd; + sparseImageFloat32Atomics = copy_src.sparseImageFloat32Atomics; + sparseImageFloat32AtomicAdd = copy_src.sparseImageFloat32AtomicAdd; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::~safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::initialize(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderBufferFloat32Atomics = in_struct->shaderBufferFloat32Atomics; + shaderBufferFloat32AtomicAdd = in_struct->shaderBufferFloat32AtomicAdd; + shaderBufferFloat64Atomics = in_struct->shaderBufferFloat64Atomics; + shaderBufferFloat64AtomicAdd = in_struct->shaderBufferFloat64AtomicAdd; + shaderSharedFloat32Atomics = in_struct->shaderSharedFloat32Atomics; + shaderSharedFloat32AtomicAdd = in_struct->shaderSharedFloat32AtomicAdd; + shaderSharedFloat64Atomics = in_struct->shaderSharedFloat64Atomics; + shaderSharedFloat64AtomicAdd = in_struct->shaderSharedFloat64AtomicAdd; + shaderImageFloat32Atomics = in_struct->shaderImageFloat32Atomics; + shaderImageFloat32AtomicAdd = in_struct->shaderImageFloat32AtomicAdd; + sparseImageFloat32Atomics = in_struct->sparseImageFloat32Atomics; + sparseImageFloat32AtomicAdd = in_struct->sparseImageFloat32AtomicAdd; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::initialize( + const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderBufferFloat32Atomics = copy_src->shaderBufferFloat32Atomics; + shaderBufferFloat32AtomicAdd = copy_src->shaderBufferFloat32AtomicAdd; + shaderBufferFloat64Atomics = copy_src->shaderBufferFloat64Atomics; + shaderBufferFloat64AtomicAdd = copy_src->shaderBufferFloat64AtomicAdd; + shaderSharedFloat32Atomics = copy_src->shaderSharedFloat32Atomics; + shaderSharedFloat32AtomicAdd = copy_src->shaderSharedFloat32AtomicAdd; + shaderSharedFloat64Atomics = copy_src->shaderSharedFloat64Atomics; + shaderSharedFloat64AtomicAdd = copy_src->shaderSharedFloat64AtomicAdd; + shaderImageFloat32Atomics = copy_src->shaderImageFloat32Atomics; + shaderImageFloat32AtomicAdd = copy_src->shaderImageFloat32AtomicAdd; + sparseImageFloat32Atomics = copy_src->sparseImageFloat32Atomics; + sparseImageFloat32AtomicAdd = copy_src->sparseImageFloat32AtomicAdd; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT( + const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), extendedDynamicState(in_struct->extendedDynamicState) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT), pNext(nullptr), extendedDynamicState() {} + +safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT( + const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& copy_src) { + sType = copy_src.sType; + extendedDynamicState = copy_src.extendedDynamicState; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::operator=( + const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + extendedDynamicState = copy_src.extendedDynamicState; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::~safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::initialize( + const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + extendedDynamicState = in_struct->extendedDynamicState; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::initialize( + const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + extendedDynamicState = copy_src->extendedDynamicState; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::safe_VkPhysicalDeviceHostImageCopyFeaturesEXT( + const VkPhysicalDeviceHostImageCopyFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), hostImageCopy(in_struct->hostImageCopy) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::safe_VkPhysicalDeviceHostImageCopyFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT), pNext(nullptr), hostImageCopy() {} + +safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::safe_VkPhysicalDeviceHostImageCopyFeaturesEXT( + const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& copy_src) { + sType = copy_src.sType; + hostImageCopy = copy_src.hostImageCopy; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::operator=( + const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + hostImageCopy = copy_src.hostImageCopy; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::~safe_VkPhysicalDeviceHostImageCopyFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::initialize(const VkPhysicalDeviceHostImageCopyFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + hostImageCopy = in_struct->hostImageCopy; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::initialize(const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + hostImageCopy = copy_src->hostImageCopy; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::safe_VkPhysicalDeviceHostImageCopyPropertiesEXT( + const VkPhysicalDeviceHostImageCopyPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + copySrcLayoutCount(in_struct->copySrcLayoutCount), + pCopySrcLayouts(nullptr), + copyDstLayoutCount(in_struct->copyDstLayoutCount), + pCopyDstLayouts(nullptr), + identicalMemoryTypeRequirements(in_struct->identicalMemoryTypeRequirements) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pCopySrcLayouts) { + pCopySrcLayouts = new VkImageLayout[in_struct->copySrcLayoutCount]; + memcpy((void*)pCopySrcLayouts, (void*)in_struct->pCopySrcLayouts, sizeof(VkImageLayout) * in_struct->copySrcLayoutCount); + } + + if (in_struct->pCopyDstLayouts) { + pCopyDstLayouts = new VkImageLayout[in_struct->copyDstLayoutCount]; + memcpy((void*)pCopyDstLayouts, (void*)in_struct->pCopyDstLayouts, sizeof(VkImageLayout) * in_struct->copyDstLayoutCount); + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + optimalTilingLayoutUUID[i] = in_struct->optimalTilingLayoutUUID[i]; + } +} + +safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::safe_VkPhysicalDeviceHostImageCopyPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT), + pNext(nullptr), + copySrcLayoutCount(), + pCopySrcLayouts(nullptr), + copyDstLayoutCount(), + pCopyDstLayouts(nullptr), + identicalMemoryTypeRequirements() {} + +safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::safe_VkPhysicalDeviceHostImageCopyPropertiesEXT( + const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& copy_src) { + sType = copy_src.sType; + copySrcLayoutCount = copy_src.copySrcLayoutCount; + pCopySrcLayouts = nullptr; + copyDstLayoutCount = copy_src.copyDstLayoutCount; + pCopyDstLayouts = nullptr; + identicalMemoryTypeRequirements = copy_src.identicalMemoryTypeRequirements; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pCopySrcLayouts) { + pCopySrcLayouts = new VkImageLayout[copy_src.copySrcLayoutCount]; + memcpy((void*)pCopySrcLayouts, (void*)copy_src.pCopySrcLayouts, sizeof(VkImageLayout) * copy_src.copySrcLayoutCount); + } + + if (copy_src.pCopyDstLayouts) { + pCopyDstLayouts = new VkImageLayout[copy_src.copyDstLayoutCount]; + memcpy((void*)pCopyDstLayouts, (void*)copy_src.pCopyDstLayouts, sizeof(VkImageLayout) * copy_src.copyDstLayoutCount); + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + optimalTilingLayoutUUID[i] = copy_src.optimalTilingLayoutUUID[i]; + } +} + +safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::operator=( + const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + if (pCopySrcLayouts) delete[] pCopySrcLayouts; + if (pCopyDstLayouts) delete[] pCopyDstLayouts; + FreePnextChain(pNext); + + sType = copy_src.sType; + copySrcLayoutCount = copy_src.copySrcLayoutCount; + pCopySrcLayouts = nullptr; + copyDstLayoutCount = copy_src.copyDstLayoutCount; + pCopyDstLayouts = nullptr; + identicalMemoryTypeRequirements = copy_src.identicalMemoryTypeRequirements; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pCopySrcLayouts) { + pCopySrcLayouts = new VkImageLayout[copy_src.copySrcLayoutCount]; + memcpy((void*)pCopySrcLayouts, (void*)copy_src.pCopySrcLayouts, sizeof(VkImageLayout) * copy_src.copySrcLayoutCount); + } + + if (copy_src.pCopyDstLayouts) { + pCopyDstLayouts = new VkImageLayout[copy_src.copyDstLayoutCount]; + memcpy((void*)pCopyDstLayouts, (void*)copy_src.pCopyDstLayouts, sizeof(VkImageLayout) * copy_src.copyDstLayoutCount); + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + optimalTilingLayoutUUID[i] = copy_src.optimalTilingLayoutUUID[i]; + } + + return *this; +} + +safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::~safe_VkPhysicalDeviceHostImageCopyPropertiesEXT() { + if (pCopySrcLayouts) delete[] pCopySrcLayouts; + if (pCopyDstLayouts) delete[] pCopyDstLayouts; + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::initialize(const VkPhysicalDeviceHostImageCopyPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pCopySrcLayouts) delete[] pCopySrcLayouts; + if (pCopyDstLayouts) delete[] pCopyDstLayouts; + FreePnextChain(pNext); + sType = in_struct->sType; + copySrcLayoutCount = in_struct->copySrcLayoutCount; + pCopySrcLayouts = nullptr; + copyDstLayoutCount = in_struct->copyDstLayoutCount; + pCopyDstLayouts = nullptr; + identicalMemoryTypeRequirements = in_struct->identicalMemoryTypeRequirements; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pCopySrcLayouts) { + pCopySrcLayouts = new VkImageLayout[in_struct->copySrcLayoutCount]; + memcpy((void*)pCopySrcLayouts, (void*)in_struct->pCopySrcLayouts, sizeof(VkImageLayout) * in_struct->copySrcLayoutCount); + } + + if (in_struct->pCopyDstLayouts) { + pCopyDstLayouts = new VkImageLayout[in_struct->copyDstLayoutCount]; + memcpy((void*)pCopyDstLayouts, (void*)in_struct->pCopyDstLayouts, sizeof(VkImageLayout) * in_struct->copyDstLayoutCount); + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + optimalTilingLayoutUUID[i] = in_struct->optimalTilingLayoutUUID[i]; + } +} + +void safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::initialize(const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + copySrcLayoutCount = copy_src->copySrcLayoutCount; + pCopySrcLayouts = nullptr; + copyDstLayoutCount = copy_src->copyDstLayoutCount; + pCopyDstLayouts = nullptr; + identicalMemoryTypeRequirements = copy_src->identicalMemoryTypeRequirements; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pCopySrcLayouts) { + pCopySrcLayouts = new VkImageLayout[copy_src->copySrcLayoutCount]; + memcpy((void*)pCopySrcLayouts, (void*)copy_src->pCopySrcLayouts, sizeof(VkImageLayout) * copy_src->copySrcLayoutCount); + } + + if (copy_src->pCopyDstLayouts) { + pCopyDstLayouts = new VkImageLayout[copy_src->copyDstLayoutCount]; + memcpy((void*)pCopyDstLayouts, (void*)copy_src->pCopyDstLayouts, sizeof(VkImageLayout) * copy_src->copyDstLayoutCount); + } + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + optimalTilingLayoutUUID[i] = copy_src->optimalTilingLayoutUUID[i]; + } +} + +safe_VkMemoryToImageCopyEXT::safe_VkMemoryToImageCopyEXT(const VkMemoryToImageCopyEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + pHostPointer(in_struct->pHostPointer), + memoryRowLength(in_struct->memoryRowLength), + memoryImageHeight(in_struct->memoryImageHeight), + imageSubresource(in_struct->imageSubresource), + imageOffset(in_struct->imageOffset), + imageExtent(in_struct->imageExtent) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMemoryToImageCopyEXT::safe_VkMemoryToImageCopyEXT() + : sType(VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT), + pNext(nullptr), + pHostPointer(nullptr), + memoryRowLength(), + memoryImageHeight(), + imageSubresource(), + imageOffset(), + imageExtent() {} + +safe_VkMemoryToImageCopyEXT::safe_VkMemoryToImageCopyEXT(const safe_VkMemoryToImageCopyEXT& copy_src) { + sType = copy_src.sType; + pHostPointer = copy_src.pHostPointer; + memoryRowLength = copy_src.memoryRowLength; + memoryImageHeight = copy_src.memoryImageHeight; + imageSubresource = copy_src.imageSubresource; + imageOffset = copy_src.imageOffset; + imageExtent = copy_src.imageExtent; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryToImageCopyEXT& safe_VkMemoryToImageCopyEXT::operator=(const safe_VkMemoryToImageCopyEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pHostPointer = copy_src.pHostPointer; + memoryRowLength = copy_src.memoryRowLength; + memoryImageHeight = copy_src.memoryImageHeight; + imageSubresource = copy_src.imageSubresource; + imageOffset = copy_src.imageOffset; + imageExtent = copy_src.imageExtent; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryToImageCopyEXT::~safe_VkMemoryToImageCopyEXT() { FreePnextChain(pNext); } + +void safe_VkMemoryToImageCopyEXT::initialize(const VkMemoryToImageCopyEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pHostPointer = in_struct->pHostPointer; + memoryRowLength = in_struct->memoryRowLength; + memoryImageHeight = in_struct->memoryImageHeight; + imageSubresource = in_struct->imageSubresource; + imageOffset = in_struct->imageOffset; + imageExtent = in_struct->imageExtent; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryToImageCopyEXT::initialize(const safe_VkMemoryToImageCopyEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pHostPointer = copy_src->pHostPointer; + memoryRowLength = copy_src->memoryRowLength; + memoryImageHeight = copy_src->memoryImageHeight; + imageSubresource = copy_src->imageSubresource; + imageOffset = copy_src->imageOffset; + imageExtent = copy_src->imageExtent; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImageToMemoryCopyEXT::safe_VkImageToMemoryCopyEXT(const VkImageToMemoryCopyEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + pHostPointer(in_struct->pHostPointer), + memoryRowLength(in_struct->memoryRowLength), + memoryImageHeight(in_struct->memoryImageHeight), + imageSubresource(in_struct->imageSubresource), + imageOffset(in_struct->imageOffset), + imageExtent(in_struct->imageExtent) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageToMemoryCopyEXT::safe_VkImageToMemoryCopyEXT() + : sType(VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT), + pNext(nullptr), + pHostPointer(nullptr), + memoryRowLength(), + memoryImageHeight(), + imageSubresource(), + imageOffset(), + imageExtent() {} + +safe_VkImageToMemoryCopyEXT::safe_VkImageToMemoryCopyEXT(const safe_VkImageToMemoryCopyEXT& copy_src) { + sType = copy_src.sType; + pHostPointer = copy_src.pHostPointer; + memoryRowLength = copy_src.memoryRowLength; + memoryImageHeight = copy_src.memoryImageHeight; + imageSubresource = copy_src.imageSubresource; + imageOffset = copy_src.imageOffset; + imageExtent = copy_src.imageExtent; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageToMemoryCopyEXT& safe_VkImageToMemoryCopyEXT::operator=(const safe_VkImageToMemoryCopyEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pHostPointer = copy_src.pHostPointer; + memoryRowLength = copy_src.memoryRowLength; + memoryImageHeight = copy_src.memoryImageHeight; + imageSubresource = copy_src.imageSubresource; + imageOffset = copy_src.imageOffset; + imageExtent = copy_src.imageExtent; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageToMemoryCopyEXT::~safe_VkImageToMemoryCopyEXT() { FreePnextChain(pNext); } + +void safe_VkImageToMemoryCopyEXT::initialize(const VkImageToMemoryCopyEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pHostPointer = in_struct->pHostPointer; + memoryRowLength = in_struct->memoryRowLength; + memoryImageHeight = in_struct->memoryImageHeight; + imageSubresource = in_struct->imageSubresource; + imageOffset = in_struct->imageOffset; + imageExtent = in_struct->imageExtent; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageToMemoryCopyEXT::initialize(const safe_VkImageToMemoryCopyEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pHostPointer = copy_src->pHostPointer; + memoryRowLength = copy_src->memoryRowLength; + memoryImageHeight = copy_src->memoryImageHeight; + imageSubresource = copy_src->imageSubresource; + imageOffset = copy_src->imageOffset; + imageExtent = copy_src->imageExtent; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCopyMemoryToImageInfoEXT::safe_VkCopyMemoryToImageInfoEXT(const VkCopyMemoryToImageInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + dstImage(in_struct->dstImage), + dstImageLayout(in_struct->dstImageLayout), + regionCount(in_struct->regionCount), + pRegions(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkMemoryToImageCopyEXT[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +safe_VkCopyMemoryToImageInfoEXT::safe_VkCopyMemoryToImageInfoEXT() + : sType(VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT), + pNext(nullptr), + flags(), + dstImage(), + dstImageLayout(), + regionCount(), + pRegions(nullptr) {} + +safe_VkCopyMemoryToImageInfoEXT::safe_VkCopyMemoryToImageInfoEXT(const safe_VkCopyMemoryToImageInfoEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + dstImage = copy_src.dstImage; + dstImageLayout = copy_src.dstImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkMemoryToImageCopyEXT[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } +} + +safe_VkCopyMemoryToImageInfoEXT& safe_VkCopyMemoryToImageInfoEXT::operator=(const safe_VkCopyMemoryToImageInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + dstImage = copy_src.dstImage; + dstImageLayout = copy_src.dstImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkMemoryToImageCopyEXT[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } + + return *this; +} + +safe_VkCopyMemoryToImageInfoEXT::~safe_VkCopyMemoryToImageInfoEXT() { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); +} + +void safe_VkCopyMemoryToImageInfoEXT::initialize(const VkCopyMemoryToImageInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + dstImage = in_struct->dstImage; + dstImageLayout = in_struct->dstImageLayout; + regionCount = in_struct->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkMemoryToImageCopyEXT[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +void safe_VkCopyMemoryToImageInfoEXT::initialize(const safe_VkCopyMemoryToImageInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + dstImage = copy_src->dstImage; + dstImageLayout = copy_src->dstImageLayout; + regionCount = copy_src->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (regionCount && copy_src->pRegions) { + pRegions = new safe_VkMemoryToImageCopyEXT[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src->pRegions[i]); + } + } +} + +safe_VkCopyImageToMemoryInfoEXT::safe_VkCopyImageToMemoryInfoEXT(const VkCopyImageToMemoryInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + srcImage(in_struct->srcImage), + srcImageLayout(in_struct->srcImageLayout), + regionCount(in_struct->regionCount), + pRegions(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkImageToMemoryCopyEXT[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +safe_VkCopyImageToMemoryInfoEXT::safe_VkCopyImageToMemoryInfoEXT() + : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT), + pNext(nullptr), + flags(), + srcImage(), + srcImageLayout(), + regionCount(), + pRegions(nullptr) {} + +safe_VkCopyImageToMemoryInfoEXT::safe_VkCopyImageToMemoryInfoEXT(const safe_VkCopyImageToMemoryInfoEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + srcImage = copy_src.srcImage; + srcImageLayout = copy_src.srcImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkImageToMemoryCopyEXT[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } +} + +safe_VkCopyImageToMemoryInfoEXT& safe_VkCopyImageToMemoryInfoEXT::operator=(const safe_VkCopyImageToMemoryInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + srcImage = copy_src.srcImage; + srcImageLayout = copy_src.srcImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkImageToMemoryCopyEXT[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } + + return *this; +} + +safe_VkCopyImageToMemoryInfoEXT::~safe_VkCopyImageToMemoryInfoEXT() { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); +} + +void safe_VkCopyImageToMemoryInfoEXT::initialize(const VkCopyImageToMemoryInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + srcImage = in_struct->srcImage; + srcImageLayout = in_struct->srcImageLayout; + regionCount = in_struct->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkImageToMemoryCopyEXT[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +void safe_VkCopyImageToMemoryInfoEXT::initialize(const safe_VkCopyImageToMemoryInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + srcImage = copy_src->srcImage; + srcImageLayout = copy_src->srcImageLayout; + regionCount = copy_src->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (regionCount && copy_src->pRegions) { + pRegions = new safe_VkImageToMemoryCopyEXT[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src->pRegions[i]); + } + } +} + +safe_VkCopyImageToImageInfoEXT::safe_VkCopyImageToImageInfoEXT(const VkCopyImageToImageInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + srcImage(in_struct->srcImage), + srcImageLayout(in_struct->srcImageLayout), + dstImage(in_struct->dstImage), + dstImageLayout(in_struct->dstImageLayout), + regionCount(in_struct->regionCount), + pRegions(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +safe_VkCopyImageToImageInfoEXT::safe_VkCopyImageToImageInfoEXT() + : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT), + pNext(nullptr), + flags(), + srcImage(), + srcImageLayout(), + dstImage(), + dstImageLayout(), + regionCount(), + pRegions(nullptr) {} + +safe_VkCopyImageToImageInfoEXT::safe_VkCopyImageToImageInfoEXT(const safe_VkCopyImageToImageInfoEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + srcImage = copy_src.srcImage; + srcImageLayout = copy_src.srcImageLayout; + dstImage = copy_src.dstImage; + dstImageLayout = copy_src.dstImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } +} + +safe_VkCopyImageToImageInfoEXT& safe_VkCopyImageToImageInfoEXT::operator=(const safe_VkCopyImageToImageInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + srcImage = copy_src.srcImage; + srcImageLayout = copy_src.srcImageLayout; + dstImage = copy_src.dstImage; + dstImageLayout = copy_src.dstImageLayout; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (regionCount && copy_src.pRegions) { + pRegions = new safe_VkImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src.pRegions[i]); + } + } + + return *this; +} + +safe_VkCopyImageToImageInfoEXT::~safe_VkCopyImageToImageInfoEXT() { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); +} + +void safe_VkCopyImageToImageInfoEXT::initialize(const VkCopyImageToImageInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + srcImage = in_struct->srcImage; + srcImageLayout = in_struct->srcImageLayout; + dstImage = in_struct->dstImage; + dstImageLayout = in_struct->dstImageLayout; + regionCount = in_struct->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (regionCount && in_struct->pRegions) { + pRegions = new safe_VkImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(&in_struct->pRegions[i]); + } + } +} + +void safe_VkCopyImageToImageInfoEXT::initialize(const safe_VkCopyImageToImageInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + srcImage = copy_src->srcImage; + srcImageLayout = copy_src->srcImageLayout; + dstImage = copy_src->dstImage; + dstImageLayout = copy_src->dstImageLayout; + regionCount = copy_src->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (regionCount && copy_src->pRegions) { + pRegions = new safe_VkImageCopy2[regionCount]; + for (uint32_t i = 0; i < regionCount; ++i) { + pRegions[i].initialize(©_src->pRegions[i]); + } + } +} + +safe_VkHostImageLayoutTransitionInfoEXT::safe_VkHostImageLayoutTransitionInfoEXT( + const VkHostImageLayoutTransitionInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + image(in_struct->image), + oldLayout(in_struct->oldLayout), + newLayout(in_struct->newLayout), + subresourceRange(in_struct->subresourceRange) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkHostImageLayoutTransitionInfoEXT::safe_VkHostImageLayoutTransitionInfoEXT() + : sType(VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT), + pNext(nullptr), + image(), + oldLayout(), + newLayout(), + subresourceRange() {} + +safe_VkHostImageLayoutTransitionInfoEXT::safe_VkHostImageLayoutTransitionInfoEXT( + const safe_VkHostImageLayoutTransitionInfoEXT& copy_src) { + sType = copy_src.sType; + image = copy_src.image; + oldLayout = copy_src.oldLayout; + newLayout = copy_src.newLayout; + subresourceRange = copy_src.subresourceRange; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkHostImageLayoutTransitionInfoEXT& safe_VkHostImageLayoutTransitionInfoEXT::operator=( + const safe_VkHostImageLayoutTransitionInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + image = copy_src.image; + oldLayout = copy_src.oldLayout; + newLayout = copy_src.newLayout; + subresourceRange = copy_src.subresourceRange; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkHostImageLayoutTransitionInfoEXT::~safe_VkHostImageLayoutTransitionInfoEXT() { FreePnextChain(pNext); } + +void safe_VkHostImageLayoutTransitionInfoEXT::initialize(const VkHostImageLayoutTransitionInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + image = in_struct->image; + oldLayout = in_struct->oldLayout; + newLayout = in_struct->newLayout; + subresourceRange = in_struct->subresourceRange; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkHostImageLayoutTransitionInfoEXT::initialize(const safe_VkHostImageLayoutTransitionInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + image = copy_src->image; + oldLayout = copy_src->oldLayout; + newLayout = copy_src->newLayout; + subresourceRange = copy_src->subresourceRange; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSubresourceHostMemcpySizeEXT::safe_VkSubresourceHostMemcpySizeEXT(const VkSubresourceHostMemcpySizeEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), size(in_struct->size) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSubresourceHostMemcpySizeEXT::safe_VkSubresourceHostMemcpySizeEXT() + : sType(VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT), pNext(nullptr), size() {} + +safe_VkSubresourceHostMemcpySizeEXT::safe_VkSubresourceHostMemcpySizeEXT(const safe_VkSubresourceHostMemcpySizeEXT& copy_src) { + sType = copy_src.sType; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSubresourceHostMemcpySizeEXT& safe_VkSubresourceHostMemcpySizeEXT::operator=( + const safe_VkSubresourceHostMemcpySizeEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSubresourceHostMemcpySizeEXT::~safe_VkSubresourceHostMemcpySizeEXT() { FreePnextChain(pNext); } + +void safe_VkSubresourceHostMemcpySizeEXT::initialize(const VkSubresourceHostMemcpySizeEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + size = in_struct->size; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSubresourceHostMemcpySizeEXT::initialize(const safe_VkSubresourceHostMemcpySizeEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + size = copy_src->size; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkHostImageCopyDevicePerformanceQueryEXT::safe_VkHostImageCopyDevicePerformanceQueryEXT( + const VkHostImageCopyDevicePerformanceQueryEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + optimalDeviceAccess(in_struct->optimalDeviceAccess), + identicalMemoryLayout(in_struct->identicalMemoryLayout) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkHostImageCopyDevicePerformanceQueryEXT::safe_VkHostImageCopyDevicePerformanceQueryEXT() + : sType(VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT), + pNext(nullptr), + optimalDeviceAccess(), + identicalMemoryLayout() {} + +safe_VkHostImageCopyDevicePerformanceQueryEXT::safe_VkHostImageCopyDevicePerformanceQueryEXT( + const safe_VkHostImageCopyDevicePerformanceQueryEXT& copy_src) { + sType = copy_src.sType; + optimalDeviceAccess = copy_src.optimalDeviceAccess; + identicalMemoryLayout = copy_src.identicalMemoryLayout; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkHostImageCopyDevicePerformanceQueryEXT& safe_VkHostImageCopyDevicePerformanceQueryEXT::operator=( + const safe_VkHostImageCopyDevicePerformanceQueryEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + optimalDeviceAccess = copy_src.optimalDeviceAccess; + identicalMemoryLayout = copy_src.identicalMemoryLayout; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkHostImageCopyDevicePerformanceQueryEXT::~safe_VkHostImageCopyDevicePerformanceQueryEXT() { FreePnextChain(pNext); } + +void safe_VkHostImageCopyDevicePerformanceQueryEXT::initialize(const VkHostImageCopyDevicePerformanceQueryEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + optimalDeviceAccess = in_struct->optimalDeviceAccess; + identicalMemoryLayout = in_struct->identicalMemoryLayout; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkHostImageCopyDevicePerformanceQueryEXT::initialize(const safe_VkHostImageCopyDevicePerformanceQueryEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + optimalDeviceAccess = copy_src->optimalDeviceAccess; + identicalMemoryLayout = copy_src->identicalMemoryLayout; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT::safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT( + const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + memoryMapPlaced(in_struct->memoryMapPlaced), + memoryMapRangePlaced(in_struct->memoryMapRangePlaced), + memoryUnmapReserve(in_struct->memoryUnmapReserve) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT::safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT), + pNext(nullptr), + memoryMapPlaced(), + memoryMapRangePlaced(), + memoryUnmapReserve() {} + +safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT::safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT( + const safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT& copy_src) { + sType = copy_src.sType; + memoryMapPlaced = copy_src.memoryMapPlaced; + memoryMapRangePlaced = copy_src.memoryMapRangePlaced; + memoryUnmapReserve = copy_src.memoryUnmapReserve; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT& safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT::operator=( + const safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memoryMapPlaced = copy_src.memoryMapPlaced; + memoryMapRangePlaced = copy_src.memoryMapRangePlaced; + memoryUnmapReserve = copy_src.memoryUnmapReserve; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT::~safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT::initialize(const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memoryMapPlaced = in_struct->memoryMapPlaced; + memoryMapRangePlaced = in_struct->memoryMapRangePlaced; + memoryUnmapReserve = in_struct->memoryUnmapReserve; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT::initialize(const safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memoryMapPlaced = copy_src->memoryMapPlaced; + memoryMapRangePlaced = copy_src->memoryMapRangePlaced; + memoryUnmapReserve = copy_src->memoryUnmapReserve; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT::safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT( + const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), minPlacedMemoryMapAlignment(in_struct->minPlacedMemoryMapAlignment) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT::safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT), pNext(nullptr), minPlacedMemoryMapAlignment() {} + +safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT::safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT( + const safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT& copy_src) { + sType = copy_src.sType; + minPlacedMemoryMapAlignment = copy_src.minPlacedMemoryMapAlignment; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT& safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT::operator=( + const safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + minPlacedMemoryMapAlignment = copy_src.minPlacedMemoryMapAlignment; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT::~safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT::initialize(const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + minPlacedMemoryMapAlignment = in_struct->minPlacedMemoryMapAlignment; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT::initialize( + const safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + minPlacedMemoryMapAlignment = copy_src->minPlacedMemoryMapAlignment; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMemoryMapPlacedInfoEXT::safe_VkMemoryMapPlacedInfoEXT(const VkMemoryMapPlacedInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pPlacedAddress(in_struct->pPlacedAddress) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMemoryMapPlacedInfoEXT::safe_VkMemoryMapPlacedInfoEXT() + : sType(VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT), pNext(nullptr), pPlacedAddress(nullptr) {} + +safe_VkMemoryMapPlacedInfoEXT::safe_VkMemoryMapPlacedInfoEXT(const safe_VkMemoryMapPlacedInfoEXT& copy_src) { + sType = copy_src.sType; + pPlacedAddress = copy_src.pPlacedAddress; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryMapPlacedInfoEXT& safe_VkMemoryMapPlacedInfoEXT::operator=(const safe_VkMemoryMapPlacedInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pPlacedAddress = copy_src.pPlacedAddress; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryMapPlacedInfoEXT::~safe_VkMemoryMapPlacedInfoEXT() { FreePnextChain(pNext); } + +void safe_VkMemoryMapPlacedInfoEXT::initialize(const VkMemoryMapPlacedInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pPlacedAddress = in_struct->pPlacedAddress; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryMapPlacedInfoEXT::initialize(const safe_VkMemoryMapPlacedInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pPlacedAddress = copy_src->pPlacedAddress; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT( + const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shaderBufferFloat16Atomics(in_struct->shaderBufferFloat16Atomics), + shaderBufferFloat16AtomicAdd(in_struct->shaderBufferFloat16AtomicAdd), + shaderBufferFloat16AtomicMinMax(in_struct->shaderBufferFloat16AtomicMinMax), + shaderBufferFloat32AtomicMinMax(in_struct->shaderBufferFloat32AtomicMinMax), + shaderBufferFloat64AtomicMinMax(in_struct->shaderBufferFloat64AtomicMinMax), + shaderSharedFloat16Atomics(in_struct->shaderSharedFloat16Atomics), + shaderSharedFloat16AtomicAdd(in_struct->shaderSharedFloat16AtomicAdd), + shaderSharedFloat16AtomicMinMax(in_struct->shaderSharedFloat16AtomicMinMax), + shaderSharedFloat32AtomicMinMax(in_struct->shaderSharedFloat32AtomicMinMax), + shaderSharedFloat64AtomicMinMax(in_struct->shaderSharedFloat64AtomicMinMax), + shaderImageFloat32AtomicMinMax(in_struct->shaderImageFloat32AtomicMinMax), + sparseImageFloat32AtomicMinMax(in_struct->sparseImageFloat32AtomicMinMax) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT), + pNext(nullptr), + shaderBufferFloat16Atomics(), + shaderBufferFloat16AtomicAdd(), + shaderBufferFloat16AtomicMinMax(), + shaderBufferFloat32AtomicMinMax(), + shaderBufferFloat64AtomicMinMax(), + shaderSharedFloat16Atomics(), + shaderSharedFloat16AtomicAdd(), + shaderSharedFloat16AtomicMinMax(), + shaderSharedFloat32AtomicMinMax(), + shaderSharedFloat64AtomicMinMax(), + shaderImageFloat32AtomicMinMax(), + sparseImageFloat32AtomicMinMax() {} + +safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT( + const safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& copy_src) { + sType = copy_src.sType; + shaderBufferFloat16Atomics = copy_src.shaderBufferFloat16Atomics; + shaderBufferFloat16AtomicAdd = copy_src.shaderBufferFloat16AtomicAdd; + shaderBufferFloat16AtomicMinMax = copy_src.shaderBufferFloat16AtomicMinMax; + shaderBufferFloat32AtomicMinMax = copy_src.shaderBufferFloat32AtomicMinMax; + shaderBufferFloat64AtomicMinMax = copy_src.shaderBufferFloat64AtomicMinMax; + shaderSharedFloat16Atomics = copy_src.shaderSharedFloat16Atomics; + shaderSharedFloat16AtomicAdd = copy_src.shaderSharedFloat16AtomicAdd; + shaderSharedFloat16AtomicMinMax = copy_src.shaderSharedFloat16AtomicMinMax; + shaderSharedFloat32AtomicMinMax = copy_src.shaderSharedFloat32AtomicMinMax; + shaderSharedFloat64AtomicMinMax = copy_src.shaderSharedFloat64AtomicMinMax; + shaderImageFloat32AtomicMinMax = copy_src.shaderImageFloat32AtomicMinMax; + sparseImageFloat32AtomicMinMax = copy_src.sparseImageFloat32AtomicMinMax; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::operator=( + const safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderBufferFloat16Atomics = copy_src.shaderBufferFloat16Atomics; + shaderBufferFloat16AtomicAdd = copy_src.shaderBufferFloat16AtomicAdd; + shaderBufferFloat16AtomicMinMax = copy_src.shaderBufferFloat16AtomicMinMax; + shaderBufferFloat32AtomicMinMax = copy_src.shaderBufferFloat32AtomicMinMax; + shaderBufferFloat64AtomicMinMax = copy_src.shaderBufferFloat64AtomicMinMax; + shaderSharedFloat16Atomics = copy_src.shaderSharedFloat16Atomics; + shaderSharedFloat16AtomicAdd = copy_src.shaderSharedFloat16AtomicAdd; + shaderSharedFloat16AtomicMinMax = copy_src.shaderSharedFloat16AtomicMinMax; + shaderSharedFloat32AtomicMinMax = copy_src.shaderSharedFloat32AtomicMinMax; + shaderSharedFloat64AtomicMinMax = copy_src.shaderSharedFloat64AtomicMinMax; + shaderImageFloat32AtomicMinMax = copy_src.shaderImageFloat32AtomicMinMax; + sparseImageFloat32AtomicMinMax = copy_src.sparseImageFloat32AtomicMinMax; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::~safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::initialize(const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderBufferFloat16Atomics = in_struct->shaderBufferFloat16Atomics; + shaderBufferFloat16AtomicAdd = in_struct->shaderBufferFloat16AtomicAdd; + shaderBufferFloat16AtomicMinMax = in_struct->shaderBufferFloat16AtomicMinMax; + shaderBufferFloat32AtomicMinMax = in_struct->shaderBufferFloat32AtomicMinMax; + shaderBufferFloat64AtomicMinMax = in_struct->shaderBufferFloat64AtomicMinMax; + shaderSharedFloat16Atomics = in_struct->shaderSharedFloat16Atomics; + shaderSharedFloat16AtomicAdd = in_struct->shaderSharedFloat16AtomicAdd; + shaderSharedFloat16AtomicMinMax = in_struct->shaderSharedFloat16AtomicMinMax; + shaderSharedFloat32AtomicMinMax = in_struct->shaderSharedFloat32AtomicMinMax; + shaderSharedFloat64AtomicMinMax = in_struct->shaderSharedFloat64AtomicMinMax; + shaderImageFloat32AtomicMinMax = in_struct->shaderImageFloat32AtomicMinMax; + sparseImageFloat32AtomicMinMax = in_struct->sparseImageFloat32AtomicMinMax; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::initialize( + const safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderBufferFloat16Atomics = copy_src->shaderBufferFloat16Atomics; + shaderBufferFloat16AtomicAdd = copy_src->shaderBufferFloat16AtomicAdd; + shaderBufferFloat16AtomicMinMax = copy_src->shaderBufferFloat16AtomicMinMax; + shaderBufferFloat32AtomicMinMax = copy_src->shaderBufferFloat32AtomicMinMax; + shaderBufferFloat64AtomicMinMax = copy_src->shaderBufferFloat64AtomicMinMax; + shaderSharedFloat16Atomics = copy_src->shaderSharedFloat16Atomics; + shaderSharedFloat16AtomicAdd = copy_src->shaderSharedFloat16AtomicAdd; + shaderSharedFloat16AtomicMinMax = copy_src->shaderSharedFloat16AtomicMinMax; + shaderSharedFloat32AtomicMinMax = copy_src->shaderSharedFloat32AtomicMinMax; + shaderSharedFloat64AtomicMinMax = copy_src->shaderSharedFloat64AtomicMinMax; + shaderImageFloat32AtomicMinMax = copy_src->shaderImageFloat32AtomicMinMax; + sparseImageFloat32AtomicMinMax = copy_src->sparseImageFloat32AtomicMinMax; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSurfacePresentModeEXT::safe_VkSurfacePresentModeEXT(const VkSurfacePresentModeEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), presentMode(in_struct->presentMode) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSurfacePresentModeEXT::safe_VkSurfacePresentModeEXT() + : sType(VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT), pNext(nullptr), presentMode() {} + +safe_VkSurfacePresentModeEXT::safe_VkSurfacePresentModeEXT(const safe_VkSurfacePresentModeEXT& copy_src) { + sType = copy_src.sType; + presentMode = copy_src.presentMode; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSurfacePresentModeEXT& safe_VkSurfacePresentModeEXT::operator=(const safe_VkSurfacePresentModeEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + presentMode = copy_src.presentMode; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSurfacePresentModeEXT::~safe_VkSurfacePresentModeEXT() { FreePnextChain(pNext); } + +void safe_VkSurfacePresentModeEXT::initialize(const VkSurfacePresentModeEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + presentMode = in_struct->presentMode; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSurfacePresentModeEXT::initialize(const safe_VkSurfacePresentModeEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentMode = copy_src->presentMode; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSurfacePresentScalingCapabilitiesEXT::safe_VkSurfacePresentScalingCapabilitiesEXT( + const VkSurfacePresentScalingCapabilitiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + supportedPresentScaling(in_struct->supportedPresentScaling), + supportedPresentGravityX(in_struct->supportedPresentGravityX), + supportedPresentGravityY(in_struct->supportedPresentGravityY), + minScaledImageExtent(in_struct->minScaledImageExtent), + maxScaledImageExtent(in_struct->maxScaledImageExtent) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSurfacePresentScalingCapabilitiesEXT::safe_VkSurfacePresentScalingCapabilitiesEXT() + : sType(VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT), + pNext(nullptr), + supportedPresentScaling(), + supportedPresentGravityX(), + supportedPresentGravityY(), + minScaledImageExtent(), + maxScaledImageExtent() {} + +safe_VkSurfacePresentScalingCapabilitiesEXT::safe_VkSurfacePresentScalingCapabilitiesEXT( + const safe_VkSurfacePresentScalingCapabilitiesEXT& copy_src) { + sType = copy_src.sType; + supportedPresentScaling = copy_src.supportedPresentScaling; + supportedPresentGravityX = copy_src.supportedPresentGravityX; + supportedPresentGravityY = copy_src.supportedPresentGravityY; + minScaledImageExtent = copy_src.minScaledImageExtent; + maxScaledImageExtent = copy_src.maxScaledImageExtent; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSurfacePresentScalingCapabilitiesEXT& safe_VkSurfacePresentScalingCapabilitiesEXT::operator=( + const safe_VkSurfacePresentScalingCapabilitiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + supportedPresentScaling = copy_src.supportedPresentScaling; + supportedPresentGravityX = copy_src.supportedPresentGravityX; + supportedPresentGravityY = copy_src.supportedPresentGravityY; + minScaledImageExtent = copy_src.minScaledImageExtent; + maxScaledImageExtent = copy_src.maxScaledImageExtent; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSurfacePresentScalingCapabilitiesEXT::~safe_VkSurfacePresentScalingCapabilitiesEXT() { FreePnextChain(pNext); } + +void safe_VkSurfacePresentScalingCapabilitiesEXT::initialize(const VkSurfacePresentScalingCapabilitiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + supportedPresentScaling = in_struct->supportedPresentScaling; + supportedPresentGravityX = in_struct->supportedPresentGravityX; + supportedPresentGravityY = in_struct->supportedPresentGravityY; + minScaledImageExtent = in_struct->minScaledImageExtent; + maxScaledImageExtent = in_struct->maxScaledImageExtent; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSurfacePresentScalingCapabilitiesEXT::initialize(const safe_VkSurfacePresentScalingCapabilitiesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + supportedPresentScaling = copy_src->supportedPresentScaling; + supportedPresentGravityX = copy_src->supportedPresentGravityX; + supportedPresentGravityY = copy_src->supportedPresentGravityY; + minScaledImageExtent = copy_src->minScaledImageExtent; + maxScaledImageExtent = copy_src->maxScaledImageExtent; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSurfacePresentModeCompatibilityEXT::safe_VkSurfacePresentModeCompatibilityEXT( + const VkSurfacePresentModeCompatibilityEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), presentModeCount(in_struct->presentModeCount), pPresentModes(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pPresentModes) { + pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount]; + memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount); + } +} + +safe_VkSurfacePresentModeCompatibilityEXT::safe_VkSurfacePresentModeCompatibilityEXT() + : sType(VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT), pNext(nullptr), presentModeCount(), pPresentModes(nullptr) {} + +safe_VkSurfacePresentModeCompatibilityEXT::safe_VkSurfacePresentModeCompatibilityEXT( + const safe_VkSurfacePresentModeCompatibilityEXT& copy_src) { + sType = copy_src.sType; + presentModeCount = copy_src.presentModeCount; + pPresentModes = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPresentModes) { + pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount]; + memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount); + } +} + +safe_VkSurfacePresentModeCompatibilityEXT& safe_VkSurfacePresentModeCompatibilityEXT::operator=( + const safe_VkSurfacePresentModeCompatibilityEXT& copy_src) { + if (©_src == this) return *this; + + if (pPresentModes) delete[] pPresentModes; + FreePnextChain(pNext); + + sType = copy_src.sType; + presentModeCount = copy_src.presentModeCount; + pPresentModes = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPresentModes) { + pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount]; + memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount); + } + + return *this; +} + +safe_VkSurfacePresentModeCompatibilityEXT::~safe_VkSurfacePresentModeCompatibilityEXT() { + if (pPresentModes) delete[] pPresentModes; + FreePnextChain(pNext); +} + +void safe_VkSurfacePresentModeCompatibilityEXT::initialize(const VkSurfacePresentModeCompatibilityEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPresentModes) delete[] pPresentModes; + FreePnextChain(pNext); + sType = in_struct->sType; + presentModeCount = in_struct->presentModeCount; + pPresentModes = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pPresentModes) { + pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount]; + memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount); + } +} + +void safe_VkSurfacePresentModeCompatibilityEXT::initialize(const safe_VkSurfacePresentModeCompatibilityEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentModeCount = copy_src->presentModeCount; + pPresentModes = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pPresentModes) { + pPresentModes = new VkPresentModeKHR[copy_src->presentModeCount]; + memcpy((void*)pPresentModes, (void*)copy_src->pPresentModes, sizeof(VkPresentModeKHR) * copy_src->presentModeCount); + } +} + +safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT( + const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), swapchainMaintenance1(in_struct->swapchainMaintenance1) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT), pNext(nullptr), swapchainMaintenance1() {} + +safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT( + const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT& copy_src) { + sType = copy_src.sType; + swapchainMaintenance1 = copy_src.swapchainMaintenance1; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT& safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::operator=( + const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + swapchainMaintenance1 = copy_src.swapchainMaintenance1; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::~safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::initialize( + const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + swapchainMaintenance1 = in_struct->swapchainMaintenance1; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::initialize( + const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + swapchainMaintenance1 = copy_src->swapchainMaintenance1; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSwapchainPresentFenceInfoEXT::safe_VkSwapchainPresentFenceInfoEXT(const VkSwapchainPresentFenceInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pFences(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (swapchainCount && in_struct->pFences) { + pFences = new VkFence[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pFences[i] = in_struct->pFences[i]; + } + } +} + +safe_VkSwapchainPresentFenceInfoEXT::safe_VkSwapchainPresentFenceInfoEXT() + : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT), pNext(nullptr), swapchainCount(), pFences(nullptr) {} + +safe_VkSwapchainPresentFenceInfoEXT::safe_VkSwapchainPresentFenceInfoEXT(const safe_VkSwapchainPresentFenceInfoEXT& copy_src) { + sType = copy_src.sType; + swapchainCount = copy_src.swapchainCount; + pFences = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (swapchainCount && copy_src.pFences) { + pFences = new VkFence[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pFences[i] = copy_src.pFences[i]; + } + } +} + +safe_VkSwapchainPresentFenceInfoEXT& safe_VkSwapchainPresentFenceInfoEXT::operator=( + const safe_VkSwapchainPresentFenceInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pFences) delete[] pFences; + FreePnextChain(pNext); + + sType = copy_src.sType; + swapchainCount = copy_src.swapchainCount; + pFences = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (swapchainCount && copy_src.pFences) { + pFences = new VkFence[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pFences[i] = copy_src.pFences[i]; + } + } + + return *this; +} + +safe_VkSwapchainPresentFenceInfoEXT::~safe_VkSwapchainPresentFenceInfoEXT() { + if (pFences) delete[] pFences; + FreePnextChain(pNext); +} + +void safe_VkSwapchainPresentFenceInfoEXT::initialize(const VkSwapchainPresentFenceInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pFences) delete[] pFences; + FreePnextChain(pNext); + sType = in_struct->sType; + swapchainCount = in_struct->swapchainCount; + pFences = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (swapchainCount && in_struct->pFences) { + pFences = new VkFence[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pFences[i] = in_struct->pFences[i]; + } + } +} + +void safe_VkSwapchainPresentFenceInfoEXT::initialize(const safe_VkSwapchainPresentFenceInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + swapchainCount = copy_src->swapchainCount; + pFences = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (swapchainCount && copy_src->pFences) { + pFences = new VkFence[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pFences[i] = copy_src->pFences[i]; + } + } +} + +safe_VkSwapchainPresentModesCreateInfoEXT::safe_VkSwapchainPresentModesCreateInfoEXT( + const VkSwapchainPresentModesCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), presentModeCount(in_struct->presentModeCount), pPresentModes(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pPresentModes) { + pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount]; + memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount); + } +} + +safe_VkSwapchainPresentModesCreateInfoEXT::safe_VkSwapchainPresentModesCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT), + pNext(nullptr), + presentModeCount(), + pPresentModes(nullptr) {} + +safe_VkSwapchainPresentModesCreateInfoEXT::safe_VkSwapchainPresentModesCreateInfoEXT( + const safe_VkSwapchainPresentModesCreateInfoEXT& copy_src) { + sType = copy_src.sType; + presentModeCount = copy_src.presentModeCount; + pPresentModes = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPresentModes) { + pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount]; + memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount); + } +} + +safe_VkSwapchainPresentModesCreateInfoEXT& safe_VkSwapchainPresentModesCreateInfoEXT::operator=( + const safe_VkSwapchainPresentModesCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pPresentModes) delete[] pPresentModes; + FreePnextChain(pNext); + + sType = copy_src.sType; + presentModeCount = copy_src.presentModeCount; + pPresentModes = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPresentModes) { + pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount]; + memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount); + } + + return *this; +} + +safe_VkSwapchainPresentModesCreateInfoEXT::~safe_VkSwapchainPresentModesCreateInfoEXT() { + if (pPresentModes) delete[] pPresentModes; + FreePnextChain(pNext); +} + +void safe_VkSwapchainPresentModesCreateInfoEXT::initialize(const VkSwapchainPresentModesCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPresentModes) delete[] pPresentModes; + FreePnextChain(pNext); + sType = in_struct->sType; + presentModeCount = in_struct->presentModeCount; + pPresentModes = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pPresentModes) { + pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount]; + memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount); + } +} + +void safe_VkSwapchainPresentModesCreateInfoEXT::initialize(const safe_VkSwapchainPresentModesCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentModeCount = copy_src->presentModeCount; + pPresentModes = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pPresentModes) { + pPresentModes = new VkPresentModeKHR[copy_src->presentModeCount]; + memcpy((void*)pPresentModes, (void*)copy_src->pPresentModes, sizeof(VkPresentModeKHR) * copy_src->presentModeCount); + } +} + +safe_VkSwapchainPresentModeInfoEXT::safe_VkSwapchainPresentModeInfoEXT(const VkSwapchainPresentModeInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pPresentModes(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pPresentModes) { + pPresentModes = new VkPresentModeKHR[in_struct->swapchainCount]; + memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->swapchainCount); + } +} + +safe_VkSwapchainPresentModeInfoEXT::safe_VkSwapchainPresentModeInfoEXT() + : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT), pNext(nullptr), swapchainCount(), pPresentModes(nullptr) {} + +safe_VkSwapchainPresentModeInfoEXT::safe_VkSwapchainPresentModeInfoEXT(const safe_VkSwapchainPresentModeInfoEXT& copy_src) { + sType = copy_src.sType; + swapchainCount = copy_src.swapchainCount; + pPresentModes = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPresentModes) { + pPresentModes = new VkPresentModeKHR[copy_src.swapchainCount]; + memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.swapchainCount); + } +} + +safe_VkSwapchainPresentModeInfoEXT& safe_VkSwapchainPresentModeInfoEXT::operator=( + const safe_VkSwapchainPresentModeInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pPresentModes) delete[] pPresentModes; + FreePnextChain(pNext); + + sType = copy_src.sType; + swapchainCount = copy_src.swapchainCount; + pPresentModes = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPresentModes) { + pPresentModes = new VkPresentModeKHR[copy_src.swapchainCount]; + memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.swapchainCount); + } + + return *this; +} + +safe_VkSwapchainPresentModeInfoEXT::~safe_VkSwapchainPresentModeInfoEXT() { + if (pPresentModes) delete[] pPresentModes; + FreePnextChain(pNext); +} + +void safe_VkSwapchainPresentModeInfoEXT::initialize(const VkSwapchainPresentModeInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPresentModes) delete[] pPresentModes; + FreePnextChain(pNext); + sType = in_struct->sType; + swapchainCount = in_struct->swapchainCount; + pPresentModes = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pPresentModes) { + pPresentModes = new VkPresentModeKHR[in_struct->swapchainCount]; + memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->swapchainCount); + } +} + +void safe_VkSwapchainPresentModeInfoEXT::initialize(const safe_VkSwapchainPresentModeInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + swapchainCount = copy_src->swapchainCount; + pPresentModes = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pPresentModes) { + pPresentModes = new VkPresentModeKHR[copy_src->swapchainCount]; + memcpy((void*)pPresentModes, (void*)copy_src->pPresentModes, sizeof(VkPresentModeKHR) * copy_src->swapchainCount); + } +} + +safe_VkSwapchainPresentScalingCreateInfoEXT::safe_VkSwapchainPresentScalingCreateInfoEXT( + const VkSwapchainPresentScalingCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + scalingBehavior(in_struct->scalingBehavior), + presentGravityX(in_struct->presentGravityX), + presentGravityY(in_struct->presentGravityY) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSwapchainPresentScalingCreateInfoEXT::safe_VkSwapchainPresentScalingCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT), + pNext(nullptr), + scalingBehavior(), + presentGravityX(), + presentGravityY() {} + +safe_VkSwapchainPresentScalingCreateInfoEXT::safe_VkSwapchainPresentScalingCreateInfoEXT( + const safe_VkSwapchainPresentScalingCreateInfoEXT& copy_src) { + sType = copy_src.sType; + scalingBehavior = copy_src.scalingBehavior; + presentGravityX = copy_src.presentGravityX; + presentGravityY = copy_src.presentGravityY; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSwapchainPresentScalingCreateInfoEXT& safe_VkSwapchainPresentScalingCreateInfoEXT::operator=( + const safe_VkSwapchainPresentScalingCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + scalingBehavior = copy_src.scalingBehavior; + presentGravityX = copy_src.presentGravityX; + presentGravityY = copy_src.presentGravityY; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSwapchainPresentScalingCreateInfoEXT::~safe_VkSwapchainPresentScalingCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkSwapchainPresentScalingCreateInfoEXT::initialize(const VkSwapchainPresentScalingCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + scalingBehavior = in_struct->scalingBehavior; + presentGravityX = in_struct->presentGravityX; + presentGravityY = in_struct->presentGravityY; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSwapchainPresentScalingCreateInfoEXT::initialize(const safe_VkSwapchainPresentScalingCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + scalingBehavior = copy_src->scalingBehavior; + presentGravityX = copy_src->presentGravityX; + presentGravityY = copy_src->presentGravityY; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkReleaseSwapchainImagesInfoEXT::safe_VkReleaseSwapchainImagesInfoEXT(const VkReleaseSwapchainImagesInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + swapchain(in_struct->swapchain), + imageIndexCount(in_struct->imageIndexCount), + pImageIndices(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pImageIndices) { + pImageIndices = new uint32_t[in_struct->imageIndexCount]; + memcpy((void*)pImageIndices, (void*)in_struct->pImageIndices, sizeof(uint32_t) * in_struct->imageIndexCount); + } +} + +safe_VkReleaseSwapchainImagesInfoEXT::safe_VkReleaseSwapchainImagesInfoEXT() + : sType(VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT), + pNext(nullptr), + swapchain(), + imageIndexCount(), + pImageIndices(nullptr) {} + +safe_VkReleaseSwapchainImagesInfoEXT::safe_VkReleaseSwapchainImagesInfoEXT(const safe_VkReleaseSwapchainImagesInfoEXT& copy_src) { + sType = copy_src.sType; + swapchain = copy_src.swapchain; + imageIndexCount = copy_src.imageIndexCount; + pImageIndices = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pImageIndices) { + pImageIndices = new uint32_t[copy_src.imageIndexCount]; + memcpy((void*)pImageIndices, (void*)copy_src.pImageIndices, sizeof(uint32_t) * copy_src.imageIndexCount); + } +} + +safe_VkReleaseSwapchainImagesInfoEXT& safe_VkReleaseSwapchainImagesInfoEXT::operator=( + const safe_VkReleaseSwapchainImagesInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pImageIndices) delete[] pImageIndices; + FreePnextChain(pNext); + + sType = copy_src.sType; + swapchain = copy_src.swapchain; + imageIndexCount = copy_src.imageIndexCount; + pImageIndices = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pImageIndices) { + pImageIndices = new uint32_t[copy_src.imageIndexCount]; + memcpy((void*)pImageIndices, (void*)copy_src.pImageIndices, sizeof(uint32_t) * copy_src.imageIndexCount); + } + + return *this; +} + +safe_VkReleaseSwapchainImagesInfoEXT::~safe_VkReleaseSwapchainImagesInfoEXT() { + if (pImageIndices) delete[] pImageIndices; + FreePnextChain(pNext); +} + +void safe_VkReleaseSwapchainImagesInfoEXT::initialize(const VkReleaseSwapchainImagesInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pImageIndices) delete[] pImageIndices; + FreePnextChain(pNext); + sType = in_struct->sType; + swapchain = in_struct->swapchain; + imageIndexCount = in_struct->imageIndexCount; + pImageIndices = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pImageIndices) { + pImageIndices = new uint32_t[in_struct->imageIndexCount]; + memcpy((void*)pImageIndices, (void*)in_struct->pImageIndices, sizeof(uint32_t) * in_struct->imageIndexCount); + } +} + +void safe_VkReleaseSwapchainImagesInfoEXT::initialize(const safe_VkReleaseSwapchainImagesInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + swapchain = copy_src->swapchain; + imageIndexCount = copy_src->imageIndexCount; + pImageIndices = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pImageIndices) { + pImageIndices = new uint32_t[copy_src->imageIndexCount]; + memcpy((void*)pImageIndices, (void*)copy_src->pImageIndices, sizeof(uint32_t) * copy_src->imageIndexCount); + } +} + +safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT( + const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), texelBufferAlignment(in_struct->texelBufferAlignment) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT), pNext(nullptr), texelBufferAlignment() {} + +safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT( + const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& copy_src) { + sType = copy_src.sType; + texelBufferAlignment = copy_src.texelBufferAlignment; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::operator=( + const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + texelBufferAlignment = copy_src.texelBufferAlignment; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::~safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::initialize( + const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + texelBufferAlignment = in_struct->texelBufferAlignment; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::initialize( + const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + texelBufferAlignment = copy_src->texelBufferAlignment; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT::safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT( + const VkPhysicalDeviceDepthBiasControlFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + depthBiasControl(in_struct->depthBiasControl), + leastRepresentableValueForceUnormRepresentation(in_struct->leastRepresentableValueForceUnormRepresentation), + floatRepresentation(in_struct->floatRepresentation), + depthBiasExact(in_struct->depthBiasExact) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT::safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT), + pNext(nullptr), + depthBiasControl(), + leastRepresentableValueForceUnormRepresentation(), + floatRepresentation(), + depthBiasExact() {} + +safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT::safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT( + const safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT& copy_src) { + sType = copy_src.sType; + depthBiasControl = copy_src.depthBiasControl; + leastRepresentableValueForceUnormRepresentation = copy_src.leastRepresentableValueForceUnormRepresentation; + floatRepresentation = copy_src.floatRepresentation; + depthBiasExact = copy_src.depthBiasExact; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT& safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT::operator=( + const safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + depthBiasControl = copy_src.depthBiasControl; + leastRepresentableValueForceUnormRepresentation = copy_src.leastRepresentableValueForceUnormRepresentation; + floatRepresentation = copy_src.floatRepresentation; + depthBiasExact = copy_src.depthBiasExact; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT::~safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT::initialize(const VkPhysicalDeviceDepthBiasControlFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + depthBiasControl = in_struct->depthBiasControl; + leastRepresentableValueForceUnormRepresentation = in_struct->leastRepresentableValueForceUnormRepresentation; + floatRepresentation = in_struct->floatRepresentation; + depthBiasExact = in_struct->depthBiasExact; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT::initialize(const safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + depthBiasControl = copy_src->depthBiasControl; + leastRepresentableValueForceUnormRepresentation = copy_src->leastRepresentableValueForceUnormRepresentation; + floatRepresentation = copy_src->floatRepresentation; + depthBiasExact = copy_src->depthBiasExact; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDepthBiasInfoEXT::safe_VkDepthBiasInfoEXT(const VkDepthBiasInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + depthBiasConstantFactor(in_struct->depthBiasConstantFactor), + depthBiasClamp(in_struct->depthBiasClamp), + depthBiasSlopeFactor(in_struct->depthBiasSlopeFactor) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDepthBiasInfoEXT::safe_VkDepthBiasInfoEXT() + : sType(VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT), + pNext(nullptr), + depthBiasConstantFactor(), + depthBiasClamp(), + depthBiasSlopeFactor() {} + +safe_VkDepthBiasInfoEXT::safe_VkDepthBiasInfoEXT(const safe_VkDepthBiasInfoEXT& copy_src) { + sType = copy_src.sType; + depthBiasConstantFactor = copy_src.depthBiasConstantFactor; + depthBiasClamp = copy_src.depthBiasClamp; + depthBiasSlopeFactor = copy_src.depthBiasSlopeFactor; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDepthBiasInfoEXT& safe_VkDepthBiasInfoEXT::operator=(const safe_VkDepthBiasInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + depthBiasConstantFactor = copy_src.depthBiasConstantFactor; + depthBiasClamp = copy_src.depthBiasClamp; + depthBiasSlopeFactor = copy_src.depthBiasSlopeFactor; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDepthBiasInfoEXT::~safe_VkDepthBiasInfoEXT() { FreePnextChain(pNext); } + +void safe_VkDepthBiasInfoEXT::initialize(const VkDepthBiasInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + depthBiasConstantFactor = in_struct->depthBiasConstantFactor; + depthBiasClamp = in_struct->depthBiasClamp; + depthBiasSlopeFactor = in_struct->depthBiasSlopeFactor; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDepthBiasInfoEXT::initialize(const safe_VkDepthBiasInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + depthBiasConstantFactor = copy_src->depthBiasConstantFactor; + depthBiasClamp = copy_src->depthBiasClamp; + depthBiasSlopeFactor = copy_src->depthBiasSlopeFactor; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDepthBiasRepresentationInfoEXT::safe_VkDepthBiasRepresentationInfoEXT(const VkDepthBiasRepresentationInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + depthBiasRepresentation(in_struct->depthBiasRepresentation), + depthBiasExact(in_struct->depthBiasExact) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDepthBiasRepresentationInfoEXT::safe_VkDepthBiasRepresentationInfoEXT() + : sType(VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT), pNext(nullptr), depthBiasRepresentation(), depthBiasExact() {} + +safe_VkDepthBiasRepresentationInfoEXT::safe_VkDepthBiasRepresentationInfoEXT( + const safe_VkDepthBiasRepresentationInfoEXT& copy_src) { + sType = copy_src.sType; + depthBiasRepresentation = copy_src.depthBiasRepresentation; + depthBiasExact = copy_src.depthBiasExact; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDepthBiasRepresentationInfoEXT& safe_VkDepthBiasRepresentationInfoEXT::operator=( + const safe_VkDepthBiasRepresentationInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + depthBiasRepresentation = copy_src.depthBiasRepresentation; + depthBiasExact = copy_src.depthBiasExact; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDepthBiasRepresentationInfoEXT::~safe_VkDepthBiasRepresentationInfoEXT() { FreePnextChain(pNext); } + +void safe_VkDepthBiasRepresentationInfoEXT::initialize(const VkDepthBiasRepresentationInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + depthBiasRepresentation = in_struct->depthBiasRepresentation; + depthBiasExact = in_struct->depthBiasExact; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDepthBiasRepresentationInfoEXT::initialize(const safe_VkDepthBiasRepresentationInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + depthBiasRepresentation = copy_src->depthBiasRepresentation; + depthBiasExact = copy_src->depthBiasExact; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT( + const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), deviceMemoryReport(in_struct->deviceMemoryReport) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT), pNext(nullptr), deviceMemoryReport() {} + +safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT( + const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& copy_src) { + sType = copy_src.sType; + deviceMemoryReport = copy_src.deviceMemoryReport; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::operator=( + const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + deviceMemoryReport = copy_src.deviceMemoryReport; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::~safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::initialize(const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + deviceMemoryReport = in_struct->deviceMemoryReport; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::initialize( + const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + deviceMemoryReport = copy_src->deviceMemoryReport; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDeviceMemoryReportCallbackDataEXT::safe_VkDeviceMemoryReportCallbackDataEXT( + const VkDeviceMemoryReportCallbackDataEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + type(in_struct->type), + memoryObjectId(in_struct->memoryObjectId), + size(in_struct->size), + objectType(in_struct->objectType), + objectHandle(in_struct->objectHandle), + heapIndex(in_struct->heapIndex) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDeviceMemoryReportCallbackDataEXT::safe_VkDeviceMemoryReportCallbackDataEXT() + : sType(VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT), + pNext(nullptr), + flags(), + type(), + memoryObjectId(), + size(), + objectType(), + objectHandle(), + heapIndex() {} + +safe_VkDeviceMemoryReportCallbackDataEXT::safe_VkDeviceMemoryReportCallbackDataEXT( + const safe_VkDeviceMemoryReportCallbackDataEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + type = copy_src.type; + memoryObjectId = copy_src.memoryObjectId; + size = copy_src.size; + objectType = copy_src.objectType; + objectHandle = copy_src.objectHandle; + heapIndex = copy_src.heapIndex; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDeviceMemoryReportCallbackDataEXT& safe_VkDeviceMemoryReportCallbackDataEXT::operator=( + const safe_VkDeviceMemoryReportCallbackDataEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + type = copy_src.type; + memoryObjectId = copy_src.memoryObjectId; + size = copy_src.size; + objectType = copy_src.objectType; + objectHandle = copy_src.objectHandle; + heapIndex = copy_src.heapIndex; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDeviceMemoryReportCallbackDataEXT::~safe_VkDeviceMemoryReportCallbackDataEXT() { FreePnextChain(pNext); } + +void safe_VkDeviceMemoryReportCallbackDataEXT::initialize(const VkDeviceMemoryReportCallbackDataEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + type = in_struct->type; + memoryObjectId = in_struct->memoryObjectId; + size = in_struct->size; + objectType = in_struct->objectType; + objectHandle = in_struct->objectHandle; + heapIndex = in_struct->heapIndex; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDeviceMemoryReportCallbackDataEXT::initialize(const safe_VkDeviceMemoryReportCallbackDataEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + type = copy_src->type; + memoryObjectId = copy_src->memoryObjectId; + size = copy_src->size; + objectType = copy_src->objectType; + objectHandle = copy_src->objectHandle; + heapIndex = copy_src->heapIndex; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDeviceDeviceMemoryReportCreateInfoEXT::safe_VkDeviceDeviceMemoryReportCreateInfoEXT( + const VkDeviceDeviceMemoryReportCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + pfnUserCallback(in_struct->pfnUserCallback), + pUserData(in_struct->pUserData) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDeviceDeviceMemoryReportCreateInfoEXT::safe_VkDeviceDeviceMemoryReportCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT), + pNext(nullptr), + flags(), + pfnUserCallback(), + pUserData(nullptr) {} + +safe_VkDeviceDeviceMemoryReportCreateInfoEXT::safe_VkDeviceDeviceMemoryReportCreateInfoEXT( + const safe_VkDeviceDeviceMemoryReportCreateInfoEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pfnUserCallback = copy_src.pfnUserCallback; + pUserData = copy_src.pUserData; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDeviceDeviceMemoryReportCreateInfoEXT& safe_VkDeviceDeviceMemoryReportCreateInfoEXT::operator=( + const safe_VkDeviceDeviceMemoryReportCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pfnUserCallback = copy_src.pfnUserCallback; + pUserData = copy_src.pUserData; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDeviceDeviceMemoryReportCreateInfoEXT::~safe_VkDeviceDeviceMemoryReportCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkDeviceDeviceMemoryReportCreateInfoEXT::initialize(const VkDeviceDeviceMemoryReportCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pfnUserCallback = in_struct->pfnUserCallback; + pUserData = in_struct->pUserData; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDeviceDeviceMemoryReportCreateInfoEXT::initialize(const safe_VkDeviceDeviceMemoryReportCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pfnUserCallback = copy_src->pfnUserCallback; + pUserData = copy_src->pUserData; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceRobustness2FeaturesEXT::safe_VkPhysicalDeviceRobustness2FeaturesEXT( + const VkPhysicalDeviceRobustness2FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + robustBufferAccess2(in_struct->robustBufferAccess2), + robustImageAccess2(in_struct->robustImageAccess2), + nullDescriptor(in_struct->nullDescriptor) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceRobustness2FeaturesEXT::safe_VkPhysicalDeviceRobustness2FeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT), + pNext(nullptr), + robustBufferAccess2(), + robustImageAccess2(), + nullDescriptor() {} + +safe_VkPhysicalDeviceRobustness2FeaturesEXT::safe_VkPhysicalDeviceRobustness2FeaturesEXT( + const safe_VkPhysicalDeviceRobustness2FeaturesEXT& copy_src) { + sType = copy_src.sType; + robustBufferAccess2 = copy_src.robustBufferAccess2; + robustImageAccess2 = copy_src.robustImageAccess2; + nullDescriptor = copy_src.nullDescriptor; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceRobustness2FeaturesEXT& safe_VkPhysicalDeviceRobustness2FeaturesEXT::operator=( + const safe_VkPhysicalDeviceRobustness2FeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + robustBufferAccess2 = copy_src.robustBufferAccess2; + robustImageAccess2 = copy_src.robustImageAccess2; + nullDescriptor = copy_src.nullDescriptor; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceRobustness2FeaturesEXT::~safe_VkPhysicalDeviceRobustness2FeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceRobustness2FeaturesEXT::initialize(const VkPhysicalDeviceRobustness2FeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + robustBufferAccess2 = in_struct->robustBufferAccess2; + robustImageAccess2 = in_struct->robustImageAccess2; + nullDescriptor = in_struct->nullDescriptor; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceRobustness2FeaturesEXT::initialize(const safe_VkPhysicalDeviceRobustness2FeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + robustBufferAccess2 = copy_src->robustBufferAccess2; + robustImageAccess2 = copy_src->robustImageAccess2; + nullDescriptor = copy_src->nullDescriptor; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceRobustness2PropertiesEXT::safe_VkPhysicalDeviceRobustness2PropertiesEXT( + const VkPhysicalDeviceRobustness2PropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + robustStorageBufferAccessSizeAlignment(in_struct->robustStorageBufferAccessSizeAlignment), + robustUniformBufferAccessSizeAlignment(in_struct->robustUniformBufferAccessSizeAlignment) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceRobustness2PropertiesEXT::safe_VkPhysicalDeviceRobustness2PropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT), + pNext(nullptr), + robustStorageBufferAccessSizeAlignment(), + robustUniformBufferAccessSizeAlignment() {} + +safe_VkPhysicalDeviceRobustness2PropertiesEXT::safe_VkPhysicalDeviceRobustness2PropertiesEXT( + const safe_VkPhysicalDeviceRobustness2PropertiesEXT& copy_src) { + sType = copy_src.sType; + robustStorageBufferAccessSizeAlignment = copy_src.robustStorageBufferAccessSizeAlignment; + robustUniformBufferAccessSizeAlignment = copy_src.robustUniformBufferAccessSizeAlignment; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceRobustness2PropertiesEXT& safe_VkPhysicalDeviceRobustness2PropertiesEXT::operator=( + const safe_VkPhysicalDeviceRobustness2PropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + robustStorageBufferAccessSizeAlignment = copy_src.robustStorageBufferAccessSizeAlignment; + robustUniformBufferAccessSizeAlignment = copy_src.robustUniformBufferAccessSizeAlignment; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceRobustness2PropertiesEXT::~safe_VkPhysicalDeviceRobustness2PropertiesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceRobustness2PropertiesEXT::initialize(const VkPhysicalDeviceRobustness2PropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + robustStorageBufferAccessSizeAlignment = in_struct->robustStorageBufferAccessSizeAlignment; + robustUniformBufferAccessSizeAlignment = in_struct->robustUniformBufferAccessSizeAlignment; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceRobustness2PropertiesEXT::initialize(const safe_VkPhysicalDeviceRobustness2PropertiesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + robustStorageBufferAccessSizeAlignment = copy_src->robustStorageBufferAccessSizeAlignment; + robustUniformBufferAccessSizeAlignment = copy_src->robustUniformBufferAccessSizeAlignment; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSamplerCustomBorderColorCreateInfoEXT::safe_VkSamplerCustomBorderColorCreateInfoEXT( + const VkSamplerCustomBorderColorCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), customBorderColor(in_struct->customBorderColor), format(in_struct->format) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSamplerCustomBorderColorCreateInfoEXT::safe_VkSamplerCustomBorderColorCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT), pNext(nullptr), customBorderColor(), format() {} + +safe_VkSamplerCustomBorderColorCreateInfoEXT::safe_VkSamplerCustomBorderColorCreateInfoEXT( + const safe_VkSamplerCustomBorderColorCreateInfoEXT& copy_src) { + sType = copy_src.sType; + customBorderColor = copy_src.customBorderColor; + format = copy_src.format; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSamplerCustomBorderColorCreateInfoEXT& safe_VkSamplerCustomBorderColorCreateInfoEXT::operator=( + const safe_VkSamplerCustomBorderColorCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + customBorderColor = copy_src.customBorderColor; + format = copy_src.format; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSamplerCustomBorderColorCreateInfoEXT::~safe_VkSamplerCustomBorderColorCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkSamplerCustomBorderColorCreateInfoEXT::initialize(const VkSamplerCustomBorderColorCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + customBorderColor = in_struct->customBorderColor; + format = in_struct->format; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSamplerCustomBorderColorCreateInfoEXT::initialize(const safe_VkSamplerCustomBorderColorCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + customBorderColor = copy_src->customBorderColor; + format = copy_src->format; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT( + const VkPhysicalDeviceCustomBorderColorPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), maxCustomBorderColorSamplers(in_struct->maxCustomBorderColorSamplers) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT), pNext(nullptr), maxCustomBorderColorSamplers() {} + +safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT( + const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT& copy_src) { + sType = copy_src.sType; + maxCustomBorderColorSamplers = copy_src.maxCustomBorderColorSamplers; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT& safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::operator=( + const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxCustomBorderColorSamplers = copy_src.maxCustomBorderColorSamplers; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::~safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::initialize( + const VkPhysicalDeviceCustomBorderColorPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxCustomBorderColorSamplers = in_struct->maxCustomBorderColorSamplers; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::initialize( + const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxCustomBorderColorSamplers = copy_src->maxCustomBorderColorSamplers; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT( + const VkPhysicalDeviceCustomBorderColorFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + customBorderColors(in_struct->customBorderColors), + customBorderColorWithoutFormat(in_struct->customBorderColorWithoutFormat) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT), + pNext(nullptr), + customBorderColors(), + customBorderColorWithoutFormat() {} + +safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT( + const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT& copy_src) { + sType = copy_src.sType; + customBorderColors = copy_src.customBorderColors; + customBorderColorWithoutFormat = copy_src.customBorderColorWithoutFormat; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT& safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::operator=( + const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + customBorderColors = copy_src.customBorderColors; + customBorderColorWithoutFormat = copy_src.customBorderColorWithoutFormat; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::~safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::initialize(const VkPhysicalDeviceCustomBorderColorFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + customBorderColors = in_struct->customBorderColors; + customBorderColorWithoutFormat = in_struct->customBorderColorWithoutFormat; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::initialize( + const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + customBorderColors = copy_src->customBorderColors; + customBorderColorWithoutFormat = copy_src->customBorderColorWithoutFormat; + pNext = SafePnextCopy(copy_src->pNext); +} +#ifdef VK_USE_PLATFORM_METAL_EXT + +safe_VkExportMetalObjectCreateInfoEXT::safe_VkExportMetalObjectCreateInfoEXT(const VkExportMetalObjectCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), exportObjectType(in_struct->exportObjectType) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExportMetalObjectCreateInfoEXT::safe_VkExportMetalObjectCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT), pNext(nullptr), exportObjectType() {} + +safe_VkExportMetalObjectCreateInfoEXT::safe_VkExportMetalObjectCreateInfoEXT( + const safe_VkExportMetalObjectCreateInfoEXT& copy_src) { + sType = copy_src.sType; + exportObjectType = copy_src.exportObjectType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExportMetalObjectCreateInfoEXT& safe_VkExportMetalObjectCreateInfoEXT::operator=( + const safe_VkExportMetalObjectCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + exportObjectType = copy_src.exportObjectType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExportMetalObjectCreateInfoEXT::~safe_VkExportMetalObjectCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkExportMetalObjectCreateInfoEXT::initialize(const VkExportMetalObjectCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + exportObjectType = in_struct->exportObjectType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExportMetalObjectCreateInfoEXT::initialize(const safe_VkExportMetalObjectCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + exportObjectType = copy_src->exportObjectType; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExportMetalObjectsInfoEXT::safe_VkExportMetalObjectsInfoEXT(const VkExportMetalObjectsInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExportMetalObjectsInfoEXT::safe_VkExportMetalObjectsInfoEXT() + : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT), pNext(nullptr) {} + +safe_VkExportMetalObjectsInfoEXT::safe_VkExportMetalObjectsInfoEXT(const safe_VkExportMetalObjectsInfoEXT& copy_src) { + sType = copy_src.sType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExportMetalObjectsInfoEXT& safe_VkExportMetalObjectsInfoEXT::operator=(const safe_VkExportMetalObjectsInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExportMetalObjectsInfoEXT::~safe_VkExportMetalObjectsInfoEXT() { FreePnextChain(pNext); } + +void safe_VkExportMetalObjectsInfoEXT::initialize(const VkExportMetalObjectsInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExportMetalObjectsInfoEXT::initialize(const safe_VkExportMetalObjectsInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExportMetalDeviceInfoEXT::safe_VkExportMetalDeviceInfoEXT(const VkExportMetalDeviceInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), mtlDevice(in_struct->mtlDevice) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExportMetalDeviceInfoEXT::safe_VkExportMetalDeviceInfoEXT() + : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT), pNext(nullptr), mtlDevice() {} + +safe_VkExportMetalDeviceInfoEXT::safe_VkExportMetalDeviceInfoEXT(const safe_VkExportMetalDeviceInfoEXT& copy_src) { + sType = copy_src.sType; + mtlDevice = copy_src.mtlDevice; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExportMetalDeviceInfoEXT& safe_VkExportMetalDeviceInfoEXT::operator=(const safe_VkExportMetalDeviceInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + mtlDevice = copy_src.mtlDevice; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExportMetalDeviceInfoEXT::~safe_VkExportMetalDeviceInfoEXT() { FreePnextChain(pNext); } + +void safe_VkExportMetalDeviceInfoEXT::initialize(const VkExportMetalDeviceInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + mtlDevice = in_struct->mtlDevice; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExportMetalDeviceInfoEXT::initialize(const safe_VkExportMetalDeviceInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + mtlDevice = copy_src->mtlDevice; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExportMetalCommandQueueInfoEXT::safe_VkExportMetalCommandQueueInfoEXT(const VkExportMetalCommandQueueInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), queue(in_struct->queue), mtlCommandQueue(in_struct->mtlCommandQueue) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExportMetalCommandQueueInfoEXT::safe_VkExportMetalCommandQueueInfoEXT() + : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT), pNext(nullptr), queue(), mtlCommandQueue() {} + +safe_VkExportMetalCommandQueueInfoEXT::safe_VkExportMetalCommandQueueInfoEXT( + const safe_VkExportMetalCommandQueueInfoEXT& copy_src) { + sType = copy_src.sType; + queue = copy_src.queue; + mtlCommandQueue = copy_src.mtlCommandQueue; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExportMetalCommandQueueInfoEXT& safe_VkExportMetalCommandQueueInfoEXT::operator=( + const safe_VkExportMetalCommandQueueInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + queue = copy_src.queue; + mtlCommandQueue = copy_src.mtlCommandQueue; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExportMetalCommandQueueInfoEXT::~safe_VkExportMetalCommandQueueInfoEXT() { FreePnextChain(pNext); } + +void safe_VkExportMetalCommandQueueInfoEXT::initialize(const VkExportMetalCommandQueueInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + queue = in_struct->queue; + mtlCommandQueue = in_struct->mtlCommandQueue; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExportMetalCommandQueueInfoEXT::initialize(const safe_VkExportMetalCommandQueueInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + queue = copy_src->queue; + mtlCommandQueue = copy_src->mtlCommandQueue; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExportMetalBufferInfoEXT::safe_VkExportMetalBufferInfoEXT(const VkExportMetalBufferInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), memory(in_struct->memory), mtlBuffer(in_struct->mtlBuffer) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExportMetalBufferInfoEXT::safe_VkExportMetalBufferInfoEXT() + : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT), pNext(nullptr), memory(), mtlBuffer() {} + +safe_VkExportMetalBufferInfoEXT::safe_VkExportMetalBufferInfoEXT(const safe_VkExportMetalBufferInfoEXT& copy_src) { + sType = copy_src.sType; + memory = copy_src.memory; + mtlBuffer = copy_src.mtlBuffer; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExportMetalBufferInfoEXT& safe_VkExportMetalBufferInfoEXT::operator=(const safe_VkExportMetalBufferInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memory = copy_src.memory; + mtlBuffer = copy_src.mtlBuffer; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExportMetalBufferInfoEXT::~safe_VkExportMetalBufferInfoEXT() { FreePnextChain(pNext); } + +void safe_VkExportMetalBufferInfoEXT::initialize(const VkExportMetalBufferInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memory = in_struct->memory; + mtlBuffer = in_struct->mtlBuffer; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExportMetalBufferInfoEXT::initialize(const safe_VkExportMetalBufferInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memory = copy_src->memory; + mtlBuffer = copy_src->mtlBuffer; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImportMetalBufferInfoEXT::safe_VkImportMetalBufferInfoEXT(const VkImportMetalBufferInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), mtlBuffer(in_struct->mtlBuffer) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImportMetalBufferInfoEXT::safe_VkImportMetalBufferInfoEXT() + : sType(VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT), pNext(nullptr), mtlBuffer() {} + +safe_VkImportMetalBufferInfoEXT::safe_VkImportMetalBufferInfoEXT(const safe_VkImportMetalBufferInfoEXT& copy_src) { + sType = copy_src.sType; + mtlBuffer = copy_src.mtlBuffer; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImportMetalBufferInfoEXT& safe_VkImportMetalBufferInfoEXT::operator=(const safe_VkImportMetalBufferInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + mtlBuffer = copy_src.mtlBuffer; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImportMetalBufferInfoEXT::~safe_VkImportMetalBufferInfoEXT() { FreePnextChain(pNext); } + +void safe_VkImportMetalBufferInfoEXT::initialize(const VkImportMetalBufferInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + mtlBuffer = in_struct->mtlBuffer; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImportMetalBufferInfoEXT::initialize(const safe_VkImportMetalBufferInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + mtlBuffer = copy_src->mtlBuffer; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExportMetalTextureInfoEXT::safe_VkExportMetalTextureInfoEXT(const VkExportMetalTextureInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + image(in_struct->image), + imageView(in_struct->imageView), + bufferView(in_struct->bufferView), + plane(in_struct->plane), + mtlTexture(in_struct->mtlTexture) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExportMetalTextureInfoEXT::safe_VkExportMetalTextureInfoEXT() + : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT), + pNext(nullptr), + image(), + imageView(), + bufferView(), + plane(), + mtlTexture() {} + +safe_VkExportMetalTextureInfoEXT::safe_VkExportMetalTextureInfoEXT(const safe_VkExportMetalTextureInfoEXT& copy_src) { + sType = copy_src.sType; + image = copy_src.image; + imageView = copy_src.imageView; + bufferView = copy_src.bufferView; + plane = copy_src.plane; + mtlTexture = copy_src.mtlTexture; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExportMetalTextureInfoEXT& safe_VkExportMetalTextureInfoEXT::operator=(const safe_VkExportMetalTextureInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + image = copy_src.image; + imageView = copy_src.imageView; + bufferView = copy_src.bufferView; + plane = copy_src.plane; + mtlTexture = copy_src.mtlTexture; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExportMetalTextureInfoEXT::~safe_VkExportMetalTextureInfoEXT() { FreePnextChain(pNext); } + +void safe_VkExportMetalTextureInfoEXT::initialize(const VkExportMetalTextureInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + image = in_struct->image; + imageView = in_struct->imageView; + bufferView = in_struct->bufferView; + plane = in_struct->plane; + mtlTexture = in_struct->mtlTexture; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExportMetalTextureInfoEXT::initialize(const safe_VkExportMetalTextureInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + image = copy_src->image; + imageView = copy_src->imageView; + bufferView = copy_src->bufferView; + plane = copy_src->plane; + mtlTexture = copy_src->mtlTexture; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImportMetalTextureInfoEXT::safe_VkImportMetalTextureInfoEXT(const VkImportMetalTextureInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), plane(in_struct->plane), mtlTexture(in_struct->mtlTexture) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImportMetalTextureInfoEXT::safe_VkImportMetalTextureInfoEXT() + : sType(VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT), pNext(nullptr), plane(), mtlTexture() {} + +safe_VkImportMetalTextureInfoEXT::safe_VkImportMetalTextureInfoEXT(const safe_VkImportMetalTextureInfoEXT& copy_src) { + sType = copy_src.sType; + plane = copy_src.plane; + mtlTexture = copy_src.mtlTexture; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImportMetalTextureInfoEXT& safe_VkImportMetalTextureInfoEXT::operator=(const safe_VkImportMetalTextureInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + plane = copy_src.plane; + mtlTexture = copy_src.mtlTexture; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImportMetalTextureInfoEXT::~safe_VkImportMetalTextureInfoEXT() { FreePnextChain(pNext); } + +void safe_VkImportMetalTextureInfoEXT::initialize(const VkImportMetalTextureInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + plane = in_struct->plane; + mtlTexture = in_struct->mtlTexture; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImportMetalTextureInfoEXT::initialize(const safe_VkImportMetalTextureInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + plane = copy_src->plane; + mtlTexture = copy_src->mtlTexture; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExportMetalIOSurfaceInfoEXT::safe_VkExportMetalIOSurfaceInfoEXT(const VkExportMetalIOSurfaceInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), image(in_struct->image), ioSurface(in_struct->ioSurface) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExportMetalIOSurfaceInfoEXT::safe_VkExportMetalIOSurfaceInfoEXT() + : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT), pNext(nullptr), image(), ioSurface() {} + +safe_VkExportMetalIOSurfaceInfoEXT::safe_VkExportMetalIOSurfaceInfoEXT(const safe_VkExportMetalIOSurfaceInfoEXT& copy_src) { + sType = copy_src.sType; + image = copy_src.image; + ioSurface = copy_src.ioSurface; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExportMetalIOSurfaceInfoEXT& safe_VkExportMetalIOSurfaceInfoEXT::operator=( + const safe_VkExportMetalIOSurfaceInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + image = copy_src.image; + ioSurface = copy_src.ioSurface; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExportMetalIOSurfaceInfoEXT::~safe_VkExportMetalIOSurfaceInfoEXT() { FreePnextChain(pNext); } + +void safe_VkExportMetalIOSurfaceInfoEXT::initialize(const VkExportMetalIOSurfaceInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + image = in_struct->image; + ioSurface = in_struct->ioSurface; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExportMetalIOSurfaceInfoEXT::initialize(const safe_VkExportMetalIOSurfaceInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + image = copy_src->image; + ioSurface = copy_src->ioSurface; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImportMetalIOSurfaceInfoEXT::safe_VkImportMetalIOSurfaceInfoEXT(const VkImportMetalIOSurfaceInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), ioSurface(in_struct->ioSurface) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImportMetalIOSurfaceInfoEXT::safe_VkImportMetalIOSurfaceInfoEXT() + : sType(VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT), pNext(nullptr), ioSurface() {} + +safe_VkImportMetalIOSurfaceInfoEXT::safe_VkImportMetalIOSurfaceInfoEXT(const safe_VkImportMetalIOSurfaceInfoEXT& copy_src) { + sType = copy_src.sType; + ioSurface = copy_src.ioSurface; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImportMetalIOSurfaceInfoEXT& safe_VkImportMetalIOSurfaceInfoEXT::operator=( + const safe_VkImportMetalIOSurfaceInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + ioSurface = copy_src.ioSurface; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImportMetalIOSurfaceInfoEXT::~safe_VkImportMetalIOSurfaceInfoEXT() { FreePnextChain(pNext); } + +void safe_VkImportMetalIOSurfaceInfoEXT::initialize(const VkImportMetalIOSurfaceInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + ioSurface = in_struct->ioSurface; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImportMetalIOSurfaceInfoEXT::initialize(const safe_VkImportMetalIOSurfaceInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + ioSurface = copy_src->ioSurface; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExportMetalSharedEventInfoEXT::safe_VkExportMetalSharedEventInfoEXT(const VkExportMetalSharedEventInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), semaphore(in_struct->semaphore), event(in_struct->event), mtlSharedEvent(in_struct->mtlSharedEvent) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExportMetalSharedEventInfoEXT::safe_VkExportMetalSharedEventInfoEXT() + : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT), pNext(nullptr), semaphore(), event(), mtlSharedEvent() {} + +safe_VkExportMetalSharedEventInfoEXT::safe_VkExportMetalSharedEventInfoEXT(const safe_VkExportMetalSharedEventInfoEXT& copy_src) { + sType = copy_src.sType; + semaphore = copy_src.semaphore; + event = copy_src.event; + mtlSharedEvent = copy_src.mtlSharedEvent; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExportMetalSharedEventInfoEXT& safe_VkExportMetalSharedEventInfoEXT::operator=( + const safe_VkExportMetalSharedEventInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + semaphore = copy_src.semaphore; + event = copy_src.event; + mtlSharedEvent = copy_src.mtlSharedEvent; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExportMetalSharedEventInfoEXT::~safe_VkExportMetalSharedEventInfoEXT() { FreePnextChain(pNext); } + +void safe_VkExportMetalSharedEventInfoEXT::initialize(const VkExportMetalSharedEventInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + semaphore = in_struct->semaphore; + event = in_struct->event; + mtlSharedEvent = in_struct->mtlSharedEvent; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExportMetalSharedEventInfoEXT::initialize(const safe_VkExportMetalSharedEventInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + semaphore = copy_src->semaphore; + event = copy_src->event; + mtlSharedEvent = copy_src->mtlSharedEvent; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImportMetalSharedEventInfoEXT::safe_VkImportMetalSharedEventInfoEXT(const VkImportMetalSharedEventInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), mtlSharedEvent(in_struct->mtlSharedEvent) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImportMetalSharedEventInfoEXT::safe_VkImportMetalSharedEventInfoEXT() + : sType(VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT), pNext(nullptr), mtlSharedEvent() {} + +safe_VkImportMetalSharedEventInfoEXT::safe_VkImportMetalSharedEventInfoEXT(const safe_VkImportMetalSharedEventInfoEXT& copy_src) { + sType = copy_src.sType; + mtlSharedEvent = copy_src.mtlSharedEvent; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImportMetalSharedEventInfoEXT& safe_VkImportMetalSharedEventInfoEXT::operator=( + const safe_VkImportMetalSharedEventInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + mtlSharedEvent = copy_src.mtlSharedEvent; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImportMetalSharedEventInfoEXT::~safe_VkImportMetalSharedEventInfoEXT() { FreePnextChain(pNext); } + +void safe_VkImportMetalSharedEventInfoEXT::initialize(const VkImportMetalSharedEventInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + mtlSharedEvent = in_struct->mtlSharedEvent; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImportMetalSharedEventInfoEXT::initialize(const safe_VkImportMetalSharedEventInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + mtlSharedEvent = copy_src->mtlSharedEvent; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_METAL_EXT + +safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT::safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT( + const VkPhysicalDeviceDescriptorBufferPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + combinedImageSamplerDescriptorSingleArray(in_struct->combinedImageSamplerDescriptorSingleArray), + bufferlessPushDescriptors(in_struct->bufferlessPushDescriptors), + allowSamplerImageViewPostSubmitCreation(in_struct->allowSamplerImageViewPostSubmitCreation), + descriptorBufferOffsetAlignment(in_struct->descriptorBufferOffsetAlignment), + maxDescriptorBufferBindings(in_struct->maxDescriptorBufferBindings), + maxResourceDescriptorBufferBindings(in_struct->maxResourceDescriptorBufferBindings), + maxSamplerDescriptorBufferBindings(in_struct->maxSamplerDescriptorBufferBindings), + maxEmbeddedImmutableSamplerBindings(in_struct->maxEmbeddedImmutableSamplerBindings), + maxEmbeddedImmutableSamplers(in_struct->maxEmbeddedImmutableSamplers), + bufferCaptureReplayDescriptorDataSize(in_struct->bufferCaptureReplayDescriptorDataSize), + imageCaptureReplayDescriptorDataSize(in_struct->imageCaptureReplayDescriptorDataSize), + imageViewCaptureReplayDescriptorDataSize(in_struct->imageViewCaptureReplayDescriptorDataSize), + samplerCaptureReplayDescriptorDataSize(in_struct->samplerCaptureReplayDescriptorDataSize), + accelerationStructureCaptureReplayDescriptorDataSize(in_struct->accelerationStructureCaptureReplayDescriptorDataSize), + samplerDescriptorSize(in_struct->samplerDescriptorSize), + combinedImageSamplerDescriptorSize(in_struct->combinedImageSamplerDescriptorSize), + sampledImageDescriptorSize(in_struct->sampledImageDescriptorSize), + storageImageDescriptorSize(in_struct->storageImageDescriptorSize), + uniformTexelBufferDescriptorSize(in_struct->uniformTexelBufferDescriptorSize), + robustUniformTexelBufferDescriptorSize(in_struct->robustUniformTexelBufferDescriptorSize), + storageTexelBufferDescriptorSize(in_struct->storageTexelBufferDescriptorSize), + robustStorageTexelBufferDescriptorSize(in_struct->robustStorageTexelBufferDescriptorSize), + uniformBufferDescriptorSize(in_struct->uniformBufferDescriptorSize), + robustUniformBufferDescriptorSize(in_struct->robustUniformBufferDescriptorSize), + storageBufferDescriptorSize(in_struct->storageBufferDescriptorSize), + robustStorageBufferDescriptorSize(in_struct->robustStorageBufferDescriptorSize), + inputAttachmentDescriptorSize(in_struct->inputAttachmentDescriptorSize), + accelerationStructureDescriptorSize(in_struct->accelerationStructureDescriptorSize), + maxSamplerDescriptorBufferRange(in_struct->maxSamplerDescriptorBufferRange), + maxResourceDescriptorBufferRange(in_struct->maxResourceDescriptorBufferRange), + samplerDescriptorBufferAddressSpaceSize(in_struct->samplerDescriptorBufferAddressSpaceSize), + resourceDescriptorBufferAddressSpaceSize(in_struct->resourceDescriptorBufferAddressSpaceSize), + descriptorBufferAddressSpaceSize(in_struct->descriptorBufferAddressSpaceSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT::safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT), + pNext(nullptr), + combinedImageSamplerDescriptorSingleArray(), + bufferlessPushDescriptors(), + allowSamplerImageViewPostSubmitCreation(), + descriptorBufferOffsetAlignment(), + maxDescriptorBufferBindings(), + maxResourceDescriptorBufferBindings(), + maxSamplerDescriptorBufferBindings(), + maxEmbeddedImmutableSamplerBindings(), + maxEmbeddedImmutableSamplers(), + bufferCaptureReplayDescriptorDataSize(), + imageCaptureReplayDescriptorDataSize(), + imageViewCaptureReplayDescriptorDataSize(), + samplerCaptureReplayDescriptorDataSize(), + accelerationStructureCaptureReplayDescriptorDataSize(), + samplerDescriptorSize(), + combinedImageSamplerDescriptorSize(), + sampledImageDescriptorSize(), + storageImageDescriptorSize(), + uniformTexelBufferDescriptorSize(), + robustUniformTexelBufferDescriptorSize(), + storageTexelBufferDescriptorSize(), + robustStorageTexelBufferDescriptorSize(), + uniformBufferDescriptorSize(), + robustUniformBufferDescriptorSize(), + storageBufferDescriptorSize(), + robustStorageBufferDescriptorSize(), + inputAttachmentDescriptorSize(), + accelerationStructureDescriptorSize(), + maxSamplerDescriptorBufferRange(), + maxResourceDescriptorBufferRange(), + samplerDescriptorBufferAddressSpaceSize(), + resourceDescriptorBufferAddressSpaceSize(), + descriptorBufferAddressSpaceSize() {} + +safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT::safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT( + const safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT& copy_src) { + sType = copy_src.sType; + combinedImageSamplerDescriptorSingleArray = copy_src.combinedImageSamplerDescriptorSingleArray; + bufferlessPushDescriptors = copy_src.bufferlessPushDescriptors; + allowSamplerImageViewPostSubmitCreation = copy_src.allowSamplerImageViewPostSubmitCreation; + descriptorBufferOffsetAlignment = copy_src.descriptorBufferOffsetAlignment; + maxDescriptorBufferBindings = copy_src.maxDescriptorBufferBindings; + maxResourceDescriptorBufferBindings = copy_src.maxResourceDescriptorBufferBindings; + maxSamplerDescriptorBufferBindings = copy_src.maxSamplerDescriptorBufferBindings; + maxEmbeddedImmutableSamplerBindings = copy_src.maxEmbeddedImmutableSamplerBindings; + maxEmbeddedImmutableSamplers = copy_src.maxEmbeddedImmutableSamplers; + bufferCaptureReplayDescriptorDataSize = copy_src.bufferCaptureReplayDescriptorDataSize; + imageCaptureReplayDescriptorDataSize = copy_src.imageCaptureReplayDescriptorDataSize; + imageViewCaptureReplayDescriptorDataSize = copy_src.imageViewCaptureReplayDescriptorDataSize; + samplerCaptureReplayDescriptorDataSize = copy_src.samplerCaptureReplayDescriptorDataSize; + accelerationStructureCaptureReplayDescriptorDataSize = copy_src.accelerationStructureCaptureReplayDescriptorDataSize; + samplerDescriptorSize = copy_src.samplerDescriptorSize; + combinedImageSamplerDescriptorSize = copy_src.combinedImageSamplerDescriptorSize; + sampledImageDescriptorSize = copy_src.sampledImageDescriptorSize; + storageImageDescriptorSize = copy_src.storageImageDescriptorSize; + uniformTexelBufferDescriptorSize = copy_src.uniformTexelBufferDescriptorSize; + robustUniformTexelBufferDescriptorSize = copy_src.robustUniformTexelBufferDescriptorSize; + storageTexelBufferDescriptorSize = copy_src.storageTexelBufferDescriptorSize; + robustStorageTexelBufferDescriptorSize = copy_src.robustStorageTexelBufferDescriptorSize; + uniformBufferDescriptorSize = copy_src.uniformBufferDescriptorSize; + robustUniformBufferDescriptorSize = copy_src.robustUniformBufferDescriptorSize; + storageBufferDescriptorSize = copy_src.storageBufferDescriptorSize; + robustStorageBufferDescriptorSize = copy_src.robustStorageBufferDescriptorSize; + inputAttachmentDescriptorSize = copy_src.inputAttachmentDescriptorSize; + accelerationStructureDescriptorSize = copy_src.accelerationStructureDescriptorSize; + maxSamplerDescriptorBufferRange = copy_src.maxSamplerDescriptorBufferRange; + maxResourceDescriptorBufferRange = copy_src.maxResourceDescriptorBufferRange; + samplerDescriptorBufferAddressSpaceSize = copy_src.samplerDescriptorBufferAddressSpaceSize; + resourceDescriptorBufferAddressSpaceSize = copy_src.resourceDescriptorBufferAddressSpaceSize; + descriptorBufferAddressSpaceSize = copy_src.descriptorBufferAddressSpaceSize; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT& safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT::operator=( + const safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + combinedImageSamplerDescriptorSingleArray = copy_src.combinedImageSamplerDescriptorSingleArray; + bufferlessPushDescriptors = copy_src.bufferlessPushDescriptors; + allowSamplerImageViewPostSubmitCreation = copy_src.allowSamplerImageViewPostSubmitCreation; + descriptorBufferOffsetAlignment = copy_src.descriptorBufferOffsetAlignment; + maxDescriptorBufferBindings = copy_src.maxDescriptorBufferBindings; + maxResourceDescriptorBufferBindings = copy_src.maxResourceDescriptorBufferBindings; + maxSamplerDescriptorBufferBindings = copy_src.maxSamplerDescriptorBufferBindings; + maxEmbeddedImmutableSamplerBindings = copy_src.maxEmbeddedImmutableSamplerBindings; + maxEmbeddedImmutableSamplers = copy_src.maxEmbeddedImmutableSamplers; + bufferCaptureReplayDescriptorDataSize = copy_src.bufferCaptureReplayDescriptorDataSize; + imageCaptureReplayDescriptorDataSize = copy_src.imageCaptureReplayDescriptorDataSize; + imageViewCaptureReplayDescriptorDataSize = copy_src.imageViewCaptureReplayDescriptorDataSize; + samplerCaptureReplayDescriptorDataSize = copy_src.samplerCaptureReplayDescriptorDataSize; + accelerationStructureCaptureReplayDescriptorDataSize = copy_src.accelerationStructureCaptureReplayDescriptorDataSize; + samplerDescriptorSize = copy_src.samplerDescriptorSize; + combinedImageSamplerDescriptorSize = copy_src.combinedImageSamplerDescriptorSize; + sampledImageDescriptorSize = copy_src.sampledImageDescriptorSize; + storageImageDescriptorSize = copy_src.storageImageDescriptorSize; + uniformTexelBufferDescriptorSize = copy_src.uniformTexelBufferDescriptorSize; + robustUniformTexelBufferDescriptorSize = copy_src.robustUniformTexelBufferDescriptorSize; + storageTexelBufferDescriptorSize = copy_src.storageTexelBufferDescriptorSize; + robustStorageTexelBufferDescriptorSize = copy_src.robustStorageTexelBufferDescriptorSize; + uniformBufferDescriptorSize = copy_src.uniformBufferDescriptorSize; + robustUniformBufferDescriptorSize = copy_src.robustUniformBufferDescriptorSize; + storageBufferDescriptorSize = copy_src.storageBufferDescriptorSize; + robustStorageBufferDescriptorSize = copy_src.robustStorageBufferDescriptorSize; + inputAttachmentDescriptorSize = copy_src.inputAttachmentDescriptorSize; + accelerationStructureDescriptorSize = copy_src.accelerationStructureDescriptorSize; + maxSamplerDescriptorBufferRange = copy_src.maxSamplerDescriptorBufferRange; + maxResourceDescriptorBufferRange = copy_src.maxResourceDescriptorBufferRange; + samplerDescriptorBufferAddressSpaceSize = copy_src.samplerDescriptorBufferAddressSpaceSize; + resourceDescriptorBufferAddressSpaceSize = copy_src.resourceDescriptorBufferAddressSpaceSize; + descriptorBufferAddressSpaceSize = copy_src.descriptorBufferAddressSpaceSize; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT::~safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT::initialize(const VkPhysicalDeviceDescriptorBufferPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + combinedImageSamplerDescriptorSingleArray = in_struct->combinedImageSamplerDescriptorSingleArray; + bufferlessPushDescriptors = in_struct->bufferlessPushDescriptors; + allowSamplerImageViewPostSubmitCreation = in_struct->allowSamplerImageViewPostSubmitCreation; + descriptorBufferOffsetAlignment = in_struct->descriptorBufferOffsetAlignment; + maxDescriptorBufferBindings = in_struct->maxDescriptorBufferBindings; + maxResourceDescriptorBufferBindings = in_struct->maxResourceDescriptorBufferBindings; + maxSamplerDescriptorBufferBindings = in_struct->maxSamplerDescriptorBufferBindings; + maxEmbeddedImmutableSamplerBindings = in_struct->maxEmbeddedImmutableSamplerBindings; + maxEmbeddedImmutableSamplers = in_struct->maxEmbeddedImmutableSamplers; + bufferCaptureReplayDescriptorDataSize = in_struct->bufferCaptureReplayDescriptorDataSize; + imageCaptureReplayDescriptorDataSize = in_struct->imageCaptureReplayDescriptorDataSize; + imageViewCaptureReplayDescriptorDataSize = in_struct->imageViewCaptureReplayDescriptorDataSize; + samplerCaptureReplayDescriptorDataSize = in_struct->samplerCaptureReplayDescriptorDataSize; + accelerationStructureCaptureReplayDescriptorDataSize = in_struct->accelerationStructureCaptureReplayDescriptorDataSize; + samplerDescriptorSize = in_struct->samplerDescriptorSize; + combinedImageSamplerDescriptorSize = in_struct->combinedImageSamplerDescriptorSize; + sampledImageDescriptorSize = in_struct->sampledImageDescriptorSize; + storageImageDescriptorSize = in_struct->storageImageDescriptorSize; + uniformTexelBufferDescriptorSize = in_struct->uniformTexelBufferDescriptorSize; + robustUniformTexelBufferDescriptorSize = in_struct->robustUniformTexelBufferDescriptorSize; + storageTexelBufferDescriptorSize = in_struct->storageTexelBufferDescriptorSize; + robustStorageTexelBufferDescriptorSize = in_struct->robustStorageTexelBufferDescriptorSize; + uniformBufferDescriptorSize = in_struct->uniformBufferDescriptorSize; + robustUniformBufferDescriptorSize = in_struct->robustUniformBufferDescriptorSize; + storageBufferDescriptorSize = in_struct->storageBufferDescriptorSize; + robustStorageBufferDescriptorSize = in_struct->robustStorageBufferDescriptorSize; + inputAttachmentDescriptorSize = in_struct->inputAttachmentDescriptorSize; + accelerationStructureDescriptorSize = in_struct->accelerationStructureDescriptorSize; + maxSamplerDescriptorBufferRange = in_struct->maxSamplerDescriptorBufferRange; + maxResourceDescriptorBufferRange = in_struct->maxResourceDescriptorBufferRange; + samplerDescriptorBufferAddressSpaceSize = in_struct->samplerDescriptorBufferAddressSpaceSize; + resourceDescriptorBufferAddressSpaceSize = in_struct->resourceDescriptorBufferAddressSpaceSize; + descriptorBufferAddressSpaceSize = in_struct->descriptorBufferAddressSpaceSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT::initialize( + const safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + combinedImageSamplerDescriptorSingleArray = copy_src->combinedImageSamplerDescriptorSingleArray; + bufferlessPushDescriptors = copy_src->bufferlessPushDescriptors; + allowSamplerImageViewPostSubmitCreation = copy_src->allowSamplerImageViewPostSubmitCreation; + descriptorBufferOffsetAlignment = copy_src->descriptorBufferOffsetAlignment; + maxDescriptorBufferBindings = copy_src->maxDescriptorBufferBindings; + maxResourceDescriptorBufferBindings = copy_src->maxResourceDescriptorBufferBindings; + maxSamplerDescriptorBufferBindings = copy_src->maxSamplerDescriptorBufferBindings; + maxEmbeddedImmutableSamplerBindings = copy_src->maxEmbeddedImmutableSamplerBindings; + maxEmbeddedImmutableSamplers = copy_src->maxEmbeddedImmutableSamplers; + bufferCaptureReplayDescriptorDataSize = copy_src->bufferCaptureReplayDescriptorDataSize; + imageCaptureReplayDescriptorDataSize = copy_src->imageCaptureReplayDescriptorDataSize; + imageViewCaptureReplayDescriptorDataSize = copy_src->imageViewCaptureReplayDescriptorDataSize; + samplerCaptureReplayDescriptorDataSize = copy_src->samplerCaptureReplayDescriptorDataSize; + accelerationStructureCaptureReplayDescriptorDataSize = copy_src->accelerationStructureCaptureReplayDescriptorDataSize; + samplerDescriptorSize = copy_src->samplerDescriptorSize; + combinedImageSamplerDescriptorSize = copy_src->combinedImageSamplerDescriptorSize; + sampledImageDescriptorSize = copy_src->sampledImageDescriptorSize; + storageImageDescriptorSize = copy_src->storageImageDescriptorSize; + uniformTexelBufferDescriptorSize = copy_src->uniformTexelBufferDescriptorSize; + robustUniformTexelBufferDescriptorSize = copy_src->robustUniformTexelBufferDescriptorSize; + storageTexelBufferDescriptorSize = copy_src->storageTexelBufferDescriptorSize; + robustStorageTexelBufferDescriptorSize = copy_src->robustStorageTexelBufferDescriptorSize; + uniformBufferDescriptorSize = copy_src->uniformBufferDescriptorSize; + robustUniformBufferDescriptorSize = copy_src->robustUniformBufferDescriptorSize; + storageBufferDescriptorSize = copy_src->storageBufferDescriptorSize; + robustStorageBufferDescriptorSize = copy_src->robustStorageBufferDescriptorSize; + inputAttachmentDescriptorSize = copy_src->inputAttachmentDescriptorSize; + accelerationStructureDescriptorSize = copy_src->accelerationStructureDescriptorSize; + maxSamplerDescriptorBufferRange = copy_src->maxSamplerDescriptorBufferRange; + maxResourceDescriptorBufferRange = copy_src->maxResourceDescriptorBufferRange; + samplerDescriptorBufferAddressSpaceSize = copy_src->samplerDescriptorBufferAddressSpaceSize; + resourceDescriptorBufferAddressSpaceSize = copy_src->resourceDescriptorBufferAddressSpaceSize; + descriptorBufferAddressSpaceSize = copy_src->descriptorBufferAddressSpaceSize; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT( + const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + combinedImageSamplerDensityMapDescriptorSize(in_struct->combinedImageSamplerDensityMapDescriptorSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT), + pNext(nullptr), + combinedImageSamplerDensityMapDescriptorSize() {} + +safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT( + const safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& copy_src) { + sType = copy_src.sType; + combinedImageSamplerDensityMapDescriptorSize = copy_src.combinedImageSamplerDensityMapDescriptorSize; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& +safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::operator=( + const safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + combinedImageSamplerDensityMapDescriptorSize = copy_src.combinedImageSamplerDensityMapDescriptorSize; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::~safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::initialize( + const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + combinedImageSamplerDensityMapDescriptorSize = in_struct->combinedImageSamplerDensityMapDescriptorSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::initialize( + const safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + combinedImageSamplerDensityMapDescriptorSize = copy_src->combinedImageSamplerDensityMapDescriptorSize; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT::safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT( + const VkPhysicalDeviceDescriptorBufferFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + descriptorBuffer(in_struct->descriptorBuffer), + descriptorBufferCaptureReplay(in_struct->descriptorBufferCaptureReplay), + descriptorBufferImageLayoutIgnored(in_struct->descriptorBufferImageLayoutIgnored), + descriptorBufferPushDescriptors(in_struct->descriptorBufferPushDescriptors) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT::safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT), + pNext(nullptr), + descriptorBuffer(), + descriptorBufferCaptureReplay(), + descriptorBufferImageLayoutIgnored(), + descriptorBufferPushDescriptors() {} + +safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT::safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT( + const safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT& copy_src) { + sType = copy_src.sType; + descriptorBuffer = copy_src.descriptorBuffer; + descriptorBufferCaptureReplay = copy_src.descriptorBufferCaptureReplay; + descriptorBufferImageLayoutIgnored = copy_src.descriptorBufferImageLayoutIgnored; + descriptorBufferPushDescriptors = copy_src.descriptorBufferPushDescriptors; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT& safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT::operator=( + const safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + descriptorBuffer = copy_src.descriptorBuffer; + descriptorBufferCaptureReplay = copy_src.descriptorBufferCaptureReplay; + descriptorBufferImageLayoutIgnored = copy_src.descriptorBufferImageLayoutIgnored; + descriptorBufferPushDescriptors = copy_src.descriptorBufferPushDescriptors; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT::~safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT::initialize(const VkPhysicalDeviceDescriptorBufferFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + descriptorBuffer = in_struct->descriptorBuffer; + descriptorBufferCaptureReplay = in_struct->descriptorBufferCaptureReplay; + descriptorBufferImageLayoutIgnored = in_struct->descriptorBufferImageLayoutIgnored; + descriptorBufferPushDescriptors = in_struct->descriptorBufferPushDescriptors; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT::initialize(const safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + descriptorBuffer = copy_src->descriptorBuffer; + descriptorBufferCaptureReplay = copy_src->descriptorBufferCaptureReplay; + descriptorBufferImageLayoutIgnored = copy_src->descriptorBufferImageLayoutIgnored; + descriptorBufferPushDescriptors = copy_src->descriptorBufferPushDescriptors; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDescriptorAddressInfoEXT::safe_VkDescriptorAddressInfoEXT(const VkDescriptorAddressInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), address(in_struct->address), range(in_struct->range), format(in_struct->format) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDescriptorAddressInfoEXT::safe_VkDescriptorAddressInfoEXT() + : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT), pNext(nullptr), address(), range(), format() {} + +safe_VkDescriptorAddressInfoEXT::safe_VkDescriptorAddressInfoEXT(const safe_VkDescriptorAddressInfoEXT& copy_src) { + sType = copy_src.sType; + address = copy_src.address; + range = copy_src.range; + format = copy_src.format; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDescriptorAddressInfoEXT& safe_VkDescriptorAddressInfoEXT::operator=(const safe_VkDescriptorAddressInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + address = copy_src.address; + range = copy_src.range; + format = copy_src.format; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDescriptorAddressInfoEXT::~safe_VkDescriptorAddressInfoEXT() { FreePnextChain(pNext); } + +void safe_VkDescriptorAddressInfoEXT::initialize(const VkDescriptorAddressInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + address = in_struct->address; + range = in_struct->range; + format = in_struct->format; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDescriptorAddressInfoEXT::initialize(const safe_VkDescriptorAddressInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + address = copy_src->address; + range = copy_src->range; + format = copy_src->format; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDescriptorBufferBindingInfoEXT::safe_VkDescriptorBufferBindingInfoEXT(const VkDescriptorBufferBindingInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), address(in_struct->address), usage(in_struct->usage) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDescriptorBufferBindingInfoEXT::safe_VkDescriptorBufferBindingInfoEXT() + : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT), pNext(nullptr), address(), usage() {} + +safe_VkDescriptorBufferBindingInfoEXT::safe_VkDescriptorBufferBindingInfoEXT( + const safe_VkDescriptorBufferBindingInfoEXT& copy_src) { + sType = copy_src.sType; + address = copy_src.address; + usage = copy_src.usage; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDescriptorBufferBindingInfoEXT& safe_VkDescriptorBufferBindingInfoEXT::operator=( + const safe_VkDescriptorBufferBindingInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + address = copy_src.address; + usage = copy_src.usage; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDescriptorBufferBindingInfoEXT::~safe_VkDescriptorBufferBindingInfoEXT() { FreePnextChain(pNext); } + +void safe_VkDescriptorBufferBindingInfoEXT::initialize(const VkDescriptorBufferBindingInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + address = in_struct->address; + usage = in_struct->usage; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDescriptorBufferBindingInfoEXT::initialize(const safe_VkDescriptorBufferBindingInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + address = copy_src->address; + usage = copy_src->usage; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT::safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT( + const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), buffer(in_struct->buffer) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT::safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT() + : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT), pNext(nullptr), buffer() {} + +safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT::safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT( + const safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT& copy_src) { + sType = copy_src.sType; + buffer = copy_src.buffer; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT& safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT::operator=( + const safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + buffer = copy_src.buffer; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT::~safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT() { + FreePnextChain(pNext); +} + +void safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT::initialize( + const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + buffer = in_struct->buffer; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT::initialize( + const safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + buffer = copy_src->buffer; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDescriptorGetInfoEXT::safe_VkDescriptorGetInfoEXT(const VkDescriptorGetInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), type(in_struct->type), data(&in_struct->data, in_struct->type) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDescriptorGetInfoEXT::safe_VkDescriptorGetInfoEXT() + : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT), pNext(nullptr), type() {} + +safe_VkDescriptorGetInfoEXT::safe_VkDescriptorGetInfoEXT(const safe_VkDescriptorGetInfoEXT& copy_src) { + sType = copy_src.sType; + type = copy_src.type; + data.initialize(©_src.data); + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDescriptorGetInfoEXT& safe_VkDescriptorGetInfoEXT::operator=(const safe_VkDescriptorGetInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + type = copy_src.type; + data.initialize(©_src.data); + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDescriptorGetInfoEXT::~safe_VkDescriptorGetInfoEXT() { FreePnextChain(pNext); } + +void safe_VkDescriptorGetInfoEXT::initialize(const VkDescriptorGetInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + type = in_struct->type; + data.initialize(&in_struct->data, in_struct->type); + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDescriptorGetInfoEXT::initialize(const safe_VkDescriptorGetInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + type = copy_src->type; + data.initialize(©_src->data); + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBufferCaptureDescriptorDataInfoEXT::safe_VkBufferCaptureDescriptorDataInfoEXT( + const VkBufferCaptureDescriptorDataInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), buffer(in_struct->buffer) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBufferCaptureDescriptorDataInfoEXT::safe_VkBufferCaptureDescriptorDataInfoEXT() + : sType(VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT), pNext(nullptr), buffer() {} + +safe_VkBufferCaptureDescriptorDataInfoEXT::safe_VkBufferCaptureDescriptorDataInfoEXT( + const safe_VkBufferCaptureDescriptorDataInfoEXT& copy_src) { + sType = copy_src.sType; + buffer = copy_src.buffer; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBufferCaptureDescriptorDataInfoEXT& safe_VkBufferCaptureDescriptorDataInfoEXT::operator=( + const safe_VkBufferCaptureDescriptorDataInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + buffer = copy_src.buffer; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBufferCaptureDescriptorDataInfoEXT::~safe_VkBufferCaptureDescriptorDataInfoEXT() { FreePnextChain(pNext); } + +void safe_VkBufferCaptureDescriptorDataInfoEXT::initialize(const VkBufferCaptureDescriptorDataInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + buffer = in_struct->buffer; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBufferCaptureDescriptorDataInfoEXT::initialize(const safe_VkBufferCaptureDescriptorDataInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + buffer = copy_src->buffer; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImageCaptureDescriptorDataInfoEXT::safe_VkImageCaptureDescriptorDataInfoEXT( + const VkImageCaptureDescriptorDataInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), image(in_struct->image) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageCaptureDescriptorDataInfoEXT::safe_VkImageCaptureDescriptorDataInfoEXT() + : sType(VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT), pNext(nullptr), image() {} + +safe_VkImageCaptureDescriptorDataInfoEXT::safe_VkImageCaptureDescriptorDataInfoEXT( + const safe_VkImageCaptureDescriptorDataInfoEXT& copy_src) { + sType = copy_src.sType; + image = copy_src.image; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageCaptureDescriptorDataInfoEXT& safe_VkImageCaptureDescriptorDataInfoEXT::operator=( + const safe_VkImageCaptureDescriptorDataInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + image = copy_src.image; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageCaptureDescriptorDataInfoEXT::~safe_VkImageCaptureDescriptorDataInfoEXT() { FreePnextChain(pNext); } + +void safe_VkImageCaptureDescriptorDataInfoEXT::initialize(const VkImageCaptureDescriptorDataInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + image = in_struct->image; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageCaptureDescriptorDataInfoEXT::initialize(const safe_VkImageCaptureDescriptorDataInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + image = copy_src->image; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImageViewCaptureDescriptorDataInfoEXT::safe_VkImageViewCaptureDescriptorDataInfoEXT( + const VkImageViewCaptureDescriptorDataInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), imageView(in_struct->imageView) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageViewCaptureDescriptorDataInfoEXT::safe_VkImageViewCaptureDescriptorDataInfoEXT() + : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT), pNext(nullptr), imageView() {} + +safe_VkImageViewCaptureDescriptorDataInfoEXT::safe_VkImageViewCaptureDescriptorDataInfoEXT( + const safe_VkImageViewCaptureDescriptorDataInfoEXT& copy_src) { + sType = copy_src.sType; + imageView = copy_src.imageView; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageViewCaptureDescriptorDataInfoEXT& safe_VkImageViewCaptureDescriptorDataInfoEXT::operator=( + const safe_VkImageViewCaptureDescriptorDataInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + imageView = copy_src.imageView; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageViewCaptureDescriptorDataInfoEXT::~safe_VkImageViewCaptureDescriptorDataInfoEXT() { FreePnextChain(pNext); } + +void safe_VkImageViewCaptureDescriptorDataInfoEXT::initialize(const VkImageViewCaptureDescriptorDataInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + imageView = in_struct->imageView; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageViewCaptureDescriptorDataInfoEXT::initialize(const safe_VkImageViewCaptureDescriptorDataInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + imageView = copy_src->imageView; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSamplerCaptureDescriptorDataInfoEXT::safe_VkSamplerCaptureDescriptorDataInfoEXT( + const VkSamplerCaptureDescriptorDataInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), sampler(in_struct->sampler) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSamplerCaptureDescriptorDataInfoEXT::safe_VkSamplerCaptureDescriptorDataInfoEXT() + : sType(VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT), pNext(nullptr), sampler() {} + +safe_VkSamplerCaptureDescriptorDataInfoEXT::safe_VkSamplerCaptureDescriptorDataInfoEXT( + const safe_VkSamplerCaptureDescriptorDataInfoEXT& copy_src) { + sType = copy_src.sType; + sampler = copy_src.sampler; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSamplerCaptureDescriptorDataInfoEXT& safe_VkSamplerCaptureDescriptorDataInfoEXT::operator=( + const safe_VkSamplerCaptureDescriptorDataInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + sampler = copy_src.sampler; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSamplerCaptureDescriptorDataInfoEXT::~safe_VkSamplerCaptureDescriptorDataInfoEXT() { FreePnextChain(pNext); } + +void safe_VkSamplerCaptureDescriptorDataInfoEXT::initialize(const VkSamplerCaptureDescriptorDataInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + sampler = in_struct->sampler; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSamplerCaptureDescriptorDataInfoEXT::initialize(const safe_VkSamplerCaptureDescriptorDataInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + sampler = copy_src->sampler; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT::safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT( + const VkOpaqueCaptureDescriptorDataCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), opaqueCaptureDescriptorData(in_struct->opaqueCaptureDescriptorData) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT::safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT), + pNext(nullptr), + opaqueCaptureDescriptorData(nullptr) {} + +safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT::safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT( + const safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT& copy_src) { + sType = copy_src.sType; + opaqueCaptureDescriptorData = copy_src.opaqueCaptureDescriptorData; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT& safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT::operator=( + const safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + opaqueCaptureDescriptorData = copy_src.opaqueCaptureDescriptorData; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT::~safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT::initialize(const VkOpaqueCaptureDescriptorDataCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + opaqueCaptureDescriptorData = in_struct->opaqueCaptureDescriptorData; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT::initialize(const safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + opaqueCaptureDescriptorData = copy_src->opaqueCaptureDescriptorData; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT::safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT( + const VkAccelerationStructureCaptureDescriptorDataInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + accelerationStructure(in_struct->accelerationStructure), + accelerationStructureNV(in_struct->accelerationStructureNV) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT::safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT), + pNext(nullptr), + accelerationStructure(), + accelerationStructureNV() {} + +safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT::safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT( + const safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT& copy_src) { + sType = copy_src.sType; + accelerationStructure = copy_src.accelerationStructure; + accelerationStructureNV = copy_src.accelerationStructureNV; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT& safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT::operator=( + const safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + accelerationStructure = copy_src.accelerationStructure; + accelerationStructureNV = copy_src.accelerationStructureNV; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT::~safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT() { + FreePnextChain(pNext); +} + +void safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT::initialize( + const VkAccelerationStructureCaptureDescriptorDataInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + accelerationStructure = in_struct->accelerationStructure; + accelerationStructureNV = in_struct->accelerationStructureNV; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT::initialize( + const safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + accelerationStructure = copy_src->accelerationStructure; + accelerationStructureNV = copy_src->accelerationStructureNV; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT( + const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), graphicsPipelineLibrary(in_struct->graphicsPipelineLibrary) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT), pNext(nullptr), graphicsPipelineLibrary() {} + +safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT( + const safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& copy_src) { + sType = copy_src.sType; + graphicsPipelineLibrary = copy_src.graphicsPipelineLibrary; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::operator=( + const safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + graphicsPipelineLibrary = copy_src.graphicsPipelineLibrary; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::~safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::initialize( + const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + graphicsPipelineLibrary = in_struct->graphicsPipelineLibrary; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::initialize( + const safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + graphicsPipelineLibrary = copy_src->graphicsPipelineLibrary; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT( + const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + graphicsPipelineLibraryFastLinking(in_struct->graphicsPipelineLibraryFastLinking), + graphicsPipelineLibraryIndependentInterpolationDecoration( + in_struct->graphicsPipelineLibraryIndependentInterpolationDecoration) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT), + pNext(nullptr), + graphicsPipelineLibraryFastLinking(), + graphicsPipelineLibraryIndependentInterpolationDecoration() {} + +safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT( + const safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& copy_src) { + sType = copy_src.sType; + graphicsPipelineLibraryFastLinking = copy_src.graphicsPipelineLibraryFastLinking; + graphicsPipelineLibraryIndependentInterpolationDecoration = copy_src.graphicsPipelineLibraryIndependentInterpolationDecoration; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::operator=( + const safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + graphicsPipelineLibraryFastLinking = copy_src.graphicsPipelineLibraryFastLinking; + graphicsPipelineLibraryIndependentInterpolationDecoration = copy_src.graphicsPipelineLibraryIndependentInterpolationDecoration; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::~safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::initialize( + const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + graphicsPipelineLibraryFastLinking = in_struct->graphicsPipelineLibraryFastLinking; + graphicsPipelineLibraryIndependentInterpolationDecoration = + in_struct->graphicsPipelineLibraryIndependentInterpolationDecoration; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::initialize( + const safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + graphicsPipelineLibraryFastLinking = copy_src->graphicsPipelineLibraryFastLinking; + graphicsPipelineLibraryIndependentInterpolationDecoration = copy_src->graphicsPipelineLibraryIndependentInterpolationDecoration; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkGraphicsPipelineLibraryCreateInfoEXT::safe_VkGraphicsPipelineLibraryCreateInfoEXT( + const VkGraphicsPipelineLibraryCreateInfoEXT* 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_VkGraphicsPipelineLibraryCreateInfoEXT::safe_VkGraphicsPipelineLibraryCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT), pNext(nullptr), flags() {} + +safe_VkGraphicsPipelineLibraryCreateInfoEXT::safe_VkGraphicsPipelineLibraryCreateInfoEXT( + const safe_VkGraphicsPipelineLibraryCreateInfoEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkGraphicsPipelineLibraryCreateInfoEXT& safe_VkGraphicsPipelineLibraryCreateInfoEXT::operator=( + const safe_VkGraphicsPipelineLibraryCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkGraphicsPipelineLibraryCreateInfoEXT::~safe_VkGraphicsPipelineLibraryCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkGraphicsPipelineLibraryCreateInfoEXT::initialize(const VkGraphicsPipelineLibraryCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkGraphicsPipelineLibraryCreateInfoEXT::initialize(const safe_VkGraphicsPipelineLibraryCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT( + const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), ycbcr2plane444Formats(in_struct->ycbcr2plane444Formats) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT), pNext(nullptr), ycbcr2plane444Formats() {} + +safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT( + const safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& copy_src) { + sType = copy_src.sType; + ycbcr2plane444Formats = copy_src.ycbcr2plane444Formats; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::operator=( + const safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + ycbcr2plane444Formats = copy_src.ycbcr2plane444Formats; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::~safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::initialize( + const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + ycbcr2plane444Formats = in_struct->ycbcr2plane444Formats; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::initialize( + const safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + ycbcr2plane444Formats = copy_src->ycbcr2plane444Formats; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT( + const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), fragmentDensityMapDeferred(in_struct->fragmentDensityMapDeferred) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT), pNext(nullptr), fragmentDensityMapDeferred() {} + +safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT( + const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& copy_src) { + sType = copy_src.sType; + fragmentDensityMapDeferred = copy_src.fragmentDensityMapDeferred; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::operator=( + const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + fragmentDensityMapDeferred = copy_src.fragmentDensityMapDeferred; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::~safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::initialize( + const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + fragmentDensityMapDeferred = in_struct->fragmentDensityMapDeferred; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::initialize( + const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + fragmentDensityMapDeferred = copy_src->fragmentDensityMapDeferred; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT( + const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + subsampledLoads(in_struct->subsampledLoads), + subsampledCoarseReconstructionEarlyAccess(in_struct->subsampledCoarseReconstructionEarlyAccess), + maxSubsampledArrayLayers(in_struct->maxSubsampledArrayLayers), + maxDescriptorSetSubsampledSamplers(in_struct->maxDescriptorSetSubsampledSamplers) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT), + pNext(nullptr), + subsampledLoads(), + subsampledCoarseReconstructionEarlyAccess(), + maxSubsampledArrayLayers(), + maxDescriptorSetSubsampledSamplers() {} + +safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT( + const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& copy_src) { + sType = copy_src.sType; + subsampledLoads = copy_src.subsampledLoads; + subsampledCoarseReconstructionEarlyAccess = copy_src.subsampledCoarseReconstructionEarlyAccess; + maxSubsampledArrayLayers = copy_src.maxSubsampledArrayLayers; + maxDescriptorSetSubsampledSamplers = copy_src.maxDescriptorSetSubsampledSamplers; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::operator=( + const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + subsampledLoads = copy_src.subsampledLoads; + subsampledCoarseReconstructionEarlyAccess = copy_src.subsampledCoarseReconstructionEarlyAccess; + maxSubsampledArrayLayers = copy_src.maxSubsampledArrayLayers; + maxDescriptorSetSubsampledSamplers = copy_src.maxDescriptorSetSubsampledSamplers; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::~safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::initialize( + const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + subsampledLoads = in_struct->subsampledLoads; + subsampledCoarseReconstructionEarlyAccess = in_struct->subsampledCoarseReconstructionEarlyAccess; + maxSubsampledArrayLayers = in_struct->maxSubsampledArrayLayers; + maxDescriptorSetSubsampledSamplers = in_struct->maxDescriptorSetSubsampledSamplers; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::initialize( + const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + subsampledLoads = copy_src->subsampledLoads; + subsampledCoarseReconstructionEarlyAccess = copy_src->subsampledCoarseReconstructionEarlyAccess; + maxSubsampledArrayLayers = copy_src->maxSubsampledArrayLayers; + maxDescriptorSetSubsampledSamplers = copy_src->maxDescriptorSetSubsampledSamplers; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT::safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT( + const VkPhysicalDeviceImageCompressionControlFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), imageCompressionControl(in_struct->imageCompressionControl) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT::safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT), pNext(nullptr), imageCompressionControl() {} + +safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT::safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT( + const safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT& copy_src) { + sType = copy_src.sType; + imageCompressionControl = copy_src.imageCompressionControl; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT& safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT::operator=( + const safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + imageCompressionControl = copy_src.imageCompressionControl; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT::~safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT::initialize( + const VkPhysicalDeviceImageCompressionControlFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + imageCompressionControl = in_struct->imageCompressionControl; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT::initialize( + const safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + imageCompressionControl = copy_src->imageCompressionControl; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImageCompressionControlEXT::safe_VkImageCompressionControlEXT(const VkImageCompressionControlEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + compressionControlPlaneCount(in_struct->compressionControlPlaneCount), + pFixedRateFlags(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pFixedRateFlags) { + pFixedRateFlags = new VkImageCompressionFixedRateFlagsEXT[in_struct->compressionControlPlaneCount]; + memcpy((void*)pFixedRateFlags, (void*)in_struct->pFixedRateFlags, + sizeof(VkImageCompressionFixedRateFlagsEXT) * in_struct->compressionControlPlaneCount); + } +} + +safe_VkImageCompressionControlEXT::safe_VkImageCompressionControlEXT() + : sType(VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT), + pNext(nullptr), + flags(), + compressionControlPlaneCount(), + pFixedRateFlags(nullptr) {} + +safe_VkImageCompressionControlEXT::safe_VkImageCompressionControlEXT(const safe_VkImageCompressionControlEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + compressionControlPlaneCount = copy_src.compressionControlPlaneCount; + pFixedRateFlags = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pFixedRateFlags) { + pFixedRateFlags = new VkImageCompressionFixedRateFlagsEXT[copy_src.compressionControlPlaneCount]; + memcpy((void*)pFixedRateFlags, (void*)copy_src.pFixedRateFlags, + sizeof(VkImageCompressionFixedRateFlagsEXT) * copy_src.compressionControlPlaneCount); + } +} + +safe_VkImageCompressionControlEXT& safe_VkImageCompressionControlEXT::operator=(const safe_VkImageCompressionControlEXT& copy_src) { + if (©_src == this) return *this; + + if (pFixedRateFlags) delete[] pFixedRateFlags; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + compressionControlPlaneCount = copy_src.compressionControlPlaneCount; + pFixedRateFlags = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pFixedRateFlags) { + pFixedRateFlags = new VkImageCompressionFixedRateFlagsEXT[copy_src.compressionControlPlaneCount]; + memcpy((void*)pFixedRateFlags, (void*)copy_src.pFixedRateFlags, + sizeof(VkImageCompressionFixedRateFlagsEXT) * copy_src.compressionControlPlaneCount); + } + + return *this; +} + +safe_VkImageCompressionControlEXT::~safe_VkImageCompressionControlEXT() { + if (pFixedRateFlags) delete[] pFixedRateFlags; + FreePnextChain(pNext); +} + +void safe_VkImageCompressionControlEXT::initialize(const VkImageCompressionControlEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pFixedRateFlags) delete[] pFixedRateFlags; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + compressionControlPlaneCount = in_struct->compressionControlPlaneCount; + pFixedRateFlags = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pFixedRateFlags) { + pFixedRateFlags = new VkImageCompressionFixedRateFlagsEXT[in_struct->compressionControlPlaneCount]; + memcpy((void*)pFixedRateFlags, (void*)in_struct->pFixedRateFlags, + sizeof(VkImageCompressionFixedRateFlagsEXT) * in_struct->compressionControlPlaneCount); + } +} + +void safe_VkImageCompressionControlEXT::initialize(const safe_VkImageCompressionControlEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + compressionControlPlaneCount = copy_src->compressionControlPlaneCount; + pFixedRateFlags = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pFixedRateFlags) { + pFixedRateFlags = new VkImageCompressionFixedRateFlagsEXT[copy_src->compressionControlPlaneCount]; + memcpy((void*)pFixedRateFlags, (void*)copy_src->pFixedRateFlags, + sizeof(VkImageCompressionFixedRateFlagsEXT) * copy_src->compressionControlPlaneCount); + } +} + +safe_VkImageCompressionPropertiesEXT::safe_VkImageCompressionPropertiesEXT(const VkImageCompressionPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + imageCompressionFlags(in_struct->imageCompressionFlags), + imageCompressionFixedRateFlags(in_struct->imageCompressionFixedRateFlags) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageCompressionPropertiesEXT::safe_VkImageCompressionPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT), + pNext(nullptr), + imageCompressionFlags(), + imageCompressionFixedRateFlags() {} + +safe_VkImageCompressionPropertiesEXT::safe_VkImageCompressionPropertiesEXT(const safe_VkImageCompressionPropertiesEXT& copy_src) { + sType = copy_src.sType; + imageCompressionFlags = copy_src.imageCompressionFlags; + imageCompressionFixedRateFlags = copy_src.imageCompressionFixedRateFlags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageCompressionPropertiesEXT& safe_VkImageCompressionPropertiesEXT::operator=( + const safe_VkImageCompressionPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + imageCompressionFlags = copy_src.imageCompressionFlags; + imageCompressionFixedRateFlags = copy_src.imageCompressionFixedRateFlags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageCompressionPropertiesEXT::~safe_VkImageCompressionPropertiesEXT() { FreePnextChain(pNext); } + +void safe_VkImageCompressionPropertiesEXT::initialize(const VkImageCompressionPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + imageCompressionFlags = in_struct->imageCompressionFlags; + imageCompressionFixedRateFlags = in_struct->imageCompressionFixedRateFlags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageCompressionPropertiesEXT::initialize(const safe_VkImageCompressionPropertiesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + imageCompressionFlags = copy_src->imageCompressionFlags; + imageCompressionFixedRateFlags = copy_src->imageCompressionFixedRateFlags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT( + const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), attachmentFeedbackLoopLayout(in_struct->attachmentFeedbackLoopLayout) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT), + pNext(nullptr), + attachmentFeedbackLoopLayout() {} + +safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT( + const safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& copy_src) { + sType = copy_src.sType; + attachmentFeedbackLoopLayout = copy_src.attachmentFeedbackLoopLayout; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& +safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::operator=( + const safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + attachmentFeedbackLoopLayout = copy_src.attachmentFeedbackLoopLayout; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::~safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::initialize( + const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + attachmentFeedbackLoopLayout = in_struct->attachmentFeedbackLoopLayout; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::initialize( + const safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + attachmentFeedbackLoopLayout = copy_src->attachmentFeedbackLoopLayout; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevice4444FormatsFeaturesEXT::safe_VkPhysicalDevice4444FormatsFeaturesEXT( + const VkPhysicalDevice4444FormatsFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), formatA4R4G4B4(in_struct->formatA4R4G4B4), formatA4B4G4R4(in_struct->formatA4B4G4R4) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevice4444FormatsFeaturesEXT::safe_VkPhysicalDevice4444FormatsFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT), pNext(nullptr), formatA4R4G4B4(), formatA4B4G4R4() {} + +safe_VkPhysicalDevice4444FormatsFeaturesEXT::safe_VkPhysicalDevice4444FormatsFeaturesEXT( + const safe_VkPhysicalDevice4444FormatsFeaturesEXT& copy_src) { + sType = copy_src.sType; + formatA4R4G4B4 = copy_src.formatA4R4G4B4; + formatA4B4G4R4 = copy_src.formatA4B4G4R4; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevice4444FormatsFeaturesEXT& safe_VkPhysicalDevice4444FormatsFeaturesEXT::operator=( + const safe_VkPhysicalDevice4444FormatsFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + formatA4R4G4B4 = copy_src.formatA4R4G4B4; + formatA4B4G4R4 = copy_src.formatA4B4G4R4; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevice4444FormatsFeaturesEXT::~safe_VkPhysicalDevice4444FormatsFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevice4444FormatsFeaturesEXT::initialize(const VkPhysicalDevice4444FormatsFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + formatA4R4G4B4 = in_struct->formatA4R4G4B4; + formatA4B4G4R4 = in_struct->formatA4B4G4R4; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevice4444FormatsFeaturesEXT::initialize(const safe_VkPhysicalDevice4444FormatsFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + formatA4R4G4B4 = copy_src->formatA4R4G4B4; + formatA4B4G4R4 = copy_src->formatA4B4G4R4; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceFaultFeaturesEXT::safe_VkPhysicalDeviceFaultFeaturesEXT(const VkPhysicalDeviceFaultFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), deviceFault(in_struct->deviceFault), deviceFaultVendorBinary(in_struct->deviceFaultVendorBinary) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceFaultFeaturesEXT::safe_VkPhysicalDeviceFaultFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT), pNext(nullptr), deviceFault(), deviceFaultVendorBinary() {} + +safe_VkPhysicalDeviceFaultFeaturesEXT::safe_VkPhysicalDeviceFaultFeaturesEXT( + const safe_VkPhysicalDeviceFaultFeaturesEXT& copy_src) { + sType = copy_src.sType; + deviceFault = copy_src.deviceFault; + deviceFaultVendorBinary = copy_src.deviceFaultVendorBinary; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceFaultFeaturesEXT& safe_VkPhysicalDeviceFaultFeaturesEXT::operator=( + const safe_VkPhysicalDeviceFaultFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + deviceFault = copy_src.deviceFault; + deviceFaultVendorBinary = copy_src.deviceFaultVendorBinary; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceFaultFeaturesEXT::~safe_VkPhysicalDeviceFaultFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceFaultFeaturesEXT::initialize(const VkPhysicalDeviceFaultFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + deviceFault = in_struct->deviceFault; + deviceFaultVendorBinary = in_struct->deviceFaultVendorBinary; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceFaultFeaturesEXT::initialize(const safe_VkPhysicalDeviceFaultFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + deviceFault = copy_src->deviceFault; + deviceFaultVendorBinary = copy_src->deviceFaultVendorBinary; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDeviceFaultCountsEXT::safe_VkDeviceFaultCountsEXT(const VkDeviceFaultCountsEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + addressInfoCount(in_struct->addressInfoCount), + vendorInfoCount(in_struct->vendorInfoCount), + vendorBinarySize(in_struct->vendorBinarySize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDeviceFaultCountsEXT::safe_VkDeviceFaultCountsEXT() + : sType(VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT), pNext(nullptr), addressInfoCount(), vendorInfoCount(), vendorBinarySize() {} + +safe_VkDeviceFaultCountsEXT::safe_VkDeviceFaultCountsEXT(const safe_VkDeviceFaultCountsEXT& copy_src) { + sType = copy_src.sType; + addressInfoCount = copy_src.addressInfoCount; + vendorInfoCount = copy_src.vendorInfoCount; + vendorBinarySize = copy_src.vendorBinarySize; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDeviceFaultCountsEXT& safe_VkDeviceFaultCountsEXT::operator=(const safe_VkDeviceFaultCountsEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + addressInfoCount = copy_src.addressInfoCount; + vendorInfoCount = copy_src.vendorInfoCount; + vendorBinarySize = copy_src.vendorBinarySize; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDeviceFaultCountsEXT::~safe_VkDeviceFaultCountsEXT() { FreePnextChain(pNext); } + +void safe_VkDeviceFaultCountsEXT::initialize(const VkDeviceFaultCountsEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + addressInfoCount = in_struct->addressInfoCount; + vendorInfoCount = in_struct->vendorInfoCount; + vendorBinarySize = in_struct->vendorBinarySize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDeviceFaultCountsEXT::initialize(const safe_VkDeviceFaultCountsEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + addressInfoCount = copy_src->addressInfoCount; + vendorInfoCount = copy_src->vendorInfoCount; + vendorBinarySize = copy_src->vendorBinarySize; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDeviceFaultInfoEXT::safe_VkDeviceFaultInfoEXT(const VkDeviceFaultInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pAddressInfos(nullptr), pVendorInfos(nullptr), pVendorBinaryData(in_struct->pVendorBinaryData) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = in_struct->description[i]; + } + + if (in_struct->pAddressInfos) { + pAddressInfos = new VkDeviceFaultAddressInfoEXT(*in_struct->pAddressInfos); + } + + if (in_struct->pVendorInfos) { + pVendorInfos = new VkDeviceFaultVendorInfoEXT(*in_struct->pVendorInfos); + } +} + +safe_VkDeviceFaultInfoEXT::safe_VkDeviceFaultInfoEXT() + : sType(VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT), + pNext(nullptr), + pAddressInfos(nullptr), + pVendorInfos(nullptr), + pVendorBinaryData(nullptr) {} + +safe_VkDeviceFaultInfoEXT::safe_VkDeviceFaultInfoEXT(const safe_VkDeviceFaultInfoEXT& copy_src) { + sType = copy_src.sType; + pAddressInfos = nullptr; + pVendorInfos = nullptr; + pVendorBinaryData = copy_src.pVendorBinaryData; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = copy_src.description[i]; + } + + if (copy_src.pAddressInfos) { + pAddressInfos = new VkDeviceFaultAddressInfoEXT(*copy_src.pAddressInfos); + } + + if (copy_src.pVendorInfos) { + pVendorInfos = new VkDeviceFaultVendorInfoEXT(*copy_src.pVendorInfos); + } +} + +safe_VkDeviceFaultInfoEXT& safe_VkDeviceFaultInfoEXT::operator=(const safe_VkDeviceFaultInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pAddressInfos) delete pAddressInfos; + if (pVendorInfos) delete pVendorInfos; + FreePnextChain(pNext); + + sType = copy_src.sType; + pAddressInfos = nullptr; + pVendorInfos = nullptr; + pVendorBinaryData = copy_src.pVendorBinaryData; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = copy_src.description[i]; + } + + if (copy_src.pAddressInfos) { + pAddressInfos = new VkDeviceFaultAddressInfoEXT(*copy_src.pAddressInfos); + } + + if (copy_src.pVendorInfos) { + pVendorInfos = new VkDeviceFaultVendorInfoEXT(*copy_src.pVendorInfos); + } + + return *this; +} + +safe_VkDeviceFaultInfoEXT::~safe_VkDeviceFaultInfoEXT() { + if (pAddressInfos) delete pAddressInfos; + if (pVendorInfos) delete pVendorInfos; + FreePnextChain(pNext); +} + +void safe_VkDeviceFaultInfoEXT::initialize(const VkDeviceFaultInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pAddressInfos) delete pAddressInfos; + if (pVendorInfos) delete pVendorInfos; + FreePnextChain(pNext); + sType = in_struct->sType; + pAddressInfos = nullptr; + pVendorInfos = nullptr; + pVendorBinaryData = in_struct->pVendorBinaryData; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = in_struct->description[i]; + } + + if (in_struct->pAddressInfos) { + pAddressInfos = new VkDeviceFaultAddressInfoEXT(*in_struct->pAddressInfos); + } + + if (in_struct->pVendorInfos) { + pVendorInfos = new VkDeviceFaultVendorInfoEXT(*in_struct->pVendorInfos); + } +} + +void safe_VkDeviceFaultInfoEXT::initialize(const safe_VkDeviceFaultInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pAddressInfos = nullptr; + pVendorInfos = nullptr; + pVendorBinaryData = copy_src->pVendorBinaryData; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) { + description[i] = copy_src->description[i]; + } + + if (copy_src->pAddressInfos) { + pAddressInfos = new VkDeviceFaultAddressInfoEXT(*copy_src->pAddressInfos); + } + + if (copy_src->pVendorInfos) { + pVendorInfos = new VkDeviceFaultVendorInfoEXT(*copy_src->pVendorInfos); + } +} + +safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT:: + safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT( + const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + rasterizationOrderColorAttachmentAccess(in_struct->rasterizationOrderColorAttachmentAccess), + rasterizationOrderDepthAttachmentAccess(in_struct->rasterizationOrderDepthAttachmentAccess), + rasterizationOrderStencilAttachmentAccess(in_struct->rasterizationOrderStencilAttachmentAccess) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT:: + safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT), + pNext(nullptr), + rasterizationOrderColorAttachmentAccess(), + rasterizationOrderDepthAttachmentAccess(), + rasterizationOrderStencilAttachmentAccess() {} + +safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT:: + safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT( + const safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& copy_src) { + sType = copy_src.sType; + rasterizationOrderColorAttachmentAccess = copy_src.rasterizationOrderColorAttachmentAccess; + rasterizationOrderDepthAttachmentAccess = copy_src.rasterizationOrderDepthAttachmentAccess; + rasterizationOrderStencilAttachmentAccess = copy_src.rasterizationOrderStencilAttachmentAccess; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& +safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::operator=( + const safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + rasterizationOrderColorAttachmentAccess = copy_src.rasterizationOrderColorAttachmentAccess; + rasterizationOrderDepthAttachmentAccess = copy_src.rasterizationOrderDepthAttachmentAccess; + rasterizationOrderStencilAttachmentAccess = copy_src.rasterizationOrderStencilAttachmentAccess; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT:: + ~safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::initialize( + const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + rasterizationOrderColorAttachmentAccess = in_struct->rasterizationOrderColorAttachmentAccess; + rasterizationOrderDepthAttachmentAccess = in_struct->rasterizationOrderDepthAttachmentAccess; + rasterizationOrderStencilAttachmentAccess = in_struct->rasterizationOrderStencilAttachmentAccess; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::initialize( + const safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + rasterizationOrderColorAttachmentAccess = copy_src->rasterizationOrderColorAttachmentAccess; + rasterizationOrderDepthAttachmentAccess = copy_src->rasterizationOrderDepthAttachmentAccess; + rasterizationOrderStencilAttachmentAccess = copy_src->rasterizationOrderStencilAttachmentAccess; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT::safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT( + const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), formatRgba10x6WithoutYCbCrSampler(in_struct->formatRgba10x6WithoutYCbCrSampler) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT::safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT), pNext(nullptr), formatRgba10x6WithoutYCbCrSampler() {} + +safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT::safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT( + const safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& copy_src) { + sType = copy_src.sType; + formatRgba10x6WithoutYCbCrSampler = copy_src.formatRgba10x6WithoutYCbCrSampler; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT::operator=( + const safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + formatRgba10x6WithoutYCbCrSampler = copy_src.formatRgba10x6WithoutYCbCrSampler; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT::~safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT::initialize(const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + formatRgba10x6WithoutYCbCrSampler = in_struct->formatRgba10x6WithoutYCbCrSampler; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT::initialize(const safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + formatRgba10x6WithoutYCbCrSampler = copy_src->formatRgba10x6WithoutYCbCrSampler; + pNext = SafePnextCopy(copy_src->pNext); +} +#ifdef VK_USE_PLATFORM_DIRECTFB_EXT + +safe_VkDirectFBSurfaceCreateInfoEXT::safe_VkDirectFBSurfaceCreateInfoEXT(const VkDirectFBSurfaceCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), dfb(nullptr), surface(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->dfb) { + dfb = new IDirectFB(*in_struct->dfb); + } + + if (in_struct->surface) { + surface = new IDirectFBSurface(*in_struct->surface); + } +} + +safe_VkDirectFBSurfaceCreateInfoEXT::safe_VkDirectFBSurfaceCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT), pNext(nullptr), flags(), dfb(nullptr), surface(nullptr) {} + +safe_VkDirectFBSurfaceCreateInfoEXT::safe_VkDirectFBSurfaceCreateInfoEXT(const safe_VkDirectFBSurfaceCreateInfoEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + dfb = nullptr; + surface = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.dfb) { + dfb = new IDirectFB(*copy_src.dfb); + } + + if (copy_src.surface) { + surface = new IDirectFBSurface(*copy_src.surface); + } +} + +safe_VkDirectFBSurfaceCreateInfoEXT& safe_VkDirectFBSurfaceCreateInfoEXT::operator=( + const safe_VkDirectFBSurfaceCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (dfb) delete dfb; + if (surface) delete surface; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + dfb = nullptr; + surface = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.dfb) { + dfb = new IDirectFB(*copy_src.dfb); + } + + if (copy_src.surface) { + surface = new IDirectFBSurface(*copy_src.surface); + } + + return *this; +} + +safe_VkDirectFBSurfaceCreateInfoEXT::~safe_VkDirectFBSurfaceCreateInfoEXT() { + if (dfb) delete dfb; + if (surface) delete surface; + FreePnextChain(pNext); +} + +void safe_VkDirectFBSurfaceCreateInfoEXT::initialize(const VkDirectFBSurfaceCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (dfb) delete dfb; + if (surface) delete surface; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + dfb = nullptr; + surface = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->dfb) { + dfb = new IDirectFB(*in_struct->dfb); + } + + if (in_struct->surface) { + surface = new IDirectFBSurface(*in_struct->surface); + } +} + +void safe_VkDirectFBSurfaceCreateInfoEXT::initialize(const safe_VkDirectFBSurfaceCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + dfb = nullptr; + surface = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->dfb) { + dfb = new IDirectFB(*copy_src->dfb); + } + + if (copy_src->surface) { + surface = new IDirectFBSurface(*copy_src->surface); + } +} +#endif // VK_USE_PLATFORM_DIRECTFB_EXT + +safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT::safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT( + const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), mutableDescriptorType(in_struct->mutableDescriptorType) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT::safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT), pNext(nullptr), mutableDescriptorType() {} + +safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT::safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT( + const safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT& copy_src) { + sType = copy_src.sType; + mutableDescriptorType = copy_src.mutableDescriptorType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT& safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT::operator=( + const safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + mutableDescriptorType = copy_src.mutableDescriptorType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT::~safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT::initialize( + const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + mutableDescriptorType = in_struct->mutableDescriptorType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT::initialize( + const safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + mutableDescriptorType = copy_src->mutableDescriptorType; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMutableDescriptorTypeListEXT::safe_VkMutableDescriptorTypeListEXT(const VkMutableDescriptorTypeListEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) + : descriptorTypeCount(in_struct->descriptorTypeCount), pDescriptorTypes(nullptr) { + if (in_struct->pDescriptorTypes) { + pDescriptorTypes = new VkDescriptorType[in_struct->descriptorTypeCount]; + memcpy((void*)pDescriptorTypes, (void*)in_struct->pDescriptorTypes, + sizeof(VkDescriptorType) * in_struct->descriptorTypeCount); + } +} + +safe_VkMutableDescriptorTypeListEXT::safe_VkMutableDescriptorTypeListEXT() : descriptorTypeCount(), pDescriptorTypes(nullptr) {} + +safe_VkMutableDescriptorTypeListEXT::safe_VkMutableDescriptorTypeListEXT(const safe_VkMutableDescriptorTypeListEXT& copy_src) { + descriptorTypeCount = copy_src.descriptorTypeCount; + pDescriptorTypes = nullptr; + + if (copy_src.pDescriptorTypes) { + pDescriptorTypes = new VkDescriptorType[copy_src.descriptorTypeCount]; + memcpy((void*)pDescriptorTypes, (void*)copy_src.pDescriptorTypes, sizeof(VkDescriptorType) * copy_src.descriptorTypeCount); + } +} + +safe_VkMutableDescriptorTypeListEXT& safe_VkMutableDescriptorTypeListEXT::operator=( + const safe_VkMutableDescriptorTypeListEXT& copy_src) { + if (©_src == this) return *this; + + if (pDescriptorTypes) delete[] pDescriptorTypes; + + descriptorTypeCount = copy_src.descriptorTypeCount; + pDescriptorTypes = nullptr; + + if (copy_src.pDescriptorTypes) { + pDescriptorTypes = new VkDescriptorType[copy_src.descriptorTypeCount]; + memcpy((void*)pDescriptorTypes, (void*)copy_src.pDescriptorTypes, sizeof(VkDescriptorType) * copy_src.descriptorTypeCount); + } + + return *this; +} + +safe_VkMutableDescriptorTypeListEXT::~safe_VkMutableDescriptorTypeListEXT() { + if (pDescriptorTypes) delete[] pDescriptorTypes; +} + +void safe_VkMutableDescriptorTypeListEXT::initialize(const VkMutableDescriptorTypeListEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDescriptorTypes) delete[] pDescriptorTypes; + descriptorTypeCount = in_struct->descriptorTypeCount; + pDescriptorTypes = nullptr; + + if (in_struct->pDescriptorTypes) { + pDescriptorTypes = new VkDescriptorType[in_struct->descriptorTypeCount]; + memcpy((void*)pDescriptorTypes, (void*)in_struct->pDescriptorTypes, + sizeof(VkDescriptorType) * in_struct->descriptorTypeCount); + } +} + +void safe_VkMutableDescriptorTypeListEXT::initialize(const safe_VkMutableDescriptorTypeListEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + descriptorTypeCount = copy_src->descriptorTypeCount; + pDescriptorTypes = nullptr; + + if (copy_src->pDescriptorTypes) { + pDescriptorTypes = new VkDescriptorType[copy_src->descriptorTypeCount]; + memcpy((void*)pDescriptorTypes, (void*)copy_src->pDescriptorTypes, + sizeof(VkDescriptorType) * copy_src->descriptorTypeCount); + } +} + +safe_VkMutableDescriptorTypeCreateInfoEXT::safe_VkMutableDescriptorTypeCreateInfoEXT( + const VkMutableDescriptorTypeCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + mutableDescriptorTypeListCount(in_struct->mutableDescriptorTypeListCount), + pMutableDescriptorTypeLists(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (mutableDescriptorTypeListCount && in_struct->pMutableDescriptorTypeLists) { + pMutableDescriptorTypeLists = new safe_VkMutableDescriptorTypeListEXT[mutableDescriptorTypeListCount]; + for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) { + pMutableDescriptorTypeLists[i].initialize(&in_struct->pMutableDescriptorTypeLists[i]); + } + } +} + +safe_VkMutableDescriptorTypeCreateInfoEXT::safe_VkMutableDescriptorTypeCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT), + pNext(nullptr), + mutableDescriptorTypeListCount(), + pMutableDescriptorTypeLists(nullptr) {} + +safe_VkMutableDescriptorTypeCreateInfoEXT::safe_VkMutableDescriptorTypeCreateInfoEXT( + const safe_VkMutableDescriptorTypeCreateInfoEXT& copy_src) { + sType = copy_src.sType; + mutableDescriptorTypeListCount = copy_src.mutableDescriptorTypeListCount; + pMutableDescriptorTypeLists = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (mutableDescriptorTypeListCount && copy_src.pMutableDescriptorTypeLists) { + pMutableDescriptorTypeLists = new safe_VkMutableDescriptorTypeListEXT[mutableDescriptorTypeListCount]; + for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) { + pMutableDescriptorTypeLists[i].initialize(©_src.pMutableDescriptorTypeLists[i]); + } + } +} + +safe_VkMutableDescriptorTypeCreateInfoEXT& safe_VkMutableDescriptorTypeCreateInfoEXT::operator=( + const safe_VkMutableDescriptorTypeCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pMutableDescriptorTypeLists) delete[] pMutableDescriptorTypeLists; + FreePnextChain(pNext); + + sType = copy_src.sType; + mutableDescriptorTypeListCount = copy_src.mutableDescriptorTypeListCount; + pMutableDescriptorTypeLists = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (mutableDescriptorTypeListCount && copy_src.pMutableDescriptorTypeLists) { + pMutableDescriptorTypeLists = new safe_VkMutableDescriptorTypeListEXT[mutableDescriptorTypeListCount]; + for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) { + pMutableDescriptorTypeLists[i].initialize(©_src.pMutableDescriptorTypeLists[i]); + } + } + + return *this; +} + +safe_VkMutableDescriptorTypeCreateInfoEXT::~safe_VkMutableDescriptorTypeCreateInfoEXT() { + if (pMutableDescriptorTypeLists) delete[] pMutableDescriptorTypeLists; + FreePnextChain(pNext); +} + +void safe_VkMutableDescriptorTypeCreateInfoEXT::initialize(const VkMutableDescriptorTypeCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pMutableDescriptorTypeLists) delete[] pMutableDescriptorTypeLists; + FreePnextChain(pNext); + sType = in_struct->sType; + mutableDescriptorTypeListCount = in_struct->mutableDescriptorTypeListCount; + pMutableDescriptorTypeLists = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (mutableDescriptorTypeListCount && in_struct->pMutableDescriptorTypeLists) { + pMutableDescriptorTypeLists = new safe_VkMutableDescriptorTypeListEXT[mutableDescriptorTypeListCount]; + for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) { + pMutableDescriptorTypeLists[i].initialize(&in_struct->pMutableDescriptorTypeLists[i]); + } + } +} + +void safe_VkMutableDescriptorTypeCreateInfoEXT::initialize(const safe_VkMutableDescriptorTypeCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + mutableDescriptorTypeListCount = copy_src->mutableDescriptorTypeListCount; + pMutableDescriptorTypeLists = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (mutableDescriptorTypeListCount && copy_src->pMutableDescriptorTypeLists) { + pMutableDescriptorTypeLists = new safe_VkMutableDescriptorTypeListEXT[mutableDescriptorTypeListCount]; + for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) { + pMutableDescriptorTypeLists[i].initialize(©_src->pMutableDescriptorTypeLists[i]); + } + } +} + +safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT( + const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), vertexInputDynamicState(in_struct->vertexInputDynamicState) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT), pNext(nullptr), vertexInputDynamicState() {} + +safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT( + const safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& copy_src) { + sType = copy_src.sType; + vertexInputDynamicState = copy_src.vertexInputDynamicState; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::operator=( + const safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + vertexInputDynamicState = copy_src.vertexInputDynamicState; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::~safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::initialize( + const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + vertexInputDynamicState = in_struct->vertexInputDynamicState; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::initialize( + const safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + vertexInputDynamicState = copy_src->vertexInputDynamicState; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVertexInputBindingDescription2EXT::safe_VkVertexInputBindingDescription2EXT( + const VkVertexInputBindingDescription2EXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + binding(in_struct->binding), + stride(in_struct->stride), + inputRate(in_struct->inputRate), + divisor(in_struct->divisor) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVertexInputBindingDescription2EXT::safe_VkVertexInputBindingDescription2EXT() + : sType(VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT), + pNext(nullptr), + binding(), + stride(), + inputRate(), + divisor() {} + +safe_VkVertexInputBindingDescription2EXT::safe_VkVertexInputBindingDescription2EXT( + const safe_VkVertexInputBindingDescription2EXT& copy_src) { + sType = copy_src.sType; + binding = copy_src.binding; + stride = copy_src.stride; + inputRate = copy_src.inputRate; + divisor = copy_src.divisor; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVertexInputBindingDescription2EXT& safe_VkVertexInputBindingDescription2EXT::operator=( + const safe_VkVertexInputBindingDescription2EXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + binding = copy_src.binding; + stride = copy_src.stride; + inputRate = copy_src.inputRate; + divisor = copy_src.divisor; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVertexInputBindingDescription2EXT::~safe_VkVertexInputBindingDescription2EXT() { FreePnextChain(pNext); } + +void safe_VkVertexInputBindingDescription2EXT::initialize(const VkVertexInputBindingDescription2EXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + binding = in_struct->binding; + stride = in_struct->stride; + inputRate = in_struct->inputRate; + divisor = in_struct->divisor; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVertexInputBindingDescription2EXT::initialize(const safe_VkVertexInputBindingDescription2EXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + binding = copy_src->binding; + stride = copy_src->stride; + inputRate = copy_src->inputRate; + divisor = copy_src->divisor; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVertexInputAttributeDescription2EXT::safe_VkVertexInputAttributeDescription2EXT( + const VkVertexInputAttributeDescription2EXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + location(in_struct->location), + binding(in_struct->binding), + format(in_struct->format), + offset(in_struct->offset) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVertexInputAttributeDescription2EXT::safe_VkVertexInputAttributeDescription2EXT() + : sType(VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT), + pNext(nullptr), + location(), + binding(), + format(), + offset() {} + +safe_VkVertexInputAttributeDescription2EXT::safe_VkVertexInputAttributeDescription2EXT( + const safe_VkVertexInputAttributeDescription2EXT& copy_src) { + sType = copy_src.sType; + location = copy_src.location; + binding = copy_src.binding; + format = copy_src.format; + offset = copy_src.offset; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVertexInputAttributeDescription2EXT& safe_VkVertexInputAttributeDescription2EXT::operator=( + const safe_VkVertexInputAttributeDescription2EXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + location = copy_src.location; + binding = copy_src.binding; + format = copy_src.format; + offset = copy_src.offset; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVertexInputAttributeDescription2EXT::~safe_VkVertexInputAttributeDescription2EXT() { FreePnextChain(pNext); } + +void safe_VkVertexInputAttributeDescription2EXT::initialize(const VkVertexInputAttributeDescription2EXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + location = in_struct->location; + binding = in_struct->binding; + format = in_struct->format; + offset = in_struct->offset; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVertexInputAttributeDescription2EXT::initialize(const safe_VkVertexInputAttributeDescription2EXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + location = copy_src->location; + binding = copy_src->binding; + format = copy_src->format; + offset = copy_src->offset; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDrmPropertiesEXT::safe_VkPhysicalDeviceDrmPropertiesEXT(const VkPhysicalDeviceDrmPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + hasPrimary(in_struct->hasPrimary), + hasRender(in_struct->hasRender), + primaryMajor(in_struct->primaryMajor), + primaryMinor(in_struct->primaryMinor), + renderMajor(in_struct->renderMajor), + renderMinor(in_struct->renderMinor) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDrmPropertiesEXT::safe_VkPhysicalDeviceDrmPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT), + pNext(nullptr), + hasPrimary(), + hasRender(), + primaryMajor(), + primaryMinor(), + renderMajor(), + renderMinor() {} + +safe_VkPhysicalDeviceDrmPropertiesEXT::safe_VkPhysicalDeviceDrmPropertiesEXT( + const safe_VkPhysicalDeviceDrmPropertiesEXT& copy_src) { + sType = copy_src.sType; + hasPrimary = copy_src.hasPrimary; + hasRender = copy_src.hasRender; + primaryMajor = copy_src.primaryMajor; + primaryMinor = copy_src.primaryMinor; + renderMajor = copy_src.renderMajor; + renderMinor = copy_src.renderMinor; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDrmPropertiesEXT& safe_VkPhysicalDeviceDrmPropertiesEXT::operator=( + const safe_VkPhysicalDeviceDrmPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + hasPrimary = copy_src.hasPrimary; + hasRender = copy_src.hasRender; + primaryMajor = copy_src.primaryMajor; + primaryMinor = copy_src.primaryMinor; + renderMajor = copy_src.renderMajor; + renderMinor = copy_src.renderMinor; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDrmPropertiesEXT::~safe_VkPhysicalDeviceDrmPropertiesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceDrmPropertiesEXT::initialize(const VkPhysicalDeviceDrmPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + hasPrimary = in_struct->hasPrimary; + hasRender = in_struct->hasRender; + primaryMajor = in_struct->primaryMajor; + primaryMinor = in_struct->primaryMinor; + renderMajor = in_struct->renderMajor; + renderMinor = in_struct->renderMinor; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDrmPropertiesEXT::initialize(const safe_VkPhysicalDeviceDrmPropertiesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + hasPrimary = copy_src->hasPrimary; + hasRender = copy_src->hasRender; + primaryMajor = copy_src->primaryMajor; + primaryMinor = copy_src->primaryMinor; + renderMajor = copy_src->renderMajor; + renderMinor = copy_src->renderMinor; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT::safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT( + const VkPhysicalDeviceAddressBindingReportFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), reportAddressBinding(in_struct->reportAddressBinding) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT::safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT), pNext(nullptr), reportAddressBinding() {} + +safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT::safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT( + const safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT& copy_src) { + sType = copy_src.sType; + reportAddressBinding = copy_src.reportAddressBinding; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT& safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT::operator=( + const safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + reportAddressBinding = copy_src.reportAddressBinding; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT::~safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT::initialize( + const VkPhysicalDeviceAddressBindingReportFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + reportAddressBinding = in_struct->reportAddressBinding; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT::initialize( + const safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + reportAddressBinding = copy_src->reportAddressBinding; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDeviceAddressBindingCallbackDataEXT::safe_VkDeviceAddressBindingCallbackDataEXT( + const VkDeviceAddressBindingCallbackDataEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + baseAddress(in_struct->baseAddress), + size(in_struct->size), + bindingType(in_struct->bindingType) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDeviceAddressBindingCallbackDataEXT::safe_VkDeviceAddressBindingCallbackDataEXT() + : sType(VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT), + pNext(nullptr), + flags(), + baseAddress(), + size(), + bindingType() {} + +safe_VkDeviceAddressBindingCallbackDataEXT::safe_VkDeviceAddressBindingCallbackDataEXT( + const safe_VkDeviceAddressBindingCallbackDataEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + baseAddress = copy_src.baseAddress; + size = copy_src.size; + bindingType = copy_src.bindingType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDeviceAddressBindingCallbackDataEXT& safe_VkDeviceAddressBindingCallbackDataEXT::operator=( + const safe_VkDeviceAddressBindingCallbackDataEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + baseAddress = copy_src.baseAddress; + size = copy_src.size; + bindingType = copy_src.bindingType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDeviceAddressBindingCallbackDataEXT::~safe_VkDeviceAddressBindingCallbackDataEXT() { FreePnextChain(pNext); } + +void safe_VkDeviceAddressBindingCallbackDataEXT::initialize(const VkDeviceAddressBindingCallbackDataEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + baseAddress = in_struct->baseAddress; + size = in_struct->size; + bindingType = in_struct->bindingType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDeviceAddressBindingCallbackDataEXT::initialize(const safe_VkDeviceAddressBindingCallbackDataEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + baseAddress = copy_src->baseAddress; + size = copy_src->size; + bindingType = copy_src->bindingType; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDepthClipControlFeaturesEXT::safe_VkPhysicalDeviceDepthClipControlFeaturesEXT( + const VkPhysicalDeviceDepthClipControlFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), depthClipControl(in_struct->depthClipControl) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDepthClipControlFeaturesEXT::safe_VkPhysicalDeviceDepthClipControlFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT), pNext(nullptr), depthClipControl() {} + +safe_VkPhysicalDeviceDepthClipControlFeaturesEXT::safe_VkPhysicalDeviceDepthClipControlFeaturesEXT( + const safe_VkPhysicalDeviceDepthClipControlFeaturesEXT& copy_src) { + sType = copy_src.sType; + depthClipControl = copy_src.depthClipControl; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDepthClipControlFeaturesEXT& safe_VkPhysicalDeviceDepthClipControlFeaturesEXT::operator=( + const safe_VkPhysicalDeviceDepthClipControlFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + depthClipControl = copy_src.depthClipControl; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDepthClipControlFeaturesEXT::~safe_VkPhysicalDeviceDepthClipControlFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceDepthClipControlFeaturesEXT::initialize(const VkPhysicalDeviceDepthClipControlFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + depthClipControl = in_struct->depthClipControl; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDepthClipControlFeaturesEXT::initialize(const safe_VkPhysicalDeviceDepthClipControlFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + depthClipControl = copy_src->depthClipControl; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineViewportDepthClipControlCreateInfoEXT::safe_VkPipelineViewportDepthClipControlCreateInfoEXT( + const VkPipelineViewportDepthClipControlCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), negativeOneToOne(in_struct->negativeOneToOne) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineViewportDepthClipControlCreateInfoEXT::safe_VkPipelineViewportDepthClipControlCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT), pNext(nullptr), negativeOneToOne() {} + +safe_VkPipelineViewportDepthClipControlCreateInfoEXT::safe_VkPipelineViewportDepthClipControlCreateInfoEXT( + const safe_VkPipelineViewportDepthClipControlCreateInfoEXT& copy_src) { + sType = copy_src.sType; + negativeOneToOne = copy_src.negativeOneToOne; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineViewportDepthClipControlCreateInfoEXT& safe_VkPipelineViewportDepthClipControlCreateInfoEXT::operator=( + const safe_VkPipelineViewportDepthClipControlCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + negativeOneToOne = copy_src.negativeOneToOne; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineViewportDepthClipControlCreateInfoEXT::~safe_VkPipelineViewportDepthClipControlCreateInfoEXT() { + FreePnextChain(pNext); +} + +void safe_VkPipelineViewportDepthClipControlCreateInfoEXT::initialize( + const VkPipelineViewportDepthClipControlCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + negativeOneToOne = in_struct->negativeOneToOne; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineViewportDepthClipControlCreateInfoEXT::initialize( + const safe_VkPipelineViewportDepthClipControlCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + negativeOneToOne = copy_src->negativeOneToOne; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT( + const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + primitiveTopologyListRestart(in_struct->primitiveTopologyListRestart), + primitiveTopologyPatchListRestart(in_struct->primitiveTopologyPatchListRestart) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT), + pNext(nullptr), + primitiveTopologyListRestart(), + primitiveTopologyPatchListRestart() {} + +safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT( + const safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& copy_src) { + sType = copy_src.sType; + primitiveTopologyListRestart = copy_src.primitiveTopologyListRestart; + primitiveTopologyPatchListRestart = copy_src.primitiveTopologyPatchListRestart; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& +safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::operator=( + const safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + primitiveTopologyListRestart = copy_src.primitiveTopologyListRestart; + primitiveTopologyPatchListRestart = copy_src.primitiveTopologyPatchListRestart; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::~safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::initialize( + const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + primitiveTopologyListRestart = in_struct->primitiveTopologyListRestart; + primitiveTopologyPatchListRestart = in_struct->primitiveTopologyPatchListRestart; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::initialize( + const safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + primitiveTopologyListRestart = copy_src->primitiveTopologyListRestart; + primitiveTopologyPatchListRestart = copy_src->primitiveTopologyPatchListRestart; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelinePropertiesIdentifierEXT::safe_VkPipelinePropertiesIdentifierEXT(const VkPipelinePropertiesIdentifierEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + pipelineIdentifier[i] = in_struct->pipelineIdentifier[i]; + } +} + +safe_VkPipelinePropertiesIdentifierEXT::safe_VkPipelinePropertiesIdentifierEXT() + : sType(VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT), pNext(nullptr) {} + +safe_VkPipelinePropertiesIdentifierEXT::safe_VkPipelinePropertiesIdentifierEXT( + const safe_VkPipelinePropertiesIdentifierEXT& copy_src) { + sType = copy_src.sType; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + pipelineIdentifier[i] = copy_src.pipelineIdentifier[i]; + } +} + +safe_VkPipelinePropertiesIdentifierEXT& safe_VkPipelinePropertiesIdentifierEXT::operator=( + const safe_VkPipelinePropertiesIdentifierEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + pipelineIdentifier[i] = copy_src.pipelineIdentifier[i]; + } + + return *this; +} + +safe_VkPipelinePropertiesIdentifierEXT::~safe_VkPipelinePropertiesIdentifierEXT() { FreePnextChain(pNext); } + +void safe_VkPipelinePropertiesIdentifierEXT::initialize(const VkPipelinePropertiesIdentifierEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + pipelineIdentifier[i] = in_struct->pipelineIdentifier[i]; + } +} + +void safe_VkPipelinePropertiesIdentifierEXT::initialize(const safe_VkPipelinePropertiesIdentifierEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + pipelineIdentifier[i] = copy_src->pipelineIdentifier[i]; + } +} + +safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT::safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT( + const VkPhysicalDevicePipelinePropertiesFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pipelinePropertiesIdentifier(in_struct->pipelinePropertiesIdentifier) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT::safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT), pNext(nullptr), pipelinePropertiesIdentifier() {} + +safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT::safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT( + const safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT& copy_src) { + sType = copy_src.sType; + pipelinePropertiesIdentifier = copy_src.pipelinePropertiesIdentifier; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT& safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT::operator=( + const safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pipelinePropertiesIdentifier = copy_src.pipelinePropertiesIdentifier; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT::~safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT::initialize(const VkPhysicalDevicePipelinePropertiesFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pipelinePropertiesIdentifier = in_struct->pipelinePropertiesIdentifier; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT::initialize( + const safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipelinePropertiesIdentifier = copy_src->pipelinePropertiesIdentifier; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT( + const VkPhysicalDeviceFrameBoundaryFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), frameBoundary(in_struct->frameBoundary) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT), pNext(nullptr), frameBoundary() {} + +safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT( + const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT& copy_src) { + sType = copy_src.sType; + frameBoundary = copy_src.frameBoundary; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT& safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::operator=( + const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + frameBoundary = copy_src.frameBoundary; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::~safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::initialize(const VkPhysicalDeviceFrameBoundaryFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + frameBoundary = in_struct->frameBoundary; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::initialize(const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + frameBoundary = copy_src->frameBoundary; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkFrameBoundaryEXT::safe_VkFrameBoundaryEXT(const VkFrameBoundaryEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + frameID(in_struct->frameID), + imageCount(in_struct->imageCount), + pImages(nullptr), + bufferCount(in_struct->bufferCount), + pBuffers(nullptr), + tagName(in_struct->tagName), + tagSize(in_struct->tagSize), + pTag(in_struct->pTag) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (imageCount && in_struct->pImages) { + pImages = new VkImage[imageCount]; + for (uint32_t i = 0; i < imageCount; ++i) { + pImages[i] = in_struct->pImages[i]; + } + } + if (bufferCount && in_struct->pBuffers) { + pBuffers = new VkBuffer[bufferCount]; + for (uint32_t i = 0; i < bufferCount; ++i) { + pBuffers[i] = in_struct->pBuffers[i]; + } + } +} + +safe_VkFrameBoundaryEXT::safe_VkFrameBoundaryEXT() + : sType(VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT), + pNext(nullptr), + flags(), + frameID(), + imageCount(), + pImages(nullptr), + bufferCount(), + pBuffers(nullptr), + tagName(), + tagSize(), + pTag(nullptr) {} + +safe_VkFrameBoundaryEXT::safe_VkFrameBoundaryEXT(const safe_VkFrameBoundaryEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + frameID = copy_src.frameID; + imageCount = copy_src.imageCount; + pImages = nullptr; + bufferCount = copy_src.bufferCount; + pBuffers = nullptr; + tagName = copy_src.tagName; + tagSize = copy_src.tagSize; + pTag = copy_src.pTag; + pNext = SafePnextCopy(copy_src.pNext); + if (imageCount && copy_src.pImages) { + pImages = new VkImage[imageCount]; + for (uint32_t i = 0; i < imageCount; ++i) { + pImages[i] = copy_src.pImages[i]; + } + } + if (bufferCount && copy_src.pBuffers) { + pBuffers = new VkBuffer[bufferCount]; + for (uint32_t i = 0; i < bufferCount; ++i) { + pBuffers[i] = copy_src.pBuffers[i]; + } + } +} + +safe_VkFrameBoundaryEXT& safe_VkFrameBoundaryEXT::operator=(const safe_VkFrameBoundaryEXT& copy_src) { + if (©_src == this) return *this; + + if (pImages) delete[] pImages; + if (pBuffers) delete[] pBuffers; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + frameID = copy_src.frameID; + imageCount = copy_src.imageCount; + pImages = nullptr; + bufferCount = copy_src.bufferCount; + pBuffers = nullptr; + tagName = copy_src.tagName; + tagSize = copy_src.tagSize; + pTag = copy_src.pTag; + pNext = SafePnextCopy(copy_src.pNext); + if (imageCount && copy_src.pImages) { + pImages = new VkImage[imageCount]; + for (uint32_t i = 0; i < imageCount; ++i) { + pImages[i] = copy_src.pImages[i]; + } + } + if (bufferCount && copy_src.pBuffers) { + pBuffers = new VkBuffer[bufferCount]; + for (uint32_t i = 0; i < bufferCount; ++i) { + pBuffers[i] = copy_src.pBuffers[i]; + } + } + + return *this; +} + +safe_VkFrameBoundaryEXT::~safe_VkFrameBoundaryEXT() { + if (pImages) delete[] pImages; + if (pBuffers) delete[] pBuffers; + FreePnextChain(pNext); +} + +void safe_VkFrameBoundaryEXT::initialize(const VkFrameBoundaryEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pImages) delete[] pImages; + if (pBuffers) delete[] pBuffers; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + frameID = in_struct->frameID; + imageCount = in_struct->imageCount; + pImages = nullptr; + bufferCount = in_struct->bufferCount; + pBuffers = nullptr; + tagName = in_struct->tagName; + tagSize = in_struct->tagSize; + pTag = in_struct->pTag; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (imageCount && in_struct->pImages) { + pImages = new VkImage[imageCount]; + for (uint32_t i = 0; i < imageCount; ++i) { + pImages[i] = in_struct->pImages[i]; + } + } + if (bufferCount && in_struct->pBuffers) { + pBuffers = new VkBuffer[bufferCount]; + for (uint32_t i = 0; i < bufferCount; ++i) { + pBuffers[i] = in_struct->pBuffers[i]; + } + } +} + +void safe_VkFrameBoundaryEXT::initialize(const safe_VkFrameBoundaryEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + frameID = copy_src->frameID; + imageCount = copy_src->imageCount; + pImages = nullptr; + bufferCount = copy_src->bufferCount; + pBuffers = nullptr; + tagName = copy_src->tagName; + tagSize = copy_src->tagSize; + pTag = copy_src->pTag; + pNext = SafePnextCopy(copy_src->pNext); + if (imageCount && copy_src->pImages) { + pImages = new VkImage[imageCount]; + for (uint32_t i = 0; i < imageCount; ++i) { + pImages[i] = copy_src->pImages[i]; + } + } + if (bufferCount && copy_src->pBuffers) { + pBuffers = new VkBuffer[bufferCount]; + for (uint32_t i = 0; i < bufferCount; ++i) { + pBuffers[i] = copy_src->pBuffers[i]; + } + } +} + +safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT:: + safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT( + const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), multisampledRenderToSingleSampled(in_struct->multisampledRenderToSingleSampled) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT:: + safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT), + pNext(nullptr), + multisampledRenderToSingleSampled() {} + +safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT:: + safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT( + const safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& copy_src) { + sType = copy_src.sType; + multisampledRenderToSingleSampled = copy_src.multisampledRenderToSingleSampled; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& +safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::operator=( + const safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + multisampledRenderToSingleSampled = copy_src.multisampledRenderToSingleSampled; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT:: + ~safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::initialize( + const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + multisampledRenderToSingleSampled = in_struct->multisampledRenderToSingleSampled; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::initialize( + const safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + multisampledRenderToSingleSampled = copy_src->multisampledRenderToSingleSampled; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSubpassResolvePerformanceQueryEXT::safe_VkSubpassResolvePerformanceQueryEXT( + const VkSubpassResolvePerformanceQueryEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), optimal(in_struct->optimal) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSubpassResolvePerformanceQueryEXT::safe_VkSubpassResolvePerformanceQueryEXT() + : sType(VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT), pNext(nullptr), optimal() {} + +safe_VkSubpassResolvePerformanceQueryEXT::safe_VkSubpassResolvePerformanceQueryEXT( + const safe_VkSubpassResolvePerformanceQueryEXT& copy_src) { + sType = copy_src.sType; + optimal = copy_src.optimal; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSubpassResolvePerformanceQueryEXT& safe_VkSubpassResolvePerformanceQueryEXT::operator=( + const safe_VkSubpassResolvePerformanceQueryEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + optimal = copy_src.optimal; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSubpassResolvePerformanceQueryEXT::~safe_VkSubpassResolvePerformanceQueryEXT() { FreePnextChain(pNext); } + +void safe_VkSubpassResolvePerformanceQueryEXT::initialize(const VkSubpassResolvePerformanceQueryEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + optimal = in_struct->optimal; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSubpassResolvePerformanceQueryEXT::initialize(const safe_VkSubpassResolvePerformanceQueryEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + optimal = copy_src->optimal; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMultisampledRenderToSingleSampledInfoEXT::safe_VkMultisampledRenderToSingleSampledInfoEXT( + const VkMultisampledRenderToSingleSampledInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + multisampledRenderToSingleSampledEnable(in_struct->multisampledRenderToSingleSampledEnable), + rasterizationSamples(in_struct->rasterizationSamples) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMultisampledRenderToSingleSampledInfoEXT::safe_VkMultisampledRenderToSingleSampledInfoEXT() + : sType(VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT), + pNext(nullptr), + multisampledRenderToSingleSampledEnable(), + rasterizationSamples() {} + +safe_VkMultisampledRenderToSingleSampledInfoEXT::safe_VkMultisampledRenderToSingleSampledInfoEXT( + const safe_VkMultisampledRenderToSingleSampledInfoEXT& copy_src) { + sType = copy_src.sType; + multisampledRenderToSingleSampledEnable = copy_src.multisampledRenderToSingleSampledEnable; + rasterizationSamples = copy_src.rasterizationSamples; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMultisampledRenderToSingleSampledInfoEXT& safe_VkMultisampledRenderToSingleSampledInfoEXT::operator=( + const safe_VkMultisampledRenderToSingleSampledInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + multisampledRenderToSingleSampledEnable = copy_src.multisampledRenderToSingleSampledEnable; + rasterizationSamples = copy_src.rasterizationSamples; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMultisampledRenderToSingleSampledInfoEXT::~safe_VkMultisampledRenderToSingleSampledInfoEXT() { FreePnextChain(pNext); } + +void safe_VkMultisampledRenderToSingleSampledInfoEXT::initialize(const VkMultisampledRenderToSingleSampledInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + multisampledRenderToSingleSampledEnable = in_struct->multisampledRenderToSingleSampledEnable; + rasterizationSamples = in_struct->rasterizationSamples; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMultisampledRenderToSingleSampledInfoEXT::initialize(const safe_VkMultisampledRenderToSingleSampledInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + multisampledRenderToSingleSampledEnable = copy_src->multisampledRenderToSingleSampledEnable; + rasterizationSamples = copy_src->rasterizationSamples; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT( + const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + extendedDynamicState2(in_struct->extendedDynamicState2), + extendedDynamicState2LogicOp(in_struct->extendedDynamicState2LogicOp), + extendedDynamicState2PatchControlPoints(in_struct->extendedDynamicState2PatchControlPoints) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT), + pNext(nullptr), + extendedDynamicState2(), + extendedDynamicState2LogicOp(), + extendedDynamicState2PatchControlPoints() {} + +safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT( + const safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& copy_src) { + sType = copy_src.sType; + extendedDynamicState2 = copy_src.extendedDynamicState2; + extendedDynamicState2LogicOp = copy_src.extendedDynamicState2LogicOp; + extendedDynamicState2PatchControlPoints = copy_src.extendedDynamicState2PatchControlPoints; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::operator=( + const safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + extendedDynamicState2 = copy_src.extendedDynamicState2; + extendedDynamicState2LogicOp = copy_src.extendedDynamicState2LogicOp; + extendedDynamicState2PatchControlPoints = copy_src.extendedDynamicState2PatchControlPoints; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::~safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::initialize( + const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + extendedDynamicState2 = in_struct->extendedDynamicState2; + extendedDynamicState2LogicOp = in_struct->extendedDynamicState2LogicOp; + extendedDynamicState2PatchControlPoints = in_struct->extendedDynamicState2PatchControlPoints; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::initialize( + const safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + extendedDynamicState2 = copy_src->extendedDynamicState2; + extendedDynamicState2LogicOp = copy_src->extendedDynamicState2LogicOp; + extendedDynamicState2PatchControlPoints = copy_src->extendedDynamicState2PatchControlPoints; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT( + const VkPhysicalDeviceColorWriteEnableFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), colorWriteEnable(in_struct->colorWriteEnable) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT), pNext(nullptr), colorWriteEnable() {} + +safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT( + const safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT& copy_src) { + sType = copy_src.sType; + colorWriteEnable = copy_src.colorWriteEnable; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT& safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::operator=( + const safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + colorWriteEnable = copy_src.colorWriteEnable; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::~safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::initialize(const VkPhysicalDeviceColorWriteEnableFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + colorWriteEnable = in_struct->colorWriteEnable; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::initialize(const safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + colorWriteEnable = copy_src->colorWriteEnable; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineColorWriteCreateInfoEXT::safe_VkPipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), attachmentCount(in_struct->attachmentCount), pColorWriteEnables(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pColorWriteEnables) { + pColorWriteEnables = new VkBool32[in_struct->attachmentCount]; + memcpy((void*)pColorWriteEnables, (void*)in_struct->pColorWriteEnables, sizeof(VkBool32) * in_struct->attachmentCount); + } +} + +safe_VkPipelineColorWriteCreateInfoEXT::safe_VkPipelineColorWriteCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT), + pNext(nullptr), + attachmentCount(), + pColorWriteEnables(nullptr) {} + +safe_VkPipelineColorWriteCreateInfoEXT::safe_VkPipelineColorWriteCreateInfoEXT( + const safe_VkPipelineColorWriteCreateInfoEXT& copy_src) { + sType = copy_src.sType; + attachmentCount = copy_src.attachmentCount; + pColorWriteEnables = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pColorWriteEnables) { + pColorWriteEnables = new VkBool32[copy_src.attachmentCount]; + memcpy((void*)pColorWriteEnables, (void*)copy_src.pColorWriteEnables, sizeof(VkBool32) * copy_src.attachmentCount); + } +} + +safe_VkPipelineColorWriteCreateInfoEXT& safe_VkPipelineColorWriteCreateInfoEXT::operator=( + const safe_VkPipelineColorWriteCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pColorWriteEnables) delete[] pColorWriteEnables; + FreePnextChain(pNext); + + sType = copy_src.sType; + attachmentCount = copy_src.attachmentCount; + pColorWriteEnables = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pColorWriteEnables) { + pColorWriteEnables = new VkBool32[copy_src.attachmentCount]; + memcpy((void*)pColorWriteEnables, (void*)copy_src.pColorWriteEnables, sizeof(VkBool32) * copy_src.attachmentCount); + } + + return *this; +} + +safe_VkPipelineColorWriteCreateInfoEXT::~safe_VkPipelineColorWriteCreateInfoEXT() { + if (pColorWriteEnables) delete[] pColorWriteEnables; + FreePnextChain(pNext); +} + +void safe_VkPipelineColorWriteCreateInfoEXT::initialize(const VkPipelineColorWriteCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pColorWriteEnables) delete[] pColorWriteEnables; + FreePnextChain(pNext); + sType = in_struct->sType; + attachmentCount = in_struct->attachmentCount; + pColorWriteEnables = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pColorWriteEnables) { + pColorWriteEnables = new VkBool32[in_struct->attachmentCount]; + memcpy((void*)pColorWriteEnables, (void*)in_struct->pColorWriteEnables, sizeof(VkBool32) * in_struct->attachmentCount); + } +} + +void safe_VkPipelineColorWriteCreateInfoEXT::initialize(const safe_VkPipelineColorWriteCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + attachmentCount = copy_src->attachmentCount; + pColorWriteEnables = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pColorWriteEnables) { + pColorWriteEnables = new VkBool32[copy_src->attachmentCount]; + memcpy((void*)pColorWriteEnables, (void*)copy_src->pColorWriteEnables, sizeof(VkBool32) * copy_src->attachmentCount); + } +} + +safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT( + const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + primitivesGeneratedQuery(in_struct->primitivesGeneratedQuery), + primitivesGeneratedQueryWithRasterizerDiscard(in_struct->primitivesGeneratedQueryWithRasterizerDiscard), + primitivesGeneratedQueryWithNonZeroStreams(in_struct->primitivesGeneratedQueryWithNonZeroStreams) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT), + pNext(nullptr), + primitivesGeneratedQuery(), + primitivesGeneratedQueryWithRasterizerDiscard(), + primitivesGeneratedQueryWithNonZeroStreams() {} + +safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT( + const safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& copy_src) { + sType = copy_src.sType; + primitivesGeneratedQuery = copy_src.primitivesGeneratedQuery; + primitivesGeneratedQueryWithRasterizerDiscard = copy_src.primitivesGeneratedQueryWithRasterizerDiscard; + primitivesGeneratedQueryWithNonZeroStreams = copy_src.primitivesGeneratedQueryWithNonZeroStreams; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::operator=( + const safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + primitivesGeneratedQuery = copy_src.primitivesGeneratedQuery; + primitivesGeneratedQueryWithRasterizerDiscard = copy_src.primitivesGeneratedQueryWithRasterizerDiscard; + primitivesGeneratedQueryWithNonZeroStreams = copy_src.primitivesGeneratedQueryWithNonZeroStreams; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::~safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::initialize( + const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + primitivesGeneratedQuery = in_struct->primitivesGeneratedQuery; + primitivesGeneratedQueryWithRasterizerDiscard = in_struct->primitivesGeneratedQueryWithRasterizerDiscard; + primitivesGeneratedQueryWithNonZeroStreams = in_struct->primitivesGeneratedQueryWithNonZeroStreams; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::initialize( + const safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + primitivesGeneratedQuery = copy_src->primitivesGeneratedQuery; + primitivesGeneratedQueryWithRasterizerDiscard = copy_src->primitivesGeneratedQueryWithRasterizerDiscard; + primitivesGeneratedQueryWithNonZeroStreams = copy_src->primitivesGeneratedQueryWithNonZeroStreams; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT::safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT( + const VkPhysicalDeviceImageViewMinLodFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), minLod(in_struct->minLod) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT::safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT), pNext(nullptr), minLod() {} + +safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT::safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT( + const safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT& copy_src) { + sType = copy_src.sType; + minLod = copy_src.minLod; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT& safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT::operator=( + const safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + minLod = copy_src.minLod; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT::~safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT::initialize(const VkPhysicalDeviceImageViewMinLodFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + minLod = in_struct->minLod; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT::initialize(const safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + minLod = copy_src->minLod; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImageViewMinLodCreateInfoEXT::safe_VkImageViewMinLodCreateInfoEXT(const VkImageViewMinLodCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), minLod(in_struct->minLod) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageViewMinLodCreateInfoEXT::safe_VkImageViewMinLodCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT), pNext(nullptr), minLod() {} + +safe_VkImageViewMinLodCreateInfoEXT::safe_VkImageViewMinLodCreateInfoEXT(const safe_VkImageViewMinLodCreateInfoEXT& copy_src) { + sType = copy_src.sType; + minLod = copy_src.minLod; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageViewMinLodCreateInfoEXT& safe_VkImageViewMinLodCreateInfoEXT::operator=( + const safe_VkImageViewMinLodCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + minLod = copy_src.minLod; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageViewMinLodCreateInfoEXT::~safe_VkImageViewMinLodCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkImageViewMinLodCreateInfoEXT::initialize(const VkImageViewMinLodCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + minLod = in_struct->minLod; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageViewMinLodCreateInfoEXT::initialize(const safe_VkImageViewMinLodCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + minLod = copy_src->minLod; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMultiDrawFeaturesEXT::safe_VkPhysicalDeviceMultiDrawFeaturesEXT( + const VkPhysicalDeviceMultiDrawFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), multiDraw(in_struct->multiDraw) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMultiDrawFeaturesEXT::safe_VkPhysicalDeviceMultiDrawFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT), pNext(nullptr), multiDraw() {} + +safe_VkPhysicalDeviceMultiDrawFeaturesEXT::safe_VkPhysicalDeviceMultiDrawFeaturesEXT( + const safe_VkPhysicalDeviceMultiDrawFeaturesEXT& copy_src) { + sType = copy_src.sType; + multiDraw = copy_src.multiDraw; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMultiDrawFeaturesEXT& safe_VkPhysicalDeviceMultiDrawFeaturesEXT::operator=( + const safe_VkPhysicalDeviceMultiDrawFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + multiDraw = copy_src.multiDraw; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMultiDrawFeaturesEXT::~safe_VkPhysicalDeviceMultiDrawFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMultiDrawFeaturesEXT::initialize(const VkPhysicalDeviceMultiDrawFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + multiDraw = in_struct->multiDraw; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMultiDrawFeaturesEXT::initialize(const safe_VkPhysicalDeviceMultiDrawFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + multiDraw = copy_src->multiDraw; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMultiDrawPropertiesEXT::safe_VkPhysicalDeviceMultiDrawPropertiesEXT( + const VkPhysicalDeviceMultiDrawPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), maxMultiDrawCount(in_struct->maxMultiDrawCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMultiDrawPropertiesEXT::safe_VkPhysicalDeviceMultiDrawPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT), pNext(nullptr), maxMultiDrawCount() {} + +safe_VkPhysicalDeviceMultiDrawPropertiesEXT::safe_VkPhysicalDeviceMultiDrawPropertiesEXT( + const safe_VkPhysicalDeviceMultiDrawPropertiesEXT& copy_src) { + sType = copy_src.sType; + maxMultiDrawCount = copy_src.maxMultiDrawCount; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMultiDrawPropertiesEXT& safe_VkPhysicalDeviceMultiDrawPropertiesEXT::operator=( + const safe_VkPhysicalDeviceMultiDrawPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxMultiDrawCount = copy_src.maxMultiDrawCount; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMultiDrawPropertiesEXT::~safe_VkPhysicalDeviceMultiDrawPropertiesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMultiDrawPropertiesEXT::initialize(const VkPhysicalDeviceMultiDrawPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxMultiDrawCount = in_struct->maxMultiDrawCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMultiDrawPropertiesEXT::initialize(const safe_VkPhysicalDeviceMultiDrawPropertiesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxMultiDrawCount = copy_src->maxMultiDrawCount; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT::safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT( + const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), image2DViewOf3D(in_struct->image2DViewOf3D), sampler2DViewOf3D(in_struct->sampler2DViewOf3D) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT::safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT), + pNext(nullptr), + image2DViewOf3D(), + sampler2DViewOf3D() {} + +safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT::safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT( + const safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& copy_src) { + sType = copy_src.sType; + image2DViewOf3D = copy_src.image2DViewOf3D; + sampler2DViewOf3D = copy_src.sampler2DViewOf3D; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT::operator=( + const safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + image2DViewOf3D = copy_src.image2DViewOf3D; + sampler2DViewOf3D = copy_src.sampler2DViewOf3D; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT::~safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT::initialize(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + image2DViewOf3D = in_struct->image2DViewOf3D; + sampler2DViewOf3D = in_struct->sampler2DViewOf3D; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT::initialize(const safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + image2DViewOf3D = copy_src->image2DViewOf3D; + sampler2DViewOf3D = copy_src->sampler2DViewOf3D; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderTileImageFeaturesEXT::safe_VkPhysicalDeviceShaderTileImageFeaturesEXT( + const VkPhysicalDeviceShaderTileImageFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shaderTileImageColorReadAccess(in_struct->shaderTileImageColorReadAccess), + shaderTileImageDepthReadAccess(in_struct->shaderTileImageDepthReadAccess), + shaderTileImageStencilReadAccess(in_struct->shaderTileImageStencilReadAccess) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderTileImageFeaturesEXT::safe_VkPhysicalDeviceShaderTileImageFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT), + pNext(nullptr), + shaderTileImageColorReadAccess(), + shaderTileImageDepthReadAccess(), + shaderTileImageStencilReadAccess() {} + +safe_VkPhysicalDeviceShaderTileImageFeaturesEXT::safe_VkPhysicalDeviceShaderTileImageFeaturesEXT( + const safe_VkPhysicalDeviceShaderTileImageFeaturesEXT& copy_src) { + sType = copy_src.sType; + shaderTileImageColorReadAccess = copy_src.shaderTileImageColorReadAccess; + shaderTileImageDepthReadAccess = copy_src.shaderTileImageDepthReadAccess; + shaderTileImageStencilReadAccess = copy_src.shaderTileImageStencilReadAccess; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderTileImageFeaturesEXT& safe_VkPhysicalDeviceShaderTileImageFeaturesEXT::operator=( + const safe_VkPhysicalDeviceShaderTileImageFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderTileImageColorReadAccess = copy_src.shaderTileImageColorReadAccess; + shaderTileImageDepthReadAccess = copy_src.shaderTileImageDepthReadAccess; + shaderTileImageStencilReadAccess = copy_src.shaderTileImageStencilReadAccess; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderTileImageFeaturesEXT::~safe_VkPhysicalDeviceShaderTileImageFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderTileImageFeaturesEXT::initialize(const VkPhysicalDeviceShaderTileImageFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderTileImageColorReadAccess = in_struct->shaderTileImageColorReadAccess; + shaderTileImageDepthReadAccess = in_struct->shaderTileImageDepthReadAccess; + shaderTileImageStencilReadAccess = in_struct->shaderTileImageStencilReadAccess; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderTileImageFeaturesEXT::initialize(const safe_VkPhysicalDeviceShaderTileImageFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderTileImageColorReadAccess = copy_src->shaderTileImageColorReadAccess; + shaderTileImageDepthReadAccess = copy_src->shaderTileImageDepthReadAccess; + shaderTileImageStencilReadAccess = copy_src->shaderTileImageStencilReadAccess; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderTileImagePropertiesEXT::safe_VkPhysicalDeviceShaderTileImagePropertiesEXT( + const VkPhysicalDeviceShaderTileImagePropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shaderTileImageCoherentReadAccelerated(in_struct->shaderTileImageCoherentReadAccelerated), + shaderTileImageReadSampleFromPixelRateInvocation(in_struct->shaderTileImageReadSampleFromPixelRateInvocation), + shaderTileImageReadFromHelperInvocation(in_struct->shaderTileImageReadFromHelperInvocation) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderTileImagePropertiesEXT::safe_VkPhysicalDeviceShaderTileImagePropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT), + pNext(nullptr), + shaderTileImageCoherentReadAccelerated(), + shaderTileImageReadSampleFromPixelRateInvocation(), + shaderTileImageReadFromHelperInvocation() {} + +safe_VkPhysicalDeviceShaderTileImagePropertiesEXT::safe_VkPhysicalDeviceShaderTileImagePropertiesEXT( + const safe_VkPhysicalDeviceShaderTileImagePropertiesEXT& copy_src) { + sType = copy_src.sType; + shaderTileImageCoherentReadAccelerated = copy_src.shaderTileImageCoherentReadAccelerated; + shaderTileImageReadSampleFromPixelRateInvocation = copy_src.shaderTileImageReadSampleFromPixelRateInvocation; + shaderTileImageReadFromHelperInvocation = copy_src.shaderTileImageReadFromHelperInvocation; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderTileImagePropertiesEXT& safe_VkPhysicalDeviceShaderTileImagePropertiesEXT::operator=( + const safe_VkPhysicalDeviceShaderTileImagePropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderTileImageCoherentReadAccelerated = copy_src.shaderTileImageCoherentReadAccelerated; + shaderTileImageReadSampleFromPixelRateInvocation = copy_src.shaderTileImageReadSampleFromPixelRateInvocation; + shaderTileImageReadFromHelperInvocation = copy_src.shaderTileImageReadFromHelperInvocation; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderTileImagePropertiesEXT::~safe_VkPhysicalDeviceShaderTileImagePropertiesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderTileImagePropertiesEXT::initialize(const VkPhysicalDeviceShaderTileImagePropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderTileImageCoherentReadAccelerated = in_struct->shaderTileImageCoherentReadAccelerated; + shaderTileImageReadSampleFromPixelRateInvocation = in_struct->shaderTileImageReadSampleFromPixelRateInvocation; + shaderTileImageReadFromHelperInvocation = in_struct->shaderTileImageReadFromHelperInvocation; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderTileImagePropertiesEXT::initialize( + const safe_VkPhysicalDeviceShaderTileImagePropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderTileImageCoherentReadAccelerated = copy_src->shaderTileImageCoherentReadAccelerated; + shaderTileImageReadSampleFromPixelRateInvocation = copy_src->shaderTileImageReadSampleFromPixelRateInvocation; + shaderTileImageReadFromHelperInvocation = copy_src->shaderTileImageReadFromHelperInvocation; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMicromapCreateInfoEXT::safe_VkMicromapCreateInfoEXT(const VkMicromapCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + createFlags(in_struct->createFlags), + buffer(in_struct->buffer), + offset(in_struct->offset), + size(in_struct->size), + type(in_struct->type), + deviceAddress(in_struct->deviceAddress) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMicromapCreateInfoEXT::safe_VkMicromapCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT), + pNext(nullptr), + createFlags(), + buffer(), + offset(), + size(), + type(), + deviceAddress() {} + +safe_VkMicromapCreateInfoEXT::safe_VkMicromapCreateInfoEXT(const safe_VkMicromapCreateInfoEXT& copy_src) { + sType = copy_src.sType; + createFlags = copy_src.createFlags; + buffer = copy_src.buffer; + offset = copy_src.offset; + size = copy_src.size; + type = copy_src.type; + deviceAddress = copy_src.deviceAddress; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMicromapCreateInfoEXT& safe_VkMicromapCreateInfoEXT::operator=(const safe_VkMicromapCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + createFlags = copy_src.createFlags; + buffer = copy_src.buffer; + offset = copy_src.offset; + size = copy_src.size; + type = copy_src.type; + deviceAddress = copy_src.deviceAddress; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMicromapCreateInfoEXT::~safe_VkMicromapCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkMicromapCreateInfoEXT::initialize(const VkMicromapCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + createFlags = in_struct->createFlags; + buffer = in_struct->buffer; + offset = in_struct->offset; + size = in_struct->size; + type = in_struct->type; + deviceAddress = in_struct->deviceAddress; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMicromapCreateInfoEXT::initialize(const safe_VkMicromapCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + createFlags = copy_src->createFlags; + buffer = copy_src->buffer; + offset = copy_src->offset; + size = copy_src->size; + type = copy_src->type; + deviceAddress = copy_src->deviceAddress; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT::safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT( + const VkPhysicalDeviceOpacityMicromapFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + micromap(in_struct->micromap), + micromapCaptureReplay(in_struct->micromapCaptureReplay), + micromapHostCommands(in_struct->micromapHostCommands) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT::safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT), + pNext(nullptr), + micromap(), + micromapCaptureReplay(), + micromapHostCommands() {} + +safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT::safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT( + const safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT& copy_src) { + sType = copy_src.sType; + micromap = copy_src.micromap; + micromapCaptureReplay = copy_src.micromapCaptureReplay; + micromapHostCommands = copy_src.micromapHostCommands; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT& safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT::operator=( + const safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + micromap = copy_src.micromap; + micromapCaptureReplay = copy_src.micromapCaptureReplay; + micromapHostCommands = copy_src.micromapHostCommands; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT::~safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT::initialize(const VkPhysicalDeviceOpacityMicromapFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + micromap = in_struct->micromap; + micromapCaptureReplay = in_struct->micromapCaptureReplay; + micromapHostCommands = in_struct->micromapHostCommands; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT::initialize(const safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + micromap = copy_src->micromap; + micromapCaptureReplay = copy_src->micromapCaptureReplay; + micromapHostCommands = copy_src->micromapHostCommands; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT::safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT( + const VkPhysicalDeviceOpacityMicromapPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + maxOpacity2StateSubdivisionLevel(in_struct->maxOpacity2StateSubdivisionLevel), + maxOpacity4StateSubdivisionLevel(in_struct->maxOpacity4StateSubdivisionLevel) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT::safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT), + pNext(nullptr), + maxOpacity2StateSubdivisionLevel(), + maxOpacity4StateSubdivisionLevel() {} + +safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT::safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT( + const safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT& copy_src) { + sType = copy_src.sType; + maxOpacity2StateSubdivisionLevel = copy_src.maxOpacity2StateSubdivisionLevel; + maxOpacity4StateSubdivisionLevel = copy_src.maxOpacity4StateSubdivisionLevel; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT& safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT::operator=( + const safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxOpacity2StateSubdivisionLevel = copy_src.maxOpacity2StateSubdivisionLevel; + maxOpacity4StateSubdivisionLevel = copy_src.maxOpacity4StateSubdivisionLevel; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT::~safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT::initialize(const VkPhysicalDeviceOpacityMicromapPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxOpacity2StateSubdivisionLevel = in_struct->maxOpacity2StateSubdivisionLevel; + maxOpacity4StateSubdivisionLevel = in_struct->maxOpacity4StateSubdivisionLevel; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT::initialize( + const safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxOpacity2StateSubdivisionLevel = copy_src->maxOpacity2StateSubdivisionLevel; + maxOpacity4StateSubdivisionLevel = copy_src->maxOpacity4StateSubdivisionLevel; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMicromapVersionInfoEXT::safe_VkMicromapVersionInfoEXT(const VkMicromapVersionInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pVersionData(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pVersionData) { + pVersionData = new uint8_t[2 * VK_UUID_SIZE]; + memcpy((void*)pVersionData, (void*)in_struct->pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE); + } +} + +safe_VkMicromapVersionInfoEXT::safe_VkMicromapVersionInfoEXT() + : sType(VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT), pNext(nullptr), pVersionData(nullptr) {} + +safe_VkMicromapVersionInfoEXT::safe_VkMicromapVersionInfoEXT(const safe_VkMicromapVersionInfoEXT& copy_src) { + sType = copy_src.sType; + pVersionData = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pVersionData) { + pVersionData = new uint8_t[2 * VK_UUID_SIZE]; + memcpy((void*)pVersionData, (void*)copy_src.pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE); + } +} + +safe_VkMicromapVersionInfoEXT& safe_VkMicromapVersionInfoEXT::operator=(const safe_VkMicromapVersionInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pVersionData) delete[] pVersionData; + FreePnextChain(pNext); + + sType = copy_src.sType; + pVersionData = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pVersionData) { + pVersionData = new uint8_t[2 * VK_UUID_SIZE]; + memcpy((void*)pVersionData, (void*)copy_src.pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE); + } + + return *this; +} + +safe_VkMicromapVersionInfoEXT::~safe_VkMicromapVersionInfoEXT() { + if (pVersionData) delete[] pVersionData; + FreePnextChain(pNext); +} + +void safe_VkMicromapVersionInfoEXT::initialize(const VkMicromapVersionInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pVersionData) delete[] pVersionData; + FreePnextChain(pNext); + sType = in_struct->sType; + pVersionData = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pVersionData) { + pVersionData = new uint8_t[2 * VK_UUID_SIZE]; + memcpy((void*)pVersionData, (void*)in_struct->pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE); + } +} + +void safe_VkMicromapVersionInfoEXT::initialize(const safe_VkMicromapVersionInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pVersionData = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pVersionData) { + pVersionData = new uint8_t[2 * VK_UUID_SIZE]; + memcpy((void*)pVersionData, (void*)copy_src->pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE); + } +} + +safe_VkCopyMicromapToMemoryInfoEXT::safe_VkCopyMicromapToMemoryInfoEXT(const VkCopyMicromapToMemoryInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), src(in_struct->src), dst(&in_struct->dst), mode(in_struct->mode) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCopyMicromapToMemoryInfoEXT::safe_VkCopyMicromapToMemoryInfoEXT() + : sType(VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT), pNext(nullptr), src(), mode() {} + +safe_VkCopyMicromapToMemoryInfoEXT::safe_VkCopyMicromapToMemoryInfoEXT(const safe_VkCopyMicromapToMemoryInfoEXT& copy_src) { + sType = copy_src.sType; + src = copy_src.src; + dst.initialize(©_src.dst); + mode = copy_src.mode; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCopyMicromapToMemoryInfoEXT& safe_VkCopyMicromapToMemoryInfoEXT::operator=( + const safe_VkCopyMicromapToMemoryInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + src = copy_src.src; + dst.initialize(©_src.dst); + mode = copy_src.mode; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCopyMicromapToMemoryInfoEXT::~safe_VkCopyMicromapToMemoryInfoEXT() { FreePnextChain(pNext); } + +void safe_VkCopyMicromapToMemoryInfoEXT::initialize(const VkCopyMicromapToMemoryInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + src = in_struct->src; + dst.initialize(&in_struct->dst); + mode = in_struct->mode; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCopyMicromapToMemoryInfoEXT::initialize(const safe_VkCopyMicromapToMemoryInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + src = copy_src->src; + dst.initialize(©_src->dst); + mode = copy_src->mode; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCopyMemoryToMicromapInfoEXT::safe_VkCopyMemoryToMicromapInfoEXT(const VkCopyMemoryToMicromapInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), src(&in_struct->src), dst(in_struct->dst), mode(in_struct->mode) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCopyMemoryToMicromapInfoEXT::safe_VkCopyMemoryToMicromapInfoEXT() + : sType(VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT), pNext(nullptr), dst(), mode() {} + +safe_VkCopyMemoryToMicromapInfoEXT::safe_VkCopyMemoryToMicromapInfoEXT(const safe_VkCopyMemoryToMicromapInfoEXT& copy_src) { + sType = copy_src.sType; + src.initialize(©_src.src); + dst = copy_src.dst; + mode = copy_src.mode; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCopyMemoryToMicromapInfoEXT& safe_VkCopyMemoryToMicromapInfoEXT::operator=( + const safe_VkCopyMemoryToMicromapInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + src.initialize(©_src.src); + dst = copy_src.dst; + mode = copy_src.mode; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCopyMemoryToMicromapInfoEXT::~safe_VkCopyMemoryToMicromapInfoEXT() { FreePnextChain(pNext); } + +void safe_VkCopyMemoryToMicromapInfoEXT::initialize(const VkCopyMemoryToMicromapInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + src.initialize(&in_struct->src); + dst = in_struct->dst; + mode = in_struct->mode; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCopyMemoryToMicromapInfoEXT::initialize(const safe_VkCopyMemoryToMicromapInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + src.initialize(©_src->src); + dst = copy_src->dst; + mode = copy_src->mode; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCopyMicromapInfoEXT::safe_VkCopyMicromapInfoEXT(const VkCopyMicromapInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), src(in_struct->src), dst(in_struct->dst), mode(in_struct->mode) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCopyMicromapInfoEXT::safe_VkCopyMicromapInfoEXT() + : sType(VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT), pNext(nullptr), src(), dst(), mode() {} + +safe_VkCopyMicromapInfoEXT::safe_VkCopyMicromapInfoEXT(const safe_VkCopyMicromapInfoEXT& copy_src) { + sType = copy_src.sType; + src = copy_src.src; + dst = copy_src.dst; + mode = copy_src.mode; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCopyMicromapInfoEXT& safe_VkCopyMicromapInfoEXT::operator=(const safe_VkCopyMicromapInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + src = copy_src.src; + dst = copy_src.dst; + mode = copy_src.mode; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCopyMicromapInfoEXT::~safe_VkCopyMicromapInfoEXT() { FreePnextChain(pNext); } + +void safe_VkCopyMicromapInfoEXT::initialize(const VkCopyMicromapInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + src = in_struct->src; + dst = in_struct->dst; + mode = in_struct->mode; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCopyMicromapInfoEXT::initialize(const safe_VkCopyMicromapInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + src = copy_src->src; + dst = copy_src->dst; + mode = copy_src->mode; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMicromapBuildSizesInfoEXT::safe_VkMicromapBuildSizesInfoEXT(const VkMicromapBuildSizesInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + micromapSize(in_struct->micromapSize), + buildScratchSize(in_struct->buildScratchSize), + discardable(in_struct->discardable) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMicromapBuildSizesInfoEXT::safe_VkMicromapBuildSizesInfoEXT() + : sType(VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT), pNext(nullptr), micromapSize(), buildScratchSize(), discardable() {} + +safe_VkMicromapBuildSizesInfoEXT::safe_VkMicromapBuildSizesInfoEXT(const safe_VkMicromapBuildSizesInfoEXT& copy_src) { + sType = copy_src.sType; + micromapSize = copy_src.micromapSize; + buildScratchSize = copy_src.buildScratchSize; + discardable = copy_src.discardable; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMicromapBuildSizesInfoEXT& safe_VkMicromapBuildSizesInfoEXT::operator=(const safe_VkMicromapBuildSizesInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + micromapSize = copy_src.micromapSize; + buildScratchSize = copy_src.buildScratchSize; + discardable = copy_src.discardable; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMicromapBuildSizesInfoEXT::~safe_VkMicromapBuildSizesInfoEXT() { FreePnextChain(pNext); } + +void safe_VkMicromapBuildSizesInfoEXT::initialize(const VkMicromapBuildSizesInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + micromapSize = in_struct->micromapSize; + buildScratchSize = in_struct->buildScratchSize; + discardable = in_struct->discardable; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMicromapBuildSizesInfoEXT::initialize(const safe_VkMicromapBuildSizesInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + micromapSize = copy_src->micromapSize; + buildScratchSize = copy_src->buildScratchSize; + discardable = copy_src->discardable; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT::safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT( + const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + borderColorSwizzle(in_struct->borderColorSwizzle), + borderColorSwizzleFromImage(in_struct->borderColorSwizzleFromImage) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT::safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT), + pNext(nullptr), + borderColorSwizzle(), + borderColorSwizzleFromImage() {} + +safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT::safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT( + const safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& copy_src) { + sType = copy_src.sType; + borderColorSwizzle = copy_src.borderColorSwizzle; + borderColorSwizzleFromImage = copy_src.borderColorSwizzleFromImage; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT::operator=( + const safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + borderColorSwizzle = copy_src.borderColorSwizzle; + borderColorSwizzleFromImage = copy_src.borderColorSwizzleFromImage; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT::~safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT::initialize(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + borderColorSwizzle = in_struct->borderColorSwizzle; + borderColorSwizzleFromImage = in_struct->borderColorSwizzleFromImage; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT::initialize( + const safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + borderColorSwizzle = copy_src->borderColorSwizzle; + borderColorSwizzleFromImage = copy_src->borderColorSwizzleFromImage; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSamplerBorderColorComponentMappingCreateInfoEXT::safe_VkSamplerBorderColorComponentMappingCreateInfoEXT( + const VkSamplerBorderColorComponentMappingCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), components(in_struct->components), srgb(in_struct->srgb) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSamplerBorderColorComponentMappingCreateInfoEXT::safe_VkSamplerBorderColorComponentMappingCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT), pNext(nullptr), components(), srgb() {} + +safe_VkSamplerBorderColorComponentMappingCreateInfoEXT::safe_VkSamplerBorderColorComponentMappingCreateInfoEXT( + const safe_VkSamplerBorderColorComponentMappingCreateInfoEXT& copy_src) { + sType = copy_src.sType; + components = copy_src.components; + srgb = copy_src.srgb; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSamplerBorderColorComponentMappingCreateInfoEXT& safe_VkSamplerBorderColorComponentMappingCreateInfoEXT::operator=( + const safe_VkSamplerBorderColorComponentMappingCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + components = copy_src.components; + srgb = copy_src.srgb; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSamplerBorderColorComponentMappingCreateInfoEXT::~safe_VkSamplerBorderColorComponentMappingCreateInfoEXT() { + FreePnextChain(pNext); +} + +void safe_VkSamplerBorderColorComponentMappingCreateInfoEXT::initialize( + const VkSamplerBorderColorComponentMappingCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + components = in_struct->components; + srgb = in_struct->srgb; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSamplerBorderColorComponentMappingCreateInfoEXT::initialize( + const safe_VkSamplerBorderColorComponentMappingCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + components = copy_src->components; + srgb = copy_src->srgb; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT( + const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), pageableDeviceLocalMemory(in_struct->pageableDeviceLocalMemory) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT), + pNext(nullptr), + pageableDeviceLocalMemory() {} + +safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT( + const safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& copy_src) { + sType = copy_src.sType; + pageableDeviceLocalMemory = copy_src.pageableDeviceLocalMemory; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::operator=( + const safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pageableDeviceLocalMemory = copy_src.pageableDeviceLocalMemory; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::~safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::initialize( + const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pageableDeviceLocalMemory = in_struct->pageableDeviceLocalMemory; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::initialize( + const safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pageableDeviceLocalMemory = copy_src->pageableDeviceLocalMemory; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT::safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT( + const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), imageSlicedViewOf3D(in_struct->imageSlicedViewOf3D) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT::safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT), pNext(nullptr), imageSlicedViewOf3D() {} + +safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT::safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT( + const safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& copy_src) { + sType = copy_src.sType; + imageSlicedViewOf3D = copy_src.imageSlicedViewOf3D; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT::operator=( + const safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + imageSlicedViewOf3D = copy_src.imageSlicedViewOf3D; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT::~safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT::initialize( + const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + imageSlicedViewOf3D = in_struct->imageSlicedViewOf3D; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT::initialize( + const safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + imageSlicedViewOf3D = copy_src->imageSlicedViewOf3D; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImageViewSlicedCreateInfoEXT::safe_VkImageViewSlicedCreateInfoEXT(const VkImageViewSlicedCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), sliceOffset(in_struct->sliceOffset), sliceCount(in_struct->sliceCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageViewSlicedCreateInfoEXT::safe_VkImageViewSlicedCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT), pNext(nullptr), sliceOffset(), sliceCount() {} + +safe_VkImageViewSlicedCreateInfoEXT::safe_VkImageViewSlicedCreateInfoEXT(const safe_VkImageViewSlicedCreateInfoEXT& copy_src) { + sType = copy_src.sType; + sliceOffset = copy_src.sliceOffset; + sliceCount = copy_src.sliceCount; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageViewSlicedCreateInfoEXT& safe_VkImageViewSlicedCreateInfoEXT::operator=( + const safe_VkImageViewSlicedCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + sliceOffset = copy_src.sliceOffset; + sliceCount = copy_src.sliceCount; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageViewSlicedCreateInfoEXT::~safe_VkImageViewSlicedCreateInfoEXT() { FreePnextChain(pNext); } + +void safe_VkImageViewSlicedCreateInfoEXT::initialize(const VkImageViewSlicedCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + sliceOffset = in_struct->sliceOffset; + sliceCount = in_struct->sliceCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageViewSlicedCreateInfoEXT::initialize(const safe_VkImageViewSlicedCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + sliceOffset = copy_src->sliceOffset; + sliceCount = copy_src->sliceCount; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT( + const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), depthClampZeroOne(in_struct->depthClampZeroOne) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT), pNext(nullptr), depthClampZeroOne() {} + +safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT( + const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT& copy_src) { + sType = copy_src.sType; + depthClampZeroOne = copy_src.depthClampZeroOne; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT& safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::operator=( + const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + depthClampZeroOne = copy_src.depthClampZeroOne; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::~safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::initialize(const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + depthClampZeroOne = in_struct->depthClampZeroOne; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::initialize( + const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + depthClampZeroOne = copy_src->depthClampZeroOne; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT::safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT( + const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), nonSeamlessCubeMap(in_struct->nonSeamlessCubeMap) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT::safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT), pNext(nullptr), nonSeamlessCubeMap() {} + +safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT::safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT( + const safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& copy_src) { + sType = copy_src.sType; + nonSeamlessCubeMap = copy_src.nonSeamlessCubeMap; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT::operator=( + const safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + nonSeamlessCubeMap = copy_src.nonSeamlessCubeMap; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT::~safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT::initialize(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + nonSeamlessCubeMap = in_struct->nonSeamlessCubeMap; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT::initialize( + const safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + nonSeamlessCubeMap = copy_src->nonSeamlessCubeMap; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT( + const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), imageCompressionControlSwapchain(in_struct->imageCompressionControlSwapchain) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT), + pNext(nullptr), + imageCompressionControlSwapchain() {} + +safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT( + const safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& copy_src) { + sType = copy_src.sType; + imageCompressionControlSwapchain = copy_src.imageCompressionControlSwapchain; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& +safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::operator=( + const safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + imageCompressionControlSwapchain = copy_src.imageCompressionControlSwapchain; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT:: + ~safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::initialize( + const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + imageCompressionControlSwapchain = in_struct->imageCompressionControlSwapchain; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::initialize( + const safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + imageCompressionControlSwapchain = copy_src->imageCompressionControlSwapchain; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT::safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT( + const VkPhysicalDeviceNestedCommandBufferFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + nestedCommandBuffer(in_struct->nestedCommandBuffer), + nestedCommandBufferRendering(in_struct->nestedCommandBufferRendering), + nestedCommandBufferSimultaneousUse(in_struct->nestedCommandBufferSimultaneousUse) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT::safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT), + pNext(nullptr), + nestedCommandBuffer(), + nestedCommandBufferRendering(), + nestedCommandBufferSimultaneousUse() {} + +safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT::safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT( + const safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT& copy_src) { + sType = copy_src.sType; + nestedCommandBuffer = copy_src.nestedCommandBuffer; + nestedCommandBufferRendering = copy_src.nestedCommandBufferRendering; + nestedCommandBufferSimultaneousUse = copy_src.nestedCommandBufferSimultaneousUse; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT& safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT::operator=( + const safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + nestedCommandBuffer = copy_src.nestedCommandBuffer; + nestedCommandBufferRendering = copy_src.nestedCommandBufferRendering; + nestedCommandBufferSimultaneousUse = copy_src.nestedCommandBufferSimultaneousUse; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT::~safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT::initialize( + const VkPhysicalDeviceNestedCommandBufferFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + nestedCommandBuffer = in_struct->nestedCommandBuffer; + nestedCommandBufferRendering = in_struct->nestedCommandBufferRendering; + nestedCommandBufferSimultaneousUse = in_struct->nestedCommandBufferSimultaneousUse; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT::initialize( + const safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + nestedCommandBuffer = copy_src->nestedCommandBuffer; + nestedCommandBufferRendering = copy_src->nestedCommandBufferRendering; + nestedCommandBufferSimultaneousUse = copy_src->nestedCommandBufferSimultaneousUse; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT::safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT( + const VkPhysicalDeviceNestedCommandBufferPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), maxCommandBufferNestingLevel(in_struct->maxCommandBufferNestingLevel) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT::safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT), + pNext(nullptr), + maxCommandBufferNestingLevel() {} + +safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT::safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT( + const safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT& copy_src) { + sType = copy_src.sType; + maxCommandBufferNestingLevel = copy_src.maxCommandBufferNestingLevel; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT& safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT::operator=( + const safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxCommandBufferNestingLevel = copy_src.maxCommandBufferNestingLevel; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT::~safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT::initialize( + const VkPhysicalDeviceNestedCommandBufferPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxCommandBufferNestingLevel = in_struct->maxCommandBufferNestingLevel; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT::initialize( + const safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxCommandBufferNestingLevel = copy_src->maxCommandBufferNestingLevel; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExternalMemoryAcquireUnmodifiedEXT::safe_VkExternalMemoryAcquireUnmodifiedEXT( + const VkExternalMemoryAcquireUnmodifiedEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), acquireUnmodifiedMemory(in_struct->acquireUnmodifiedMemory) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExternalMemoryAcquireUnmodifiedEXT::safe_VkExternalMemoryAcquireUnmodifiedEXT() + : sType(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT), pNext(nullptr), acquireUnmodifiedMemory() {} + +safe_VkExternalMemoryAcquireUnmodifiedEXT::safe_VkExternalMemoryAcquireUnmodifiedEXT( + const safe_VkExternalMemoryAcquireUnmodifiedEXT& copy_src) { + sType = copy_src.sType; + acquireUnmodifiedMemory = copy_src.acquireUnmodifiedMemory; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExternalMemoryAcquireUnmodifiedEXT& safe_VkExternalMemoryAcquireUnmodifiedEXT::operator=( + const safe_VkExternalMemoryAcquireUnmodifiedEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + acquireUnmodifiedMemory = copy_src.acquireUnmodifiedMemory; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExternalMemoryAcquireUnmodifiedEXT::~safe_VkExternalMemoryAcquireUnmodifiedEXT() { FreePnextChain(pNext); } + +void safe_VkExternalMemoryAcquireUnmodifiedEXT::initialize(const VkExternalMemoryAcquireUnmodifiedEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + acquireUnmodifiedMemory = in_struct->acquireUnmodifiedMemory; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExternalMemoryAcquireUnmodifiedEXT::initialize(const safe_VkExternalMemoryAcquireUnmodifiedEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + acquireUnmodifiedMemory = copy_src->acquireUnmodifiedMemory; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT( + const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + extendedDynamicState3TessellationDomainOrigin(in_struct->extendedDynamicState3TessellationDomainOrigin), + extendedDynamicState3DepthClampEnable(in_struct->extendedDynamicState3DepthClampEnable), + extendedDynamicState3PolygonMode(in_struct->extendedDynamicState3PolygonMode), + extendedDynamicState3RasterizationSamples(in_struct->extendedDynamicState3RasterizationSamples), + extendedDynamicState3SampleMask(in_struct->extendedDynamicState3SampleMask), + extendedDynamicState3AlphaToCoverageEnable(in_struct->extendedDynamicState3AlphaToCoverageEnable), + extendedDynamicState3AlphaToOneEnable(in_struct->extendedDynamicState3AlphaToOneEnable), + extendedDynamicState3LogicOpEnable(in_struct->extendedDynamicState3LogicOpEnable), + extendedDynamicState3ColorBlendEnable(in_struct->extendedDynamicState3ColorBlendEnable), + extendedDynamicState3ColorBlendEquation(in_struct->extendedDynamicState3ColorBlendEquation), + extendedDynamicState3ColorWriteMask(in_struct->extendedDynamicState3ColorWriteMask), + extendedDynamicState3RasterizationStream(in_struct->extendedDynamicState3RasterizationStream), + extendedDynamicState3ConservativeRasterizationMode(in_struct->extendedDynamicState3ConservativeRasterizationMode), + extendedDynamicState3ExtraPrimitiveOverestimationSize(in_struct->extendedDynamicState3ExtraPrimitiveOverestimationSize), + extendedDynamicState3DepthClipEnable(in_struct->extendedDynamicState3DepthClipEnable), + extendedDynamicState3SampleLocationsEnable(in_struct->extendedDynamicState3SampleLocationsEnable), + extendedDynamicState3ColorBlendAdvanced(in_struct->extendedDynamicState3ColorBlendAdvanced), + extendedDynamicState3ProvokingVertexMode(in_struct->extendedDynamicState3ProvokingVertexMode), + extendedDynamicState3LineRasterizationMode(in_struct->extendedDynamicState3LineRasterizationMode), + extendedDynamicState3LineStippleEnable(in_struct->extendedDynamicState3LineStippleEnable), + extendedDynamicState3DepthClipNegativeOneToOne(in_struct->extendedDynamicState3DepthClipNegativeOneToOne), + extendedDynamicState3ViewportWScalingEnable(in_struct->extendedDynamicState3ViewportWScalingEnable), + extendedDynamicState3ViewportSwizzle(in_struct->extendedDynamicState3ViewportSwizzle), + extendedDynamicState3CoverageToColorEnable(in_struct->extendedDynamicState3CoverageToColorEnable), + extendedDynamicState3CoverageToColorLocation(in_struct->extendedDynamicState3CoverageToColorLocation), + extendedDynamicState3CoverageModulationMode(in_struct->extendedDynamicState3CoverageModulationMode), + extendedDynamicState3CoverageModulationTableEnable(in_struct->extendedDynamicState3CoverageModulationTableEnable), + extendedDynamicState3CoverageModulationTable(in_struct->extendedDynamicState3CoverageModulationTable), + extendedDynamicState3CoverageReductionMode(in_struct->extendedDynamicState3CoverageReductionMode), + extendedDynamicState3RepresentativeFragmentTestEnable(in_struct->extendedDynamicState3RepresentativeFragmentTestEnable), + extendedDynamicState3ShadingRateImageEnable(in_struct->extendedDynamicState3ShadingRateImageEnable) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT), + pNext(nullptr), + extendedDynamicState3TessellationDomainOrigin(), + extendedDynamicState3DepthClampEnable(), + extendedDynamicState3PolygonMode(), + extendedDynamicState3RasterizationSamples(), + extendedDynamicState3SampleMask(), + extendedDynamicState3AlphaToCoverageEnable(), + extendedDynamicState3AlphaToOneEnable(), + extendedDynamicState3LogicOpEnable(), + extendedDynamicState3ColorBlendEnable(), + extendedDynamicState3ColorBlendEquation(), + extendedDynamicState3ColorWriteMask(), + extendedDynamicState3RasterizationStream(), + extendedDynamicState3ConservativeRasterizationMode(), + extendedDynamicState3ExtraPrimitiveOverestimationSize(), + extendedDynamicState3DepthClipEnable(), + extendedDynamicState3SampleLocationsEnable(), + extendedDynamicState3ColorBlendAdvanced(), + extendedDynamicState3ProvokingVertexMode(), + extendedDynamicState3LineRasterizationMode(), + extendedDynamicState3LineStippleEnable(), + extendedDynamicState3DepthClipNegativeOneToOne(), + extendedDynamicState3ViewportWScalingEnable(), + extendedDynamicState3ViewportSwizzle(), + extendedDynamicState3CoverageToColorEnable(), + extendedDynamicState3CoverageToColorLocation(), + extendedDynamicState3CoverageModulationMode(), + extendedDynamicState3CoverageModulationTableEnable(), + extendedDynamicState3CoverageModulationTable(), + extendedDynamicState3CoverageReductionMode(), + extendedDynamicState3RepresentativeFragmentTestEnable(), + extendedDynamicState3ShadingRateImageEnable() {} + +safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT( + const safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT& copy_src) { + sType = copy_src.sType; + extendedDynamicState3TessellationDomainOrigin = copy_src.extendedDynamicState3TessellationDomainOrigin; + extendedDynamicState3DepthClampEnable = copy_src.extendedDynamicState3DepthClampEnable; + extendedDynamicState3PolygonMode = copy_src.extendedDynamicState3PolygonMode; + extendedDynamicState3RasterizationSamples = copy_src.extendedDynamicState3RasterizationSamples; + extendedDynamicState3SampleMask = copy_src.extendedDynamicState3SampleMask; + extendedDynamicState3AlphaToCoverageEnable = copy_src.extendedDynamicState3AlphaToCoverageEnable; + extendedDynamicState3AlphaToOneEnable = copy_src.extendedDynamicState3AlphaToOneEnable; + extendedDynamicState3LogicOpEnable = copy_src.extendedDynamicState3LogicOpEnable; + extendedDynamicState3ColorBlendEnable = copy_src.extendedDynamicState3ColorBlendEnable; + extendedDynamicState3ColorBlendEquation = copy_src.extendedDynamicState3ColorBlendEquation; + extendedDynamicState3ColorWriteMask = copy_src.extendedDynamicState3ColorWriteMask; + extendedDynamicState3RasterizationStream = copy_src.extendedDynamicState3RasterizationStream; + extendedDynamicState3ConservativeRasterizationMode = copy_src.extendedDynamicState3ConservativeRasterizationMode; + extendedDynamicState3ExtraPrimitiveOverestimationSize = copy_src.extendedDynamicState3ExtraPrimitiveOverestimationSize; + extendedDynamicState3DepthClipEnable = copy_src.extendedDynamicState3DepthClipEnable; + extendedDynamicState3SampleLocationsEnable = copy_src.extendedDynamicState3SampleLocationsEnable; + extendedDynamicState3ColorBlendAdvanced = copy_src.extendedDynamicState3ColorBlendAdvanced; + extendedDynamicState3ProvokingVertexMode = copy_src.extendedDynamicState3ProvokingVertexMode; + extendedDynamicState3LineRasterizationMode = copy_src.extendedDynamicState3LineRasterizationMode; + extendedDynamicState3LineStippleEnable = copy_src.extendedDynamicState3LineStippleEnable; + extendedDynamicState3DepthClipNegativeOneToOne = copy_src.extendedDynamicState3DepthClipNegativeOneToOne; + extendedDynamicState3ViewportWScalingEnable = copy_src.extendedDynamicState3ViewportWScalingEnable; + extendedDynamicState3ViewportSwizzle = copy_src.extendedDynamicState3ViewportSwizzle; + extendedDynamicState3CoverageToColorEnable = copy_src.extendedDynamicState3CoverageToColorEnable; + extendedDynamicState3CoverageToColorLocation = copy_src.extendedDynamicState3CoverageToColorLocation; + extendedDynamicState3CoverageModulationMode = copy_src.extendedDynamicState3CoverageModulationMode; + extendedDynamicState3CoverageModulationTableEnable = copy_src.extendedDynamicState3CoverageModulationTableEnable; + extendedDynamicState3CoverageModulationTable = copy_src.extendedDynamicState3CoverageModulationTable; + extendedDynamicState3CoverageReductionMode = copy_src.extendedDynamicState3CoverageReductionMode; + extendedDynamicState3RepresentativeFragmentTestEnable = copy_src.extendedDynamicState3RepresentativeFragmentTestEnable; + extendedDynamicState3ShadingRateImageEnable = copy_src.extendedDynamicState3ShadingRateImageEnable; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT& safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::operator=( + const safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + extendedDynamicState3TessellationDomainOrigin = copy_src.extendedDynamicState3TessellationDomainOrigin; + extendedDynamicState3DepthClampEnable = copy_src.extendedDynamicState3DepthClampEnable; + extendedDynamicState3PolygonMode = copy_src.extendedDynamicState3PolygonMode; + extendedDynamicState3RasterizationSamples = copy_src.extendedDynamicState3RasterizationSamples; + extendedDynamicState3SampleMask = copy_src.extendedDynamicState3SampleMask; + extendedDynamicState3AlphaToCoverageEnable = copy_src.extendedDynamicState3AlphaToCoverageEnable; + extendedDynamicState3AlphaToOneEnable = copy_src.extendedDynamicState3AlphaToOneEnable; + extendedDynamicState3LogicOpEnable = copy_src.extendedDynamicState3LogicOpEnable; + extendedDynamicState3ColorBlendEnable = copy_src.extendedDynamicState3ColorBlendEnable; + extendedDynamicState3ColorBlendEquation = copy_src.extendedDynamicState3ColorBlendEquation; + extendedDynamicState3ColorWriteMask = copy_src.extendedDynamicState3ColorWriteMask; + extendedDynamicState3RasterizationStream = copy_src.extendedDynamicState3RasterizationStream; + extendedDynamicState3ConservativeRasterizationMode = copy_src.extendedDynamicState3ConservativeRasterizationMode; + extendedDynamicState3ExtraPrimitiveOverestimationSize = copy_src.extendedDynamicState3ExtraPrimitiveOverestimationSize; + extendedDynamicState3DepthClipEnable = copy_src.extendedDynamicState3DepthClipEnable; + extendedDynamicState3SampleLocationsEnable = copy_src.extendedDynamicState3SampleLocationsEnable; + extendedDynamicState3ColorBlendAdvanced = copy_src.extendedDynamicState3ColorBlendAdvanced; + extendedDynamicState3ProvokingVertexMode = copy_src.extendedDynamicState3ProvokingVertexMode; + extendedDynamicState3LineRasterizationMode = copy_src.extendedDynamicState3LineRasterizationMode; + extendedDynamicState3LineStippleEnable = copy_src.extendedDynamicState3LineStippleEnable; + extendedDynamicState3DepthClipNegativeOneToOne = copy_src.extendedDynamicState3DepthClipNegativeOneToOne; + extendedDynamicState3ViewportWScalingEnable = copy_src.extendedDynamicState3ViewportWScalingEnable; + extendedDynamicState3ViewportSwizzle = copy_src.extendedDynamicState3ViewportSwizzle; + extendedDynamicState3CoverageToColorEnable = copy_src.extendedDynamicState3CoverageToColorEnable; + extendedDynamicState3CoverageToColorLocation = copy_src.extendedDynamicState3CoverageToColorLocation; + extendedDynamicState3CoverageModulationMode = copy_src.extendedDynamicState3CoverageModulationMode; + extendedDynamicState3CoverageModulationTableEnable = copy_src.extendedDynamicState3CoverageModulationTableEnable; + extendedDynamicState3CoverageModulationTable = copy_src.extendedDynamicState3CoverageModulationTable; + extendedDynamicState3CoverageReductionMode = copy_src.extendedDynamicState3CoverageReductionMode; + extendedDynamicState3RepresentativeFragmentTestEnable = copy_src.extendedDynamicState3RepresentativeFragmentTestEnable; + extendedDynamicState3ShadingRateImageEnable = copy_src.extendedDynamicState3ShadingRateImageEnable; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::~safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::initialize( + const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + extendedDynamicState3TessellationDomainOrigin = in_struct->extendedDynamicState3TessellationDomainOrigin; + extendedDynamicState3DepthClampEnable = in_struct->extendedDynamicState3DepthClampEnable; + extendedDynamicState3PolygonMode = in_struct->extendedDynamicState3PolygonMode; + extendedDynamicState3RasterizationSamples = in_struct->extendedDynamicState3RasterizationSamples; + extendedDynamicState3SampleMask = in_struct->extendedDynamicState3SampleMask; + extendedDynamicState3AlphaToCoverageEnable = in_struct->extendedDynamicState3AlphaToCoverageEnable; + extendedDynamicState3AlphaToOneEnable = in_struct->extendedDynamicState3AlphaToOneEnable; + extendedDynamicState3LogicOpEnable = in_struct->extendedDynamicState3LogicOpEnable; + extendedDynamicState3ColorBlendEnable = in_struct->extendedDynamicState3ColorBlendEnable; + extendedDynamicState3ColorBlendEquation = in_struct->extendedDynamicState3ColorBlendEquation; + extendedDynamicState3ColorWriteMask = in_struct->extendedDynamicState3ColorWriteMask; + extendedDynamicState3RasterizationStream = in_struct->extendedDynamicState3RasterizationStream; + extendedDynamicState3ConservativeRasterizationMode = in_struct->extendedDynamicState3ConservativeRasterizationMode; + extendedDynamicState3ExtraPrimitiveOverestimationSize = in_struct->extendedDynamicState3ExtraPrimitiveOverestimationSize; + extendedDynamicState3DepthClipEnable = in_struct->extendedDynamicState3DepthClipEnable; + extendedDynamicState3SampleLocationsEnable = in_struct->extendedDynamicState3SampleLocationsEnable; + extendedDynamicState3ColorBlendAdvanced = in_struct->extendedDynamicState3ColorBlendAdvanced; + extendedDynamicState3ProvokingVertexMode = in_struct->extendedDynamicState3ProvokingVertexMode; + extendedDynamicState3LineRasterizationMode = in_struct->extendedDynamicState3LineRasterizationMode; + extendedDynamicState3LineStippleEnable = in_struct->extendedDynamicState3LineStippleEnable; + extendedDynamicState3DepthClipNegativeOneToOne = in_struct->extendedDynamicState3DepthClipNegativeOneToOne; + extendedDynamicState3ViewportWScalingEnable = in_struct->extendedDynamicState3ViewportWScalingEnable; + extendedDynamicState3ViewportSwizzle = in_struct->extendedDynamicState3ViewportSwizzle; + extendedDynamicState3CoverageToColorEnable = in_struct->extendedDynamicState3CoverageToColorEnable; + extendedDynamicState3CoverageToColorLocation = in_struct->extendedDynamicState3CoverageToColorLocation; + extendedDynamicState3CoverageModulationMode = in_struct->extendedDynamicState3CoverageModulationMode; + extendedDynamicState3CoverageModulationTableEnable = in_struct->extendedDynamicState3CoverageModulationTableEnable; + extendedDynamicState3CoverageModulationTable = in_struct->extendedDynamicState3CoverageModulationTable; + extendedDynamicState3CoverageReductionMode = in_struct->extendedDynamicState3CoverageReductionMode; + extendedDynamicState3RepresentativeFragmentTestEnable = in_struct->extendedDynamicState3RepresentativeFragmentTestEnable; + extendedDynamicState3ShadingRateImageEnable = in_struct->extendedDynamicState3ShadingRateImageEnable; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::initialize( + const safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + extendedDynamicState3TessellationDomainOrigin = copy_src->extendedDynamicState3TessellationDomainOrigin; + extendedDynamicState3DepthClampEnable = copy_src->extendedDynamicState3DepthClampEnable; + extendedDynamicState3PolygonMode = copy_src->extendedDynamicState3PolygonMode; + extendedDynamicState3RasterizationSamples = copy_src->extendedDynamicState3RasterizationSamples; + extendedDynamicState3SampleMask = copy_src->extendedDynamicState3SampleMask; + extendedDynamicState3AlphaToCoverageEnable = copy_src->extendedDynamicState3AlphaToCoverageEnable; + extendedDynamicState3AlphaToOneEnable = copy_src->extendedDynamicState3AlphaToOneEnable; + extendedDynamicState3LogicOpEnable = copy_src->extendedDynamicState3LogicOpEnable; + extendedDynamicState3ColorBlendEnable = copy_src->extendedDynamicState3ColorBlendEnable; + extendedDynamicState3ColorBlendEquation = copy_src->extendedDynamicState3ColorBlendEquation; + extendedDynamicState3ColorWriteMask = copy_src->extendedDynamicState3ColorWriteMask; + extendedDynamicState3RasterizationStream = copy_src->extendedDynamicState3RasterizationStream; + extendedDynamicState3ConservativeRasterizationMode = copy_src->extendedDynamicState3ConservativeRasterizationMode; + extendedDynamicState3ExtraPrimitiveOverestimationSize = copy_src->extendedDynamicState3ExtraPrimitiveOverestimationSize; + extendedDynamicState3DepthClipEnable = copy_src->extendedDynamicState3DepthClipEnable; + extendedDynamicState3SampleLocationsEnable = copy_src->extendedDynamicState3SampleLocationsEnable; + extendedDynamicState3ColorBlendAdvanced = copy_src->extendedDynamicState3ColorBlendAdvanced; + extendedDynamicState3ProvokingVertexMode = copy_src->extendedDynamicState3ProvokingVertexMode; + extendedDynamicState3LineRasterizationMode = copy_src->extendedDynamicState3LineRasterizationMode; + extendedDynamicState3LineStippleEnable = copy_src->extendedDynamicState3LineStippleEnable; + extendedDynamicState3DepthClipNegativeOneToOne = copy_src->extendedDynamicState3DepthClipNegativeOneToOne; + extendedDynamicState3ViewportWScalingEnable = copy_src->extendedDynamicState3ViewportWScalingEnable; + extendedDynamicState3ViewportSwizzle = copy_src->extendedDynamicState3ViewportSwizzle; + extendedDynamicState3CoverageToColorEnable = copy_src->extendedDynamicState3CoverageToColorEnable; + extendedDynamicState3CoverageToColorLocation = copy_src->extendedDynamicState3CoverageToColorLocation; + extendedDynamicState3CoverageModulationMode = copy_src->extendedDynamicState3CoverageModulationMode; + extendedDynamicState3CoverageModulationTableEnable = copy_src->extendedDynamicState3CoverageModulationTableEnable; + extendedDynamicState3CoverageModulationTable = copy_src->extendedDynamicState3CoverageModulationTable; + extendedDynamicState3CoverageReductionMode = copy_src->extendedDynamicState3CoverageReductionMode; + extendedDynamicState3RepresentativeFragmentTestEnable = copy_src->extendedDynamicState3RepresentativeFragmentTestEnable; + extendedDynamicState3ShadingRateImageEnable = copy_src->extendedDynamicState3ShadingRateImageEnable; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT::safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT( + const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), dynamicPrimitiveTopologyUnrestricted(in_struct->dynamicPrimitiveTopologyUnrestricted) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT::safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT), + pNext(nullptr), + dynamicPrimitiveTopologyUnrestricted() {} + +safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT::safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT( + const safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT& copy_src) { + sType = copy_src.sType; + dynamicPrimitiveTopologyUnrestricted = copy_src.dynamicPrimitiveTopologyUnrestricted; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT& safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT::operator=( + const safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + dynamicPrimitiveTopologyUnrestricted = copy_src.dynamicPrimitiveTopologyUnrestricted; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT::~safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT::initialize( + const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + dynamicPrimitiveTopologyUnrestricted = in_struct->dynamicPrimitiveTopologyUnrestricted; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT::initialize( + const safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + dynamicPrimitiveTopologyUnrestricted = copy_src->dynamicPrimitiveTopologyUnrestricted; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT::safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT( + const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), subpassMergeFeedback(in_struct->subpassMergeFeedback) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT::safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT), pNext(nullptr), subpassMergeFeedback() {} + +safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT::safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT( + const safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& copy_src) { + sType = copy_src.sType; + subpassMergeFeedback = copy_src.subpassMergeFeedback; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT::operator=( + const safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + subpassMergeFeedback = copy_src.subpassMergeFeedback; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT::~safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT::initialize( + const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + subpassMergeFeedback = in_struct->subpassMergeFeedback; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT::initialize( + const safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + subpassMergeFeedback = copy_src->subpassMergeFeedback; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkRenderPassCreationControlEXT::safe_VkRenderPassCreationControlEXT(const VkRenderPassCreationControlEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), disallowMerging(in_struct->disallowMerging) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkRenderPassCreationControlEXT::safe_VkRenderPassCreationControlEXT() + : sType(VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT), pNext(nullptr), disallowMerging() {} + +safe_VkRenderPassCreationControlEXT::safe_VkRenderPassCreationControlEXT(const safe_VkRenderPassCreationControlEXT& copy_src) { + sType = copy_src.sType; + disallowMerging = copy_src.disallowMerging; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkRenderPassCreationControlEXT& safe_VkRenderPassCreationControlEXT::operator=( + const safe_VkRenderPassCreationControlEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + disallowMerging = copy_src.disallowMerging; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkRenderPassCreationControlEXT::~safe_VkRenderPassCreationControlEXT() { FreePnextChain(pNext); } + +void safe_VkRenderPassCreationControlEXT::initialize(const VkRenderPassCreationControlEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + disallowMerging = in_struct->disallowMerging; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkRenderPassCreationControlEXT::initialize(const safe_VkRenderPassCreationControlEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + disallowMerging = copy_src->disallowMerging; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkRenderPassCreationFeedbackCreateInfoEXT::safe_VkRenderPassCreationFeedbackCreateInfoEXT( + const VkRenderPassCreationFeedbackCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pRenderPassFeedback(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pRenderPassFeedback) { + pRenderPassFeedback = new VkRenderPassCreationFeedbackInfoEXT(*in_struct->pRenderPassFeedback); + } +} + +safe_VkRenderPassCreationFeedbackCreateInfoEXT::safe_VkRenderPassCreationFeedbackCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT), pNext(nullptr), pRenderPassFeedback(nullptr) {} + +safe_VkRenderPassCreationFeedbackCreateInfoEXT::safe_VkRenderPassCreationFeedbackCreateInfoEXT( + const safe_VkRenderPassCreationFeedbackCreateInfoEXT& copy_src) { + sType = copy_src.sType; + pRenderPassFeedback = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pRenderPassFeedback) { + pRenderPassFeedback = new VkRenderPassCreationFeedbackInfoEXT(*copy_src.pRenderPassFeedback); + } +} + +safe_VkRenderPassCreationFeedbackCreateInfoEXT& safe_VkRenderPassCreationFeedbackCreateInfoEXT::operator=( + const safe_VkRenderPassCreationFeedbackCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pRenderPassFeedback) delete pRenderPassFeedback; + FreePnextChain(pNext); + + sType = copy_src.sType; + pRenderPassFeedback = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pRenderPassFeedback) { + pRenderPassFeedback = new VkRenderPassCreationFeedbackInfoEXT(*copy_src.pRenderPassFeedback); + } + + return *this; +} + +safe_VkRenderPassCreationFeedbackCreateInfoEXT::~safe_VkRenderPassCreationFeedbackCreateInfoEXT() { + if (pRenderPassFeedback) delete pRenderPassFeedback; + FreePnextChain(pNext); +} + +void safe_VkRenderPassCreationFeedbackCreateInfoEXT::initialize(const VkRenderPassCreationFeedbackCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pRenderPassFeedback) delete pRenderPassFeedback; + FreePnextChain(pNext); + sType = in_struct->sType; + pRenderPassFeedback = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pRenderPassFeedback) { + pRenderPassFeedback = new VkRenderPassCreationFeedbackInfoEXT(*in_struct->pRenderPassFeedback); + } +} + +void safe_VkRenderPassCreationFeedbackCreateInfoEXT::initialize(const safe_VkRenderPassCreationFeedbackCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pRenderPassFeedback = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pRenderPassFeedback) { + pRenderPassFeedback = new VkRenderPassCreationFeedbackInfoEXT(*copy_src->pRenderPassFeedback); + } +} + +safe_VkRenderPassSubpassFeedbackCreateInfoEXT::safe_VkRenderPassSubpassFeedbackCreateInfoEXT( + const VkRenderPassSubpassFeedbackCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pSubpassFeedback(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pSubpassFeedback) { + pSubpassFeedback = new VkRenderPassSubpassFeedbackInfoEXT(*in_struct->pSubpassFeedback); + } +} + +safe_VkRenderPassSubpassFeedbackCreateInfoEXT::safe_VkRenderPassSubpassFeedbackCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT), pNext(nullptr), pSubpassFeedback(nullptr) {} + +safe_VkRenderPassSubpassFeedbackCreateInfoEXT::safe_VkRenderPassSubpassFeedbackCreateInfoEXT( + const safe_VkRenderPassSubpassFeedbackCreateInfoEXT& copy_src) { + sType = copy_src.sType; + pSubpassFeedback = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pSubpassFeedback) { + pSubpassFeedback = new VkRenderPassSubpassFeedbackInfoEXT(*copy_src.pSubpassFeedback); + } +} + +safe_VkRenderPassSubpassFeedbackCreateInfoEXT& safe_VkRenderPassSubpassFeedbackCreateInfoEXT::operator=( + const safe_VkRenderPassSubpassFeedbackCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pSubpassFeedback) delete pSubpassFeedback; + FreePnextChain(pNext); + + sType = copy_src.sType; + pSubpassFeedback = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pSubpassFeedback) { + pSubpassFeedback = new VkRenderPassSubpassFeedbackInfoEXT(*copy_src.pSubpassFeedback); + } + + return *this; +} + +safe_VkRenderPassSubpassFeedbackCreateInfoEXT::~safe_VkRenderPassSubpassFeedbackCreateInfoEXT() { + if (pSubpassFeedback) delete pSubpassFeedback; + FreePnextChain(pNext); +} + +void safe_VkRenderPassSubpassFeedbackCreateInfoEXT::initialize(const VkRenderPassSubpassFeedbackCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pSubpassFeedback) delete pSubpassFeedback; + FreePnextChain(pNext); + sType = in_struct->sType; + pSubpassFeedback = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pSubpassFeedback) { + pSubpassFeedback = new VkRenderPassSubpassFeedbackInfoEXT(*in_struct->pSubpassFeedback); + } +} + +void safe_VkRenderPassSubpassFeedbackCreateInfoEXT::initialize(const safe_VkRenderPassSubpassFeedbackCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pSubpassFeedback = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pSubpassFeedback) { + pSubpassFeedback = new VkRenderPassSubpassFeedbackInfoEXT(*copy_src->pSubpassFeedback); + } +} + +safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT::safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT( + const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), shaderModuleIdentifier(in_struct->shaderModuleIdentifier) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT::safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT), pNext(nullptr), shaderModuleIdentifier() {} + +safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT::safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT( + const safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& copy_src) { + sType = copy_src.sType; + shaderModuleIdentifier = copy_src.shaderModuleIdentifier; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT::operator=( + const safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderModuleIdentifier = copy_src.shaderModuleIdentifier; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT::~safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT::initialize( + const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderModuleIdentifier = in_struct->shaderModuleIdentifier; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT::initialize( + const safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderModuleIdentifier = copy_src->shaderModuleIdentifier; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT::safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT( + const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + shaderModuleIdentifierAlgorithmUUID[i] = in_struct->shaderModuleIdentifierAlgorithmUUID[i]; + } +} + +safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT::safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT), pNext(nullptr) {} + +safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT::safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT( + const safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& copy_src) { + sType = copy_src.sType; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + shaderModuleIdentifierAlgorithmUUID[i] = copy_src.shaderModuleIdentifierAlgorithmUUID[i]; + } +} + +safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT::operator=( + const safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + shaderModuleIdentifierAlgorithmUUID[i] = copy_src.shaderModuleIdentifierAlgorithmUUID[i]; + } + + return *this; +} + +safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT::~safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT::initialize( + const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + shaderModuleIdentifierAlgorithmUUID[i] = in_struct->shaderModuleIdentifierAlgorithmUUID[i]; + } +} + +void safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT::initialize( + const safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + shaderModuleIdentifierAlgorithmUUID[i] = copy_src->shaderModuleIdentifierAlgorithmUUID[i]; + } +} + +safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT::safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT( + const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), identifierSize(in_struct->identifierSize), pIdentifier(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pIdentifier) { + pIdentifier = new uint8_t[in_struct->identifierSize]; + memcpy((void*)pIdentifier, (void*)in_struct->pIdentifier, sizeof(uint8_t) * in_struct->identifierSize); + } +} + +safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT::safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT), + pNext(nullptr), + identifierSize(), + pIdentifier(nullptr) {} + +safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT::safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT( + const safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT& copy_src) { + sType = copy_src.sType; + identifierSize = copy_src.identifierSize; + pIdentifier = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pIdentifier) { + pIdentifier = new uint8_t[copy_src.identifierSize]; + memcpy((void*)pIdentifier, (void*)copy_src.pIdentifier, sizeof(uint8_t) * copy_src.identifierSize); + } +} + +safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT& safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT::operator=( + const safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pIdentifier) delete[] pIdentifier; + FreePnextChain(pNext); + + sType = copy_src.sType; + identifierSize = copy_src.identifierSize; + pIdentifier = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pIdentifier) { + pIdentifier = new uint8_t[copy_src.identifierSize]; + memcpy((void*)pIdentifier, (void*)copy_src.pIdentifier, sizeof(uint8_t) * copy_src.identifierSize); + } + + return *this; +} + +safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT::~safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT() { + if (pIdentifier) delete[] pIdentifier; + FreePnextChain(pNext); +} + +void safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT::initialize( + const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pIdentifier) delete[] pIdentifier; + FreePnextChain(pNext); + sType = in_struct->sType; + identifierSize = in_struct->identifierSize; + pIdentifier = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pIdentifier) { + pIdentifier = new uint8_t[in_struct->identifierSize]; + memcpy((void*)pIdentifier, (void*)in_struct->pIdentifier, sizeof(uint8_t) * in_struct->identifierSize); + } +} + +void safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT::initialize( + const safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + identifierSize = copy_src->identifierSize; + pIdentifier = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pIdentifier) { + pIdentifier = new uint8_t[copy_src->identifierSize]; + memcpy((void*)pIdentifier, (void*)copy_src->pIdentifier, sizeof(uint8_t) * copy_src->identifierSize); + } +} + +safe_VkShaderModuleIdentifierEXT::safe_VkShaderModuleIdentifierEXT(const VkShaderModuleIdentifierEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), identifierSize(in_struct->identifierSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; ++i) { + identifier[i] = in_struct->identifier[i]; + } +} + +safe_VkShaderModuleIdentifierEXT::safe_VkShaderModuleIdentifierEXT() + : sType(VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT), pNext(nullptr), identifierSize() {} + +safe_VkShaderModuleIdentifierEXT::safe_VkShaderModuleIdentifierEXT(const safe_VkShaderModuleIdentifierEXT& copy_src) { + sType = copy_src.sType; + identifierSize = copy_src.identifierSize; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; ++i) { + identifier[i] = copy_src.identifier[i]; + } +} + +safe_VkShaderModuleIdentifierEXT& safe_VkShaderModuleIdentifierEXT::operator=(const safe_VkShaderModuleIdentifierEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + identifierSize = copy_src.identifierSize; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; ++i) { + identifier[i] = copy_src.identifier[i]; + } + + return *this; +} + +safe_VkShaderModuleIdentifierEXT::~safe_VkShaderModuleIdentifierEXT() { FreePnextChain(pNext); } + +void safe_VkShaderModuleIdentifierEXT::initialize(const VkShaderModuleIdentifierEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + identifierSize = in_struct->identifierSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; ++i) { + identifier[i] = in_struct->identifier[i]; + } +} + +void safe_VkShaderModuleIdentifierEXT::initialize(const safe_VkShaderModuleIdentifierEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + identifierSize = copy_src->identifierSize; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; ++i) { + identifier[i] = copy_src->identifier[i]; + } +} + +safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT::safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT( + const VkPhysicalDeviceLegacyDitheringFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), legacyDithering(in_struct->legacyDithering) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT::safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT), pNext(nullptr), legacyDithering() {} + +safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT::safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT( + const safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT& copy_src) { + sType = copy_src.sType; + legacyDithering = copy_src.legacyDithering; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT& safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT::operator=( + const safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + legacyDithering = copy_src.legacyDithering; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT::~safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT::initialize(const VkPhysicalDeviceLegacyDitheringFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + legacyDithering = in_struct->legacyDithering; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT::initialize(const safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + legacyDithering = copy_src->legacyDithering; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT( + const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), pipelineProtectedAccess(in_struct->pipelineProtectedAccess) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT), pNext(nullptr), pipelineProtectedAccess() {} + +safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT( + const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& copy_src) { + sType = copy_src.sType; + pipelineProtectedAccess = copy_src.pipelineProtectedAccess; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::operator=( + const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pipelineProtectedAccess = copy_src.pipelineProtectedAccess; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::~safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::initialize( + const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pipelineProtectedAccess = in_struct->pipelineProtectedAccess; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::initialize( + const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipelineProtectedAccess = copy_src->pipelineProtectedAccess; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderObjectFeaturesEXT::safe_VkPhysicalDeviceShaderObjectFeaturesEXT( + const VkPhysicalDeviceShaderObjectFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), shaderObject(in_struct->shaderObject) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderObjectFeaturesEXT::safe_VkPhysicalDeviceShaderObjectFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT), pNext(nullptr), shaderObject() {} + +safe_VkPhysicalDeviceShaderObjectFeaturesEXT::safe_VkPhysicalDeviceShaderObjectFeaturesEXT( + const safe_VkPhysicalDeviceShaderObjectFeaturesEXT& copy_src) { + sType = copy_src.sType; + shaderObject = copy_src.shaderObject; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderObjectFeaturesEXT& safe_VkPhysicalDeviceShaderObjectFeaturesEXT::operator=( + const safe_VkPhysicalDeviceShaderObjectFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderObject = copy_src.shaderObject; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderObjectFeaturesEXT::~safe_VkPhysicalDeviceShaderObjectFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderObjectFeaturesEXT::initialize(const VkPhysicalDeviceShaderObjectFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderObject = in_struct->shaderObject; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderObjectFeaturesEXT::initialize(const safe_VkPhysicalDeviceShaderObjectFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderObject = copy_src->shaderObject; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderObjectPropertiesEXT::safe_VkPhysicalDeviceShaderObjectPropertiesEXT( + const VkPhysicalDeviceShaderObjectPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), shaderBinaryVersion(in_struct->shaderBinaryVersion) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + shaderBinaryUUID[i] = in_struct->shaderBinaryUUID[i]; + } +} + +safe_VkPhysicalDeviceShaderObjectPropertiesEXT::safe_VkPhysicalDeviceShaderObjectPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT), pNext(nullptr), shaderBinaryVersion() {} + +safe_VkPhysicalDeviceShaderObjectPropertiesEXT::safe_VkPhysicalDeviceShaderObjectPropertiesEXT( + const safe_VkPhysicalDeviceShaderObjectPropertiesEXT& copy_src) { + sType = copy_src.sType; + shaderBinaryVersion = copy_src.shaderBinaryVersion; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + shaderBinaryUUID[i] = copy_src.shaderBinaryUUID[i]; + } +} + +safe_VkPhysicalDeviceShaderObjectPropertiesEXT& safe_VkPhysicalDeviceShaderObjectPropertiesEXT::operator=( + const safe_VkPhysicalDeviceShaderObjectPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderBinaryVersion = copy_src.shaderBinaryVersion; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + shaderBinaryUUID[i] = copy_src.shaderBinaryUUID[i]; + } + + return *this; +} + +safe_VkPhysicalDeviceShaderObjectPropertiesEXT::~safe_VkPhysicalDeviceShaderObjectPropertiesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderObjectPropertiesEXT::initialize(const VkPhysicalDeviceShaderObjectPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderBinaryVersion = in_struct->shaderBinaryVersion; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + shaderBinaryUUID[i] = in_struct->shaderBinaryUUID[i]; + } +} + +void safe_VkPhysicalDeviceShaderObjectPropertiesEXT::initialize(const safe_VkPhysicalDeviceShaderObjectPropertiesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderBinaryVersion = copy_src->shaderBinaryVersion; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) { + shaderBinaryUUID[i] = copy_src->shaderBinaryUUID[i]; + } +} + +safe_VkShaderCreateInfoEXT::safe_VkShaderCreateInfoEXT(const VkShaderCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + stage(in_struct->stage), + nextStage(in_struct->nextStage), + codeType(in_struct->codeType), + codeSize(in_struct->codeSize), + pCode(in_struct->pCode), + setLayoutCount(in_struct->setLayoutCount), + pSetLayouts(nullptr), + pushConstantRangeCount(in_struct->pushConstantRangeCount), + pPushConstantRanges(nullptr), + pSpecializationInfo(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + pName = SafeStringCopy(in_struct->pName); + if (setLayoutCount && in_struct->pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[setLayoutCount]; + for (uint32_t i = 0; i < setLayoutCount; ++i) { + pSetLayouts[i] = in_struct->pSetLayouts[i]; + } + } + + if (in_struct->pPushConstantRanges) { + pPushConstantRanges = new VkPushConstantRange[in_struct->pushConstantRangeCount]; + memcpy((void*)pPushConstantRanges, (void*)in_struct->pPushConstantRanges, + sizeof(VkPushConstantRange) * in_struct->pushConstantRangeCount); + } + if (in_struct->pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(in_struct->pSpecializationInfo); +} + +safe_VkShaderCreateInfoEXT::safe_VkShaderCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT), + pNext(nullptr), + flags(), + stage(), + nextStage(), + codeType(), + codeSize(), + pCode(nullptr), + pName(nullptr), + setLayoutCount(), + pSetLayouts(nullptr), + pushConstantRangeCount(), + pPushConstantRanges(nullptr), + pSpecializationInfo(nullptr) {} + +safe_VkShaderCreateInfoEXT::safe_VkShaderCreateInfoEXT(const safe_VkShaderCreateInfoEXT& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + stage = copy_src.stage; + nextStage = copy_src.nextStage; + codeType = copy_src.codeType; + codeSize = copy_src.codeSize; + pCode = copy_src.pCode; + setLayoutCount = copy_src.setLayoutCount; + pSetLayouts = nullptr; + pushConstantRangeCount = copy_src.pushConstantRangeCount; + pPushConstantRanges = nullptr; + pSpecializationInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + pName = SafeStringCopy(copy_src.pName); + if (setLayoutCount && copy_src.pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[setLayoutCount]; + for (uint32_t i = 0; i < setLayoutCount; ++i) { + pSetLayouts[i] = copy_src.pSetLayouts[i]; + } + } + + if (copy_src.pPushConstantRanges) { + pPushConstantRanges = new VkPushConstantRange[copy_src.pushConstantRangeCount]; + memcpy((void*)pPushConstantRanges, (void*)copy_src.pPushConstantRanges, + sizeof(VkPushConstantRange) * copy_src.pushConstantRangeCount); + } + if (copy_src.pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(*copy_src.pSpecializationInfo); +} + +safe_VkShaderCreateInfoEXT& safe_VkShaderCreateInfoEXT::operator=(const safe_VkShaderCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pName) delete[] pName; + if (pSetLayouts) delete[] pSetLayouts; + if (pPushConstantRanges) delete[] pPushConstantRanges; + if (pSpecializationInfo) delete pSpecializationInfo; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + stage = copy_src.stage; + nextStage = copy_src.nextStage; + codeType = copy_src.codeType; + codeSize = copy_src.codeSize; + pCode = copy_src.pCode; + setLayoutCount = copy_src.setLayoutCount; + pSetLayouts = nullptr; + pushConstantRangeCount = copy_src.pushConstantRangeCount; + pPushConstantRanges = nullptr; + pSpecializationInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + pName = SafeStringCopy(copy_src.pName); + if (setLayoutCount && copy_src.pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[setLayoutCount]; + for (uint32_t i = 0; i < setLayoutCount; ++i) { + pSetLayouts[i] = copy_src.pSetLayouts[i]; + } + } + + if (copy_src.pPushConstantRanges) { + pPushConstantRanges = new VkPushConstantRange[copy_src.pushConstantRangeCount]; + memcpy((void*)pPushConstantRanges, (void*)copy_src.pPushConstantRanges, + sizeof(VkPushConstantRange) * copy_src.pushConstantRangeCount); + } + if (copy_src.pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(*copy_src.pSpecializationInfo); + + return *this; +} + +safe_VkShaderCreateInfoEXT::~safe_VkShaderCreateInfoEXT() { + if (pName) delete[] pName; + if (pSetLayouts) delete[] pSetLayouts; + if (pPushConstantRanges) delete[] pPushConstantRanges; + if (pSpecializationInfo) delete pSpecializationInfo; + FreePnextChain(pNext); +} + +void safe_VkShaderCreateInfoEXT::initialize(const VkShaderCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pName) delete[] pName; + if (pSetLayouts) delete[] pSetLayouts; + if (pPushConstantRanges) delete[] pPushConstantRanges; + if (pSpecializationInfo) delete pSpecializationInfo; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + stage = in_struct->stage; + nextStage = in_struct->nextStage; + codeType = in_struct->codeType; + codeSize = in_struct->codeSize; + pCode = in_struct->pCode; + setLayoutCount = in_struct->setLayoutCount; + pSetLayouts = nullptr; + pushConstantRangeCount = in_struct->pushConstantRangeCount; + pPushConstantRanges = nullptr; + pSpecializationInfo = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + pName = SafeStringCopy(in_struct->pName); + if (setLayoutCount && in_struct->pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[setLayoutCount]; + for (uint32_t i = 0; i < setLayoutCount; ++i) { + pSetLayouts[i] = in_struct->pSetLayouts[i]; + } + } + + if (in_struct->pPushConstantRanges) { + pPushConstantRanges = new VkPushConstantRange[in_struct->pushConstantRangeCount]; + memcpy((void*)pPushConstantRanges, (void*)in_struct->pPushConstantRanges, + sizeof(VkPushConstantRange) * in_struct->pushConstantRangeCount); + } + if (in_struct->pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(in_struct->pSpecializationInfo); +} + +void safe_VkShaderCreateInfoEXT::initialize(const safe_VkShaderCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + stage = copy_src->stage; + nextStage = copy_src->nextStage; + codeType = copy_src->codeType; + codeSize = copy_src->codeSize; + pCode = copy_src->pCode; + setLayoutCount = copy_src->setLayoutCount; + pSetLayouts = nullptr; + pushConstantRangeCount = copy_src->pushConstantRangeCount; + pPushConstantRanges = nullptr; + pSpecializationInfo = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + pName = SafeStringCopy(copy_src->pName); + if (setLayoutCount && copy_src->pSetLayouts) { + pSetLayouts = new VkDescriptorSetLayout[setLayoutCount]; + for (uint32_t i = 0; i < setLayoutCount; ++i) { + pSetLayouts[i] = copy_src->pSetLayouts[i]; + } + } + + if (copy_src->pPushConstantRanges) { + pPushConstantRanges = new VkPushConstantRange[copy_src->pushConstantRangeCount]; + memcpy((void*)pPushConstantRanges, (void*)copy_src->pPushConstantRanges, + sizeof(VkPushConstantRange) * copy_src->pushConstantRangeCount); + } + if (copy_src->pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(*copy_src->pSpecializationInfo); +} + +safe_VkLayerSettingEXT::safe_VkLayerSettingEXT(const VkLayerSettingEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) + : type(in_struct->type), valueCount(in_struct->valueCount), pValues(in_struct->pValues) { + pLayerName = SafeStringCopy(in_struct->pLayerName); + pSettingName = SafeStringCopy(in_struct->pSettingName); +} + +safe_VkLayerSettingEXT::safe_VkLayerSettingEXT() + : pLayerName(nullptr), pSettingName(nullptr), type(), valueCount(), pValues(nullptr) {} + +safe_VkLayerSettingEXT::safe_VkLayerSettingEXT(const safe_VkLayerSettingEXT& copy_src) { + type = copy_src.type; + valueCount = copy_src.valueCount; + pValues = copy_src.pValues; + pLayerName = SafeStringCopy(copy_src.pLayerName); + pSettingName = SafeStringCopy(copy_src.pSettingName); +} + +safe_VkLayerSettingEXT& safe_VkLayerSettingEXT::operator=(const safe_VkLayerSettingEXT& copy_src) { + if (©_src == this) return *this; + + if (pLayerName) delete[] pLayerName; + if (pSettingName) delete[] pSettingName; + + type = copy_src.type; + valueCount = copy_src.valueCount; + pValues = copy_src.pValues; + pLayerName = SafeStringCopy(copy_src.pLayerName); + pSettingName = SafeStringCopy(copy_src.pSettingName); + + return *this; +} + +safe_VkLayerSettingEXT::~safe_VkLayerSettingEXT() { + if (pLayerName) delete[] pLayerName; + if (pSettingName) delete[] pSettingName; +} + +void safe_VkLayerSettingEXT::initialize(const VkLayerSettingEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pLayerName) delete[] pLayerName; + if (pSettingName) delete[] pSettingName; + type = in_struct->type; + valueCount = in_struct->valueCount; + pValues = in_struct->pValues; + pLayerName = SafeStringCopy(in_struct->pLayerName); + pSettingName = SafeStringCopy(in_struct->pSettingName); +} + +void safe_VkLayerSettingEXT::initialize(const safe_VkLayerSettingEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + type = copy_src->type; + valueCount = copy_src->valueCount; + pValues = copy_src->pValues; + pLayerName = SafeStringCopy(copy_src->pLayerName); + pSettingName = SafeStringCopy(copy_src->pSettingName); +} + +safe_VkLayerSettingsCreateInfoEXT::safe_VkLayerSettingsCreateInfoEXT(const VkLayerSettingsCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), settingCount(in_struct->settingCount), pSettings(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (settingCount && in_struct->pSettings) { + pSettings = new safe_VkLayerSettingEXT[settingCount]; + for (uint32_t i = 0; i < settingCount; ++i) { + pSettings[i].initialize(&in_struct->pSettings[i]); + } + } +} + +safe_VkLayerSettingsCreateInfoEXT::safe_VkLayerSettingsCreateInfoEXT() + : sType(VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT), pNext(nullptr), settingCount(), pSettings(nullptr) {} + +safe_VkLayerSettingsCreateInfoEXT::safe_VkLayerSettingsCreateInfoEXT(const safe_VkLayerSettingsCreateInfoEXT& copy_src) { + sType = copy_src.sType; + settingCount = copy_src.settingCount; + pSettings = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (settingCount && copy_src.pSettings) { + pSettings = new safe_VkLayerSettingEXT[settingCount]; + for (uint32_t i = 0; i < settingCount; ++i) { + pSettings[i].initialize(©_src.pSettings[i]); + } + } +} + +safe_VkLayerSettingsCreateInfoEXT& safe_VkLayerSettingsCreateInfoEXT::operator=(const safe_VkLayerSettingsCreateInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pSettings) delete[] pSettings; + FreePnextChain(pNext); + + sType = copy_src.sType; + settingCount = copy_src.settingCount; + pSettings = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (settingCount && copy_src.pSettings) { + pSettings = new safe_VkLayerSettingEXT[settingCount]; + for (uint32_t i = 0; i < settingCount; ++i) { + pSettings[i].initialize(©_src.pSettings[i]); + } + } + + return *this; +} + +safe_VkLayerSettingsCreateInfoEXT::~safe_VkLayerSettingsCreateInfoEXT() { + if (pSettings) delete[] pSettings; + FreePnextChain(pNext); +} + +void safe_VkLayerSettingsCreateInfoEXT::initialize(const VkLayerSettingsCreateInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pSettings) delete[] pSettings; + FreePnextChain(pNext); + sType = in_struct->sType; + settingCount = in_struct->settingCount; + pSettings = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (settingCount && in_struct->pSettings) { + pSettings = new safe_VkLayerSettingEXT[settingCount]; + for (uint32_t i = 0; i < settingCount; ++i) { + pSettings[i].initialize(&in_struct->pSettings[i]); + } + } +} + +void safe_VkLayerSettingsCreateInfoEXT::initialize(const safe_VkLayerSettingsCreateInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + settingCount = copy_src->settingCount; + pSettings = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (settingCount && copy_src->pSettings) { + pSettings = new safe_VkLayerSettingEXT[settingCount]; + for (uint32_t i = 0; i < settingCount; ++i) { + pSettings[i].initialize(©_src->pSettings[i]); + } + } +} + +safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT( + const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), pipelineLibraryGroupHandles(in_struct->pipelineLibraryGroupHandles) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT), + pNext(nullptr), + pipelineLibraryGroupHandles() {} + +safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT( + const safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& copy_src) { + sType = copy_src.sType; + pipelineLibraryGroupHandles = copy_src.pipelineLibraryGroupHandles; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::operator=( + const safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pipelineLibraryGroupHandles = copy_src.pipelineLibraryGroupHandles; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::~safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::initialize( + const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pipelineLibraryGroupHandles = in_struct->pipelineLibraryGroupHandles; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::initialize( + const safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipelineLibraryGroupHandles = copy_src->pipelineLibraryGroupHandles; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT:: + safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT( + const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), dynamicRenderingUnusedAttachments(in_struct->dynamicRenderingUnusedAttachments) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT:: + safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT), + pNext(nullptr), + dynamicRenderingUnusedAttachments() {} + +safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT:: + safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT( + const safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& copy_src) { + sType = copy_src.sType; + dynamicRenderingUnusedAttachments = copy_src.dynamicRenderingUnusedAttachments; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& +safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::operator=( + const safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + dynamicRenderingUnusedAttachments = copy_src.dynamicRenderingUnusedAttachments; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT:: + ~safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::initialize( + const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + dynamicRenderingUnusedAttachments = in_struct->dynamicRenderingUnusedAttachments; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::initialize( + const safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + dynamicRenderingUnusedAttachments = copy_src->dynamicRenderingUnusedAttachments; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT:: + safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT( + const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), attachmentFeedbackLoopDynamicState(in_struct->attachmentFeedbackLoopDynamicState) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT:: + safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT), + pNext(nullptr), + attachmentFeedbackLoopDynamicState() {} + +safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT:: + safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT( + const safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& copy_src) { + sType = copy_src.sType; + attachmentFeedbackLoopDynamicState = copy_src.attachmentFeedbackLoopDynamicState; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& +safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::operator=( + const safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + attachmentFeedbackLoopDynamicState = copy_src.attachmentFeedbackLoopDynamicState; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT:: + ~safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::initialize( + const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + attachmentFeedbackLoopDynamicState = in_struct->attachmentFeedbackLoopDynamicState; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::initialize( + const safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + attachmentFeedbackLoopDynamicState = copy_src->attachmentFeedbackLoopDynamicState; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMeshShaderFeaturesEXT::safe_VkPhysicalDeviceMeshShaderFeaturesEXT( + const VkPhysicalDeviceMeshShaderFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + taskShader(in_struct->taskShader), + meshShader(in_struct->meshShader), + multiviewMeshShader(in_struct->multiviewMeshShader), + primitiveFragmentShadingRateMeshShader(in_struct->primitiveFragmentShadingRateMeshShader), + meshShaderQueries(in_struct->meshShaderQueries) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMeshShaderFeaturesEXT::safe_VkPhysicalDeviceMeshShaderFeaturesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT), + pNext(nullptr), + taskShader(), + meshShader(), + multiviewMeshShader(), + primitiveFragmentShadingRateMeshShader(), + meshShaderQueries() {} + +safe_VkPhysicalDeviceMeshShaderFeaturesEXT::safe_VkPhysicalDeviceMeshShaderFeaturesEXT( + const safe_VkPhysicalDeviceMeshShaderFeaturesEXT& copy_src) { + sType = copy_src.sType; + taskShader = copy_src.taskShader; + meshShader = copy_src.meshShader; + multiviewMeshShader = copy_src.multiviewMeshShader; + primitiveFragmentShadingRateMeshShader = copy_src.primitiveFragmentShadingRateMeshShader; + meshShaderQueries = copy_src.meshShaderQueries; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMeshShaderFeaturesEXT& safe_VkPhysicalDeviceMeshShaderFeaturesEXT::operator=( + const safe_VkPhysicalDeviceMeshShaderFeaturesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + taskShader = copy_src.taskShader; + meshShader = copy_src.meshShader; + multiviewMeshShader = copy_src.multiviewMeshShader; + primitiveFragmentShadingRateMeshShader = copy_src.primitiveFragmentShadingRateMeshShader; + meshShaderQueries = copy_src.meshShaderQueries; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMeshShaderFeaturesEXT::~safe_VkPhysicalDeviceMeshShaderFeaturesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMeshShaderFeaturesEXT::initialize(const VkPhysicalDeviceMeshShaderFeaturesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + taskShader = in_struct->taskShader; + meshShader = in_struct->meshShader; + multiviewMeshShader = in_struct->multiviewMeshShader; + primitiveFragmentShadingRateMeshShader = in_struct->primitiveFragmentShadingRateMeshShader; + meshShaderQueries = in_struct->meshShaderQueries; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMeshShaderFeaturesEXT::initialize(const safe_VkPhysicalDeviceMeshShaderFeaturesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + taskShader = copy_src->taskShader; + meshShader = copy_src->meshShader; + multiviewMeshShader = copy_src->multiviewMeshShader; + primitiveFragmentShadingRateMeshShader = copy_src->primitiveFragmentShadingRateMeshShader; + meshShaderQueries = copy_src->meshShaderQueries; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMeshShaderPropertiesEXT::safe_VkPhysicalDeviceMeshShaderPropertiesEXT( + const VkPhysicalDeviceMeshShaderPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + maxTaskWorkGroupTotalCount(in_struct->maxTaskWorkGroupTotalCount), + maxTaskWorkGroupInvocations(in_struct->maxTaskWorkGroupInvocations), + maxTaskPayloadSize(in_struct->maxTaskPayloadSize), + maxTaskSharedMemorySize(in_struct->maxTaskSharedMemorySize), + maxTaskPayloadAndSharedMemorySize(in_struct->maxTaskPayloadAndSharedMemorySize), + maxMeshWorkGroupTotalCount(in_struct->maxMeshWorkGroupTotalCount), + maxMeshWorkGroupInvocations(in_struct->maxMeshWorkGroupInvocations), + maxMeshSharedMemorySize(in_struct->maxMeshSharedMemorySize), + maxMeshPayloadAndSharedMemorySize(in_struct->maxMeshPayloadAndSharedMemorySize), + maxMeshOutputMemorySize(in_struct->maxMeshOutputMemorySize), + maxMeshPayloadAndOutputMemorySize(in_struct->maxMeshPayloadAndOutputMemorySize), + maxMeshOutputComponents(in_struct->maxMeshOutputComponents), + maxMeshOutputVertices(in_struct->maxMeshOutputVertices), + maxMeshOutputPrimitives(in_struct->maxMeshOutputPrimitives), + maxMeshOutputLayers(in_struct->maxMeshOutputLayers), + maxMeshMultiviewViewCount(in_struct->maxMeshMultiviewViewCount), + meshOutputPerVertexGranularity(in_struct->meshOutputPerVertexGranularity), + meshOutputPerPrimitiveGranularity(in_struct->meshOutputPerPrimitiveGranularity), + maxPreferredTaskWorkGroupInvocations(in_struct->maxPreferredTaskWorkGroupInvocations), + maxPreferredMeshWorkGroupInvocations(in_struct->maxPreferredMeshWorkGroupInvocations), + prefersLocalInvocationVertexOutput(in_struct->prefersLocalInvocationVertexOutput), + prefersLocalInvocationPrimitiveOutput(in_struct->prefersLocalInvocationPrimitiveOutput), + prefersCompactVertexOutput(in_struct->prefersCompactVertexOutput), + prefersCompactPrimitiveOutput(in_struct->prefersCompactPrimitiveOutput) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < 3; ++i) { + maxTaskWorkGroupCount[i] = in_struct->maxTaskWorkGroupCount[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxTaskWorkGroupSize[i] = in_struct->maxTaskWorkGroupSize[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxMeshWorkGroupCount[i] = in_struct->maxMeshWorkGroupCount[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxMeshWorkGroupSize[i] = in_struct->maxMeshWorkGroupSize[i]; + } +} + +safe_VkPhysicalDeviceMeshShaderPropertiesEXT::safe_VkPhysicalDeviceMeshShaderPropertiesEXT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT), + pNext(nullptr), + maxTaskWorkGroupTotalCount(), + maxTaskWorkGroupInvocations(), + maxTaskPayloadSize(), + maxTaskSharedMemorySize(), + maxTaskPayloadAndSharedMemorySize(), + maxMeshWorkGroupTotalCount(), + maxMeshWorkGroupInvocations(), + maxMeshSharedMemorySize(), + maxMeshPayloadAndSharedMemorySize(), + maxMeshOutputMemorySize(), + maxMeshPayloadAndOutputMemorySize(), + maxMeshOutputComponents(), + maxMeshOutputVertices(), + maxMeshOutputPrimitives(), + maxMeshOutputLayers(), + maxMeshMultiviewViewCount(), + meshOutputPerVertexGranularity(), + meshOutputPerPrimitiveGranularity(), + maxPreferredTaskWorkGroupInvocations(), + maxPreferredMeshWorkGroupInvocations(), + prefersLocalInvocationVertexOutput(), + prefersLocalInvocationPrimitiveOutput(), + prefersCompactVertexOutput(), + prefersCompactPrimitiveOutput() {} + +safe_VkPhysicalDeviceMeshShaderPropertiesEXT::safe_VkPhysicalDeviceMeshShaderPropertiesEXT( + const safe_VkPhysicalDeviceMeshShaderPropertiesEXT& copy_src) { + sType = copy_src.sType; + maxTaskWorkGroupTotalCount = copy_src.maxTaskWorkGroupTotalCount; + maxTaskWorkGroupInvocations = copy_src.maxTaskWorkGroupInvocations; + maxTaskPayloadSize = copy_src.maxTaskPayloadSize; + maxTaskSharedMemorySize = copy_src.maxTaskSharedMemorySize; + maxTaskPayloadAndSharedMemorySize = copy_src.maxTaskPayloadAndSharedMemorySize; + maxMeshWorkGroupTotalCount = copy_src.maxMeshWorkGroupTotalCount; + maxMeshWorkGroupInvocations = copy_src.maxMeshWorkGroupInvocations; + maxMeshSharedMemorySize = copy_src.maxMeshSharedMemorySize; + maxMeshPayloadAndSharedMemorySize = copy_src.maxMeshPayloadAndSharedMemorySize; + maxMeshOutputMemorySize = copy_src.maxMeshOutputMemorySize; + maxMeshPayloadAndOutputMemorySize = copy_src.maxMeshPayloadAndOutputMemorySize; + maxMeshOutputComponents = copy_src.maxMeshOutputComponents; + maxMeshOutputVertices = copy_src.maxMeshOutputVertices; + maxMeshOutputPrimitives = copy_src.maxMeshOutputPrimitives; + maxMeshOutputLayers = copy_src.maxMeshOutputLayers; + maxMeshMultiviewViewCount = copy_src.maxMeshMultiviewViewCount; + meshOutputPerVertexGranularity = copy_src.meshOutputPerVertexGranularity; + meshOutputPerPrimitiveGranularity = copy_src.meshOutputPerPrimitiveGranularity; + maxPreferredTaskWorkGroupInvocations = copy_src.maxPreferredTaskWorkGroupInvocations; + maxPreferredMeshWorkGroupInvocations = copy_src.maxPreferredMeshWorkGroupInvocations; + prefersLocalInvocationVertexOutput = copy_src.prefersLocalInvocationVertexOutput; + prefersLocalInvocationPrimitiveOutput = copy_src.prefersLocalInvocationPrimitiveOutput; + prefersCompactVertexOutput = copy_src.prefersCompactVertexOutput; + prefersCompactPrimitiveOutput = copy_src.prefersCompactPrimitiveOutput; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < 3; ++i) { + maxTaskWorkGroupCount[i] = copy_src.maxTaskWorkGroupCount[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxTaskWorkGroupSize[i] = copy_src.maxTaskWorkGroupSize[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxMeshWorkGroupCount[i] = copy_src.maxMeshWorkGroupCount[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxMeshWorkGroupSize[i] = copy_src.maxMeshWorkGroupSize[i]; + } +} + +safe_VkPhysicalDeviceMeshShaderPropertiesEXT& safe_VkPhysicalDeviceMeshShaderPropertiesEXT::operator=( + const safe_VkPhysicalDeviceMeshShaderPropertiesEXT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxTaskWorkGroupTotalCount = copy_src.maxTaskWorkGroupTotalCount; + maxTaskWorkGroupInvocations = copy_src.maxTaskWorkGroupInvocations; + maxTaskPayloadSize = copy_src.maxTaskPayloadSize; + maxTaskSharedMemorySize = copy_src.maxTaskSharedMemorySize; + maxTaskPayloadAndSharedMemorySize = copy_src.maxTaskPayloadAndSharedMemorySize; + maxMeshWorkGroupTotalCount = copy_src.maxMeshWorkGroupTotalCount; + maxMeshWorkGroupInvocations = copy_src.maxMeshWorkGroupInvocations; + maxMeshSharedMemorySize = copy_src.maxMeshSharedMemorySize; + maxMeshPayloadAndSharedMemorySize = copy_src.maxMeshPayloadAndSharedMemorySize; + maxMeshOutputMemorySize = copy_src.maxMeshOutputMemorySize; + maxMeshPayloadAndOutputMemorySize = copy_src.maxMeshPayloadAndOutputMemorySize; + maxMeshOutputComponents = copy_src.maxMeshOutputComponents; + maxMeshOutputVertices = copy_src.maxMeshOutputVertices; + maxMeshOutputPrimitives = copy_src.maxMeshOutputPrimitives; + maxMeshOutputLayers = copy_src.maxMeshOutputLayers; + maxMeshMultiviewViewCount = copy_src.maxMeshMultiviewViewCount; + meshOutputPerVertexGranularity = copy_src.meshOutputPerVertexGranularity; + meshOutputPerPrimitiveGranularity = copy_src.meshOutputPerPrimitiveGranularity; + maxPreferredTaskWorkGroupInvocations = copy_src.maxPreferredTaskWorkGroupInvocations; + maxPreferredMeshWorkGroupInvocations = copy_src.maxPreferredMeshWorkGroupInvocations; + prefersLocalInvocationVertexOutput = copy_src.prefersLocalInvocationVertexOutput; + prefersLocalInvocationPrimitiveOutput = copy_src.prefersLocalInvocationPrimitiveOutput; + prefersCompactVertexOutput = copy_src.prefersCompactVertexOutput; + prefersCompactPrimitiveOutput = copy_src.prefersCompactPrimitiveOutput; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < 3; ++i) { + maxTaskWorkGroupCount[i] = copy_src.maxTaskWorkGroupCount[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxTaskWorkGroupSize[i] = copy_src.maxTaskWorkGroupSize[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxMeshWorkGroupCount[i] = copy_src.maxMeshWorkGroupCount[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxMeshWorkGroupSize[i] = copy_src.maxMeshWorkGroupSize[i]; + } + + return *this; +} + +safe_VkPhysicalDeviceMeshShaderPropertiesEXT::~safe_VkPhysicalDeviceMeshShaderPropertiesEXT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMeshShaderPropertiesEXT::initialize(const VkPhysicalDeviceMeshShaderPropertiesEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxTaskWorkGroupTotalCount = in_struct->maxTaskWorkGroupTotalCount; + maxTaskWorkGroupInvocations = in_struct->maxTaskWorkGroupInvocations; + maxTaskPayloadSize = in_struct->maxTaskPayloadSize; + maxTaskSharedMemorySize = in_struct->maxTaskSharedMemorySize; + maxTaskPayloadAndSharedMemorySize = in_struct->maxTaskPayloadAndSharedMemorySize; + maxMeshWorkGroupTotalCount = in_struct->maxMeshWorkGroupTotalCount; + maxMeshWorkGroupInvocations = in_struct->maxMeshWorkGroupInvocations; + maxMeshSharedMemorySize = in_struct->maxMeshSharedMemorySize; + maxMeshPayloadAndSharedMemorySize = in_struct->maxMeshPayloadAndSharedMemorySize; + maxMeshOutputMemorySize = in_struct->maxMeshOutputMemorySize; + maxMeshPayloadAndOutputMemorySize = in_struct->maxMeshPayloadAndOutputMemorySize; + maxMeshOutputComponents = in_struct->maxMeshOutputComponents; + maxMeshOutputVertices = in_struct->maxMeshOutputVertices; + maxMeshOutputPrimitives = in_struct->maxMeshOutputPrimitives; + maxMeshOutputLayers = in_struct->maxMeshOutputLayers; + maxMeshMultiviewViewCount = in_struct->maxMeshMultiviewViewCount; + meshOutputPerVertexGranularity = in_struct->meshOutputPerVertexGranularity; + meshOutputPerPrimitiveGranularity = in_struct->meshOutputPerPrimitiveGranularity; + maxPreferredTaskWorkGroupInvocations = in_struct->maxPreferredTaskWorkGroupInvocations; + maxPreferredMeshWorkGroupInvocations = in_struct->maxPreferredMeshWorkGroupInvocations; + prefersLocalInvocationVertexOutput = in_struct->prefersLocalInvocationVertexOutput; + prefersLocalInvocationPrimitiveOutput = in_struct->prefersLocalInvocationPrimitiveOutput; + prefersCompactVertexOutput = in_struct->prefersCompactVertexOutput; + prefersCompactPrimitiveOutput = in_struct->prefersCompactPrimitiveOutput; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < 3; ++i) { + maxTaskWorkGroupCount[i] = in_struct->maxTaskWorkGroupCount[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxTaskWorkGroupSize[i] = in_struct->maxTaskWorkGroupSize[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxMeshWorkGroupCount[i] = in_struct->maxMeshWorkGroupCount[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxMeshWorkGroupSize[i] = in_struct->maxMeshWorkGroupSize[i]; + } +} + +void safe_VkPhysicalDeviceMeshShaderPropertiesEXT::initialize(const safe_VkPhysicalDeviceMeshShaderPropertiesEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxTaskWorkGroupTotalCount = copy_src->maxTaskWorkGroupTotalCount; + maxTaskWorkGroupInvocations = copy_src->maxTaskWorkGroupInvocations; + maxTaskPayloadSize = copy_src->maxTaskPayloadSize; + maxTaskSharedMemorySize = copy_src->maxTaskSharedMemorySize; + maxTaskPayloadAndSharedMemorySize = copy_src->maxTaskPayloadAndSharedMemorySize; + maxMeshWorkGroupTotalCount = copy_src->maxMeshWorkGroupTotalCount; + maxMeshWorkGroupInvocations = copy_src->maxMeshWorkGroupInvocations; + maxMeshSharedMemorySize = copy_src->maxMeshSharedMemorySize; + maxMeshPayloadAndSharedMemorySize = copy_src->maxMeshPayloadAndSharedMemorySize; + maxMeshOutputMemorySize = copy_src->maxMeshOutputMemorySize; + maxMeshPayloadAndOutputMemorySize = copy_src->maxMeshPayloadAndOutputMemorySize; + maxMeshOutputComponents = copy_src->maxMeshOutputComponents; + maxMeshOutputVertices = copy_src->maxMeshOutputVertices; + maxMeshOutputPrimitives = copy_src->maxMeshOutputPrimitives; + maxMeshOutputLayers = copy_src->maxMeshOutputLayers; + maxMeshMultiviewViewCount = copy_src->maxMeshMultiviewViewCount; + meshOutputPerVertexGranularity = copy_src->meshOutputPerVertexGranularity; + meshOutputPerPrimitiveGranularity = copy_src->meshOutputPerPrimitiveGranularity; + maxPreferredTaskWorkGroupInvocations = copy_src->maxPreferredTaskWorkGroupInvocations; + maxPreferredMeshWorkGroupInvocations = copy_src->maxPreferredMeshWorkGroupInvocations; + prefersLocalInvocationVertexOutput = copy_src->prefersLocalInvocationVertexOutput; + prefersLocalInvocationPrimitiveOutput = copy_src->prefersLocalInvocationPrimitiveOutput; + prefersCompactVertexOutput = copy_src->prefersCompactVertexOutput; + prefersCompactPrimitiveOutput = copy_src->prefersCompactPrimitiveOutput; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < 3; ++i) { + maxTaskWorkGroupCount[i] = copy_src->maxTaskWorkGroupCount[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxTaskWorkGroupSize[i] = copy_src->maxTaskWorkGroupSize[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxMeshWorkGroupCount[i] = copy_src->maxMeshWorkGroupCount[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxMeshWorkGroupSize[i] = copy_src->maxMeshWorkGroupSize[i]; + } +} + +} // namespace vku + +// NOLINTEND diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp new file mode 100644 index 0000000..d3bf001 --- /dev/null +++ b/src/vulkan/vk_safe_struct_khr.cpp @@ -0,0 +1,15627 @@ +// *** THIS FILE IS GENERATED - DO NOT EDIT *** +// See safe_struct_generator.py for modifications + +/*************************************************************************** + * + * Copyright (c) 2015-2024 The Khronos Group Inc. + * Copyright (c) 2015-2024 Valve Corporation + * Copyright (c) 2015-2024 LunarG, Inc. + * Copyright (c) 2015-2024 Google Inc. + * + * SPDX-License-Identifier: Apache-2.0 + * + ****************************************************************************/ + +// NOLINTBEGIN + +#include +#include + +#include + +namespace vku { + +safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + surface(in_struct->surface), + minImageCount(in_struct->minImageCount), + imageFormat(in_struct->imageFormat), + imageColorSpace(in_struct->imageColorSpace), + imageExtent(in_struct->imageExtent), + imageArrayLayers(in_struct->imageArrayLayers), + imageUsage(in_struct->imageUsage), + imageSharingMode(in_struct->imageSharingMode), + queueFamilyIndexCount(0), + pQueueFamilyIndices(nullptr), + preTransform(in_struct->preTransform), + compositeAlpha(in_struct->compositeAlpha), + presentMode(in_struct->presentMode), + clipped(in_struct->clipped), + oldSwapchain(in_struct->oldSwapchain) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if ((in_struct->imageSharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices, + sizeof(uint32_t) * in_struct->queueFamilyIndexCount); + queueFamilyIndexCount = in_struct->queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR), + pNext(nullptr), + flags(), + surface(), + minImageCount(), + imageFormat(), + imageColorSpace(), + imageExtent(), + imageArrayLayers(), + imageUsage(), + imageSharingMode(), + queueFamilyIndexCount(), + pQueueFamilyIndices(nullptr), + preTransform(), + compositeAlpha(), + presentMode(), + clipped(), + oldSwapchain() {} + +safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR(const safe_VkSwapchainCreateInfoKHR& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + surface = copy_src.surface; + minImageCount = copy_src.minImageCount; + imageFormat = copy_src.imageFormat; + imageColorSpace = copy_src.imageColorSpace; + imageExtent = copy_src.imageExtent; + imageArrayLayers = copy_src.imageArrayLayers; + imageUsage = copy_src.imageUsage; + imageSharingMode = copy_src.imageSharingMode; + pQueueFamilyIndices = nullptr; + preTransform = copy_src.preTransform; + compositeAlpha = copy_src.compositeAlpha; + presentMode = copy_src.presentMode; + clipped = copy_src.clipped; + oldSwapchain = copy_src.oldSwapchain; + pNext = SafePnextCopy(copy_src.pNext); + + if ((copy_src.imageSharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount); + queueFamilyIndexCount = copy_src.queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +safe_VkSwapchainCreateInfoKHR& safe_VkSwapchainCreateInfoKHR::operator=(const safe_VkSwapchainCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pQueueFamilyIndices) delete[] pQueueFamilyIndices; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + surface = copy_src.surface; + minImageCount = copy_src.minImageCount; + imageFormat = copy_src.imageFormat; + imageColorSpace = copy_src.imageColorSpace; + imageExtent = copy_src.imageExtent; + imageArrayLayers = copy_src.imageArrayLayers; + imageUsage = copy_src.imageUsage; + imageSharingMode = copy_src.imageSharingMode; + pQueueFamilyIndices = nullptr; + preTransform = copy_src.preTransform; + compositeAlpha = copy_src.compositeAlpha; + presentMode = copy_src.presentMode; + clipped = copy_src.clipped; + oldSwapchain = copy_src.oldSwapchain; + pNext = SafePnextCopy(copy_src.pNext); + + if ((copy_src.imageSharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount); + queueFamilyIndexCount = copy_src.queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } + + return *this; +} + +safe_VkSwapchainCreateInfoKHR::~safe_VkSwapchainCreateInfoKHR() { + if (pQueueFamilyIndices) delete[] pQueueFamilyIndices; + FreePnextChain(pNext); +} + +void safe_VkSwapchainCreateInfoKHR::initialize(const VkSwapchainCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pQueueFamilyIndices) delete[] pQueueFamilyIndices; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + surface = in_struct->surface; + minImageCount = in_struct->minImageCount; + imageFormat = in_struct->imageFormat; + imageColorSpace = in_struct->imageColorSpace; + imageExtent = in_struct->imageExtent; + imageArrayLayers = in_struct->imageArrayLayers; + imageUsage = in_struct->imageUsage; + imageSharingMode = in_struct->imageSharingMode; + pQueueFamilyIndices = nullptr; + preTransform = in_struct->preTransform; + compositeAlpha = in_struct->compositeAlpha; + presentMode = in_struct->presentMode; + clipped = in_struct->clipped; + oldSwapchain = in_struct->oldSwapchain; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if ((in_struct->imageSharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices, + sizeof(uint32_t) * in_struct->queueFamilyIndexCount); + queueFamilyIndexCount = in_struct->queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +void safe_VkSwapchainCreateInfoKHR::initialize(const safe_VkSwapchainCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + surface = copy_src->surface; + minImageCount = copy_src->minImageCount; + imageFormat = copy_src->imageFormat; + imageColorSpace = copy_src->imageColorSpace; + imageExtent = copy_src->imageExtent; + imageArrayLayers = copy_src->imageArrayLayers; + imageUsage = copy_src->imageUsage; + imageSharingMode = copy_src->imageSharingMode; + pQueueFamilyIndices = nullptr; + preTransform = copy_src->preTransform; + compositeAlpha = copy_src->compositeAlpha; + presentMode = copy_src->presentMode; + clipped = copy_src->clipped; + oldSwapchain = copy_src->oldSwapchain; + pNext = SafePnextCopy(copy_src->pNext); + + if ((copy_src->imageSharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src->pQueueFamilyIndices) { + pQueueFamilyIndices = new uint32_t[copy_src->queueFamilyIndexCount]; + memcpy((void*)pQueueFamilyIndices, (void*)copy_src->pQueueFamilyIndices, + sizeof(uint32_t) * copy_src->queueFamilyIndexCount); + queueFamilyIndexCount = copy_src->queueFamilyIndexCount; + } else { + queueFamilyIndexCount = 0; + } +} + +safe_VkPresentInfoKHR::safe_VkPresentInfoKHR(const VkPresentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + waitSemaphoreCount(in_struct->waitSemaphoreCount), + pWaitSemaphores(nullptr), + swapchainCount(in_struct->swapchainCount), + pSwapchains(nullptr), + pImageIndices(nullptr), + pResults(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (waitSemaphoreCount && in_struct->pWaitSemaphores) { + pWaitSemaphores = new VkSemaphore[waitSemaphoreCount]; + for (uint32_t i = 0; i < waitSemaphoreCount; ++i) { + pWaitSemaphores[i] = in_struct->pWaitSemaphores[i]; + } + } + if (swapchainCount && in_struct->pSwapchains) { + pSwapchains = new VkSwapchainKHR[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pSwapchains[i] = in_struct->pSwapchains[i]; + } + } + + if (in_struct->pImageIndices) { + pImageIndices = new uint32_t[in_struct->swapchainCount]; + memcpy((void*)pImageIndices, (void*)in_struct->pImageIndices, sizeof(uint32_t) * in_struct->swapchainCount); + } + + if (in_struct->pResults) { + pResults = new VkResult[in_struct->swapchainCount]; + memcpy((void*)pResults, (void*)in_struct->pResults, sizeof(VkResult) * in_struct->swapchainCount); + } +} + +safe_VkPresentInfoKHR::safe_VkPresentInfoKHR() + : sType(VK_STRUCTURE_TYPE_PRESENT_INFO_KHR), + pNext(nullptr), + waitSemaphoreCount(), + pWaitSemaphores(nullptr), + swapchainCount(), + pSwapchains(nullptr), + pImageIndices(nullptr), + pResults(nullptr) {} + +safe_VkPresentInfoKHR::safe_VkPresentInfoKHR(const safe_VkPresentInfoKHR& copy_src) { + sType = copy_src.sType; + waitSemaphoreCount = copy_src.waitSemaphoreCount; + pWaitSemaphores = nullptr; + swapchainCount = copy_src.swapchainCount; + pSwapchains = nullptr; + pImageIndices = nullptr; + pResults = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (waitSemaphoreCount && copy_src.pWaitSemaphores) { + pWaitSemaphores = new VkSemaphore[waitSemaphoreCount]; + for (uint32_t i = 0; i < waitSemaphoreCount; ++i) { + pWaitSemaphores[i] = copy_src.pWaitSemaphores[i]; + } + } + if (swapchainCount && copy_src.pSwapchains) { + pSwapchains = new VkSwapchainKHR[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pSwapchains[i] = copy_src.pSwapchains[i]; + } + } + + if (copy_src.pImageIndices) { + pImageIndices = new uint32_t[copy_src.swapchainCount]; + memcpy((void*)pImageIndices, (void*)copy_src.pImageIndices, sizeof(uint32_t) * copy_src.swapchainCount); + } + + if (copy_src.pResults) { + pResults = new VkResult[copy_src.swapchainCount]; + memcpy((void*)pResults, (void*)copy_src.pResults, sizeof(VkResult) * copy_src.swapchainCount); + } +} + +safe_VkPresentInfoKHR& safe_VkPresentInfoKHR::operator=(const safe_VkPresentInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pWaitSemaphores) delete[] pWaitSemaphores; + if (pSwapchains) delete[] pSwapchains; + if (pImageIndices) delete[] pImageIndices; + if (pResults) delete[] pResults; + FreePnextChain(pNext); + + sType = copy_src.sType; + waitSemaphoreCount = copy_src.waitSemaphoreCount; + pWaitSemaphores = nullptr; + swapchainCount = copy_src.swapchainCount; + pSwapchains = nullptr; + pImageIndices = nullptr; + pResults = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (waitSemaphoreCount && copy_src.pWaitSemaphores) { + pWaitSemaphores = new VkSemaphore[waitSemaphoreCount]; + for (uint32_t i = 0; i < waitSemaphoreCount; ++i) { + pWaitSemaphores[i] = copy_src.pWaitSemaphores[i]; + } + } + if (swapchainCount && copy_src.pSwapchains) { + pSwapchains = new VkSwapchainKHR[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pSwapchains[i] = copy_src.pSwapchains[i]; + } + } + + if (copy_src.pImageIndices) { + pImageIndices = new uint32_t[copy_src.swapchainCount]; + memcpy((void*)pImageIndices, (void*)copy_src.pImageIndices, sizeof(uint32_t) * copy_src.swapchainCount); + } + + if (copy_src.pResults) { + pResults = new VkResult[copy_src.swapchainCount]; + memcpy((void*)pResults, (void*)copy_src.pResults, sizeof(VkResult) * copy_src.swapchainCount); + } + + return *this; +} + +safe_VkPresentInfoKHR::~safe_VkPresentInfoKHR() { + if (pWaitSemaphores) delete[] pWaitSemaphores; + if (pSwapchains) delete[] pSwapchains; + if (pImageIndices) delete[] pImageIndices; + if (pResults) delete[] pResults; + FreePnextChain(pNext); +} + +void safe_VkPresentInfoKHR::initialize(const VkPresentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pWaitSemaphores) delete[] pWaitSemaphores; + if (pSwapchains) delete[] pSwapchains; + if (pImageIndices) delete[] pImageIndices; + if (pResults) delete[] pResults; + FreePnextChain(pNext); + sType = in_struct->sType; + waitSemaphoreCount = in_struct->waitSemaphoreCount; + pWaitSemaphores = nullptr; + swapchainCount = in_struct->swapchainCount; + pSwapchains = nullptr; + pImageIndices = nullptr; + pResults = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (waitSemaphoreCount && in_struct->pWaitSemaphores) { + pWaitSemaphores = new VkSemaphore[waitSemaphoreCount]; + for (uint32_t i = 0; i < waitSemaphoreCount; ++i) { + pWaitSemaphores[i] = in_struct->pWaitSemaphores[i]; + } + } + if (swapchainCount && in_struct->pSwapchains) { + pSwapchains = new VkSwapchainKHR[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pSwapchains[i] = in_struct->pSwapchains[i]; + } + } + + if (in_struct->pImageIndices) { + pImageIndices = new uint32_t[in_struct->swapchainCount]; + memcpy((void*)pImageIndices, (void*)in_struct->pImageIndices, sizeof(uint32_t) * in_struct->swapchainCount); + } + + if (in_struct->pResults) { + pResults = new VkResult[in_struct->swapchainCount]; + memcpy((void*)pResults, (void*)in_struct->pResults, sizeof(VkResult) * in_struct->swapchainCount); + } +} + +void safe_VkPresentInfoKHR::initialize(const safe_VkPresentInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + waitSemaphoreCount = copy_src->waitSemaphoreCount; + pWaitSemaphores = nullptr; + swapchainCount = copy_src->swapchainCount; + pSwapchains = nullptr; + pImageIndices = nullptr; + pResults = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (waitSemaphoreCount && copy_src->pWaitSemaphores) { + pWaitSemaphores = new VkSemaphore[waitSemaphoreCount]; + for (uint32_t i = 0; i < waitSemaphoreCount; ++i) { + pWaitSemaphores[i] = copy_src->pWaitSemaphores[i]; + } + } + if (swapchainCount && copy_src->pSwapchains) { + pSwapchains = new VkSwapchainKHR[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + pSwapchains[i] = copy_src->pSwapchains[i]; + } + } + + if (copy_src->pImageIndices) { + pImageIndices = new uint32_t[copy_src->swapchainCount]; + memcpy((void*)pImageIndices, (void*)copy_src->pImageIndices, sizeof(uint32_t) * copy_src->swapchainCount); + } + + if (copy_src->pResults) { + pResults = new VkResult[copy_src->swapchainCount]; + memcpy((void*)pResults, (void*)copy_src->pResults, sizeof(VkResult) * copy_src->swapchainCount); + } +} + +safe_VkImageSwapchainCreateInfoKHR::safe_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), swapchain(in_struct->swapchain) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageSwapchainCreateInfoKHR::safe_VkImageSwapchainCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR), pNext(nullptr), swapchain() {} + +safe_VkImageSwapchainCreateInfoKHR::safe_VkImageSwapchainCreateInfoKHR(const safe_VkImageSwapchainCreateInfoKHR& copy_src) { + sType = copy_src.sType; + swapchain = copy_src.swapchain; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageSwapchainCreateInfoKHR& safe_VkImageSwapchainCreateInfoKHR::operator=( + const safe_VkImageSwapchainCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + swapchain = copy_src.swapchain; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageSwapchainCreateInfoKHR::~safe_VkImageSwapchainCreateInfoKHR() { FreePnextChain(pNext); } + +void safe_VkImageSwapchainCreateInfoKHR::initialize(const VkImageSwapchainCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + swapchain = in_struct->swapchain; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageSwapchainCreateInfoKHR::initialize(const safe_VkImageSwapchainCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + swapchain = copy_src->swapchain; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBindImageMemorySwapchainInfoKHR::safe_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), swapchain(in_struct->swapchain), imageIndex(in_struct->imageIndex) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBindImageMemorySwapchainInfoKHR::safe_VkBindImageMemorySwapchainInfoKHR() + : sType(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR), pNext(nullptr), swapchain(), imageIndex() {} + +safe_VkBindImageMemorySwapchainInfoKHR::safe_VkBindImageMemorySwapchainInfoKHR( + const safe_VkBindImageMemorySwapchainInfoKHR& copy_src) { + sType = copy_src.sType; + swapchain = copy_src.swapchain; + imageIndex = copy_src.imageIndex; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBindImageMemorySwapchainInfoKHR& safe_VkBindImageMemorySwapchainInfoKHR::operator=( + const safe_VkBindImageMemorySwapchainInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + swapchain = copy_src.swapchain; + imageIndex = copy_src.imageIndex; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBindImageMemorySwapchainInfoKHR::~safe_VkBindImageMemorySwapchainInfoKHR() { FreePnextChain(pNext); } + +void safe_VkBindImageMemorySwapchainInfoKHR::initialize(const VkBindImageMemorySwapchainInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + swapchain = in_struct->swapchain; + imageIndex = in_struct->imageIndex; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBindImageMemorySwapchainInfoKHR::initialize(const safe_VkBindImageMemorySwapchainInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + swapchain = copy_src->swapchain; + imageIndex = copy_src->imageIndex; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAcquireNextImageInfoKHR::safe_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + swapchain(in_struct->swapchain), + timeout(in_struct->timeout), + semaphore(in_struct->semaphore), + fence(in_struct->fence), + deviceMask(in_struct->deviceMask) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAcquireNextImageInfoKHR::safe_VkAcquireNextImageInfoKHR() + : sType(VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR), + pNext(nullptr), + swapchain(), + timeout(), + semaphore(), + fence(), + deviceMask() {} + +safe_VkAcquireNextImageInfoKHR::safe_VkAcquireNextImageInfoKHR(const safe_VkAcquireNextImageInfoKHR& copy_src) { + sType = copy_src.sType; + swapchain = copy_src.swapchain; + timeout = copy_src.timeout; + semaphore = copy_src.semaphore; + fence = copy_src.fence; + deviceMask = copy_src.deviceMask; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAcquireNextImageInfoKHR& safe_VkAcquireNextImageInfoKHR::operator=(const safe_VkAcquireNextImageInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + swapchain = copy_src.swapchain; + timeout = copy_src.timeout; + semaphore = copy_src.semaphore; + fence = copy_src.fence; + deviceMask = copy_src.deviceMask; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAcquireNextImageInfoKHR::~safe_VkAcquireNextImageInfoKHR() { FreePnextChain(pNext); } + +void safe_VkAcquireNextImageInfoKHR::initialize(const VkAcquireNextImageInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + swapchain = in_struct->swapchain; + timeout = in_struct->timeout; + semaphore = in_struct->semaphore; + fence = in_struct->fence; + deviceMask = in_struct->deviceMask; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAcquireNextImageInfoKHR::initialize(const safe_VkAcquireNextImageInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + swapchain = copy_src->swapchain; + timeout = copy_src->timeout; + semaphore = copy_src->semaphore; + fence = copy_src->fence; + deviceMask = copy_src->deviceMask; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDeviceGroupPresentCapabilitiesKHR::safe_VkDeviceGroupPresentCapabilitiesKHR( + const VkDeviceGroupPresentCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), modes(in_struct->modes) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) { + presentMask[i] = in_struct->presentMask[i]; + } +} + +safe_VkDeviceGroupPresentCapabilitiesKHR::safe_VkDeviceGroupPresentCapabilitiesKHR() + : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR), pNext(nullptr), modes() {} + +safe_VkDeviceGroupPresentCapabilitiesKHR::safe_VkDeviceGroupPresentCapabilitiesKHR( + const safe_VkDeviceGroupPresentCapabilitiesKHR& copy_src) { + sType = copy_src.sType; + modes = copy_src.modes; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) { + presentMask[i] = copy_src.presentMask[i]; + } +} + +safe_VkDeviceGroupPresentCapabilitiesKHR& safe_VkDeviceGroupPresentCapabilitiesKHR::operator=( + const safe_VkDeviceGroupPresentCapabilitiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + modes = copy_src.modes; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) { + presentMask[i] = copy_src.presentMask[i]; + } + + return *this; +} + +safe_VkDeviceGroupPresentCapabilitiesKHR::~safe_VkDeviceGroupPresentCapabilitiesKHR() { FreePnextChain(pNext); } + +void safe_VkDeviceGroupPresentCapabilitiesKHR::initialize(const VkDeviceGroupPresentCapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + modes = in_struct->modes; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) { + presentMask[i] = in_struct->presentMask[i]; + } +} + +void safe_VkDeviceGroupPresentCapabilitiesKHR::initialize(const safe_VkDeviceGroupPresentCapabilitiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + modes = copy_src->modes; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) { + presentMask[i] = copy_src->presentMask[i]; + } +} + +safe_VkDeviceGroupPresentInfoKHR::safe_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pDeviceMasks(nullptr), mode(in_struct->mode) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pDeviceMasks) { + pDeviceMasks = new uint32_t[in_struct->swapchainCount]; + memcpy((void*)pDeviceMasks, (void*)in_struct->pDeviceMasks, sizeof(uint32_t) * in_struct->swapchainCount); + } +} + +safe_VkDeviceGroupPresentInfoKHR::safe_VkDeviceGroupPresentInfoKHR() + : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR), pNext(nullptr), swapchainCount(), pDeviceMasks(nullptr), mode() {} + +safe_VkDeviceGroupPresentInfoKHR::safe_VkDeviceGroupPresentInfoKHR(const safe_VkDeviceGroupPresentInfoKHR& copy_src) { + sType = copy_src.sType; + swapchainCount = copy_src.swapchainCount; + pDeviceMasks = nullptr; + mode = copy_src.mode; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDeviceMasks) { + pDeviceMasks = new uint32_t[copy_src.swapchainCount]; + memcpy((void*)pDeviceMasks, (void*)copy_src.pDeviceMasks, sizeof(uint32_t) * copy_src.swapchainCount); + } +} + +safe_VkDeviceGroupPresentInfoKHR& safe_VkDeviceGroupPresentInfoKHR::operator=(const safe_VkDeviceGroupPresentInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pDeviceMasks) delete[] pDeviceMasks; + FreePnextChain(pNext); + + sType = copy_src.sType; + swapchainCount = copy_src.swapchainCount; + pDeviceMasks = nullptr; + mode = copy_src.mode; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDeviceMasks) { + pDeviceMasks = new uint32_t[copy_src.swapchainCount]; + memcpy((void*)pDeviceMasks, (void*)copy_src.pDeviceMasks, sizeof(uint32_t) * copy_src.swapchainCount); + } + + return *this; +} + +safe_VkDeviceGroupPresentInfoKHR::~safe_VkDeviceGroupPresentInfoKHR() { + if (pDeviceMasks) delete[] pDeviceMasks; + FreePnextChain(pNext); +} + +void safe_VkDeviceGroupPresentInfoKHR::initialize(const VkDeviceGroupPresentInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDeviceMasks) delete[] pDeviceMasks; + FreePnextChain(pNext); + sType = in_struct->sType; + swapchainCount = in_struct->swapchainCount; + pDeviceMasks = nullptr; + mode = in_struct->mode; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pDeviceMasks) { + pDeviceMasks = new uint32_t[in_struct->swapchainCount]; + memcpy((void*)pDeviceMasks, (void*)in_struct->pDeviceMasks, sizeof(uint32_t) * in_struct->swapchainCount); + } +} + +void safe_VkDeviceGroupPresentInfoKHR::initialize(const safe_VkDeviceGroupPresentInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + swapchainCount = copy_src->swapchainCount; + pDeviceMasks = nullptr; + mode = copy_src->mode; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pDeviceMasks) { + pDeviceMasks = new uint32_t[copy_src->swapchainCount]; + memcpy((void*)pDeviceMasks, (void*)copy_src->pDeviceMasks, sizeof(uint32_t) * copy_src->swapchainCount); + } +} + +safe_VkDeviceGroupSwapchainCreateInfoKHR::safe_VkDeviceGroupSwapchainCreateInfoKHR( + const VkDeviceGroupSwapchainCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), modes(in_struct->modes) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDeviceGroupSwapchainCreateInfoKHR::safe_VkDeviceGroupSwapchainCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR), pNext(nullptr), modes() {} + +safe_VkDeviceGroupSwapchainCreateInfoKHR::safe_VkDeviceGroupSwapchainCreateInfoKHR( + const safe_VkDeviceGroupSwapchainCreateInfoKHR& copy_src) { + sType = copy_src.sType; + modes = copy_src.modes; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDeviceGroupSwapchainCreateInfoKHR& safe_VkDeviceGroupSwapchainCreateInfoKHR::operator=( + const safe_VkDeviceGroupSwapchainCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + modes = copy_src.modes; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDeviceGroupSwapchainCreateInfoKHR::~safe_VkDeviceGroupSwapchainCreateInfoKHR() { FreePnextChain(pNext); } + +void safe_VkDeviceGroupSwapchainCreateInfoKHR::initialize(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + modes = in_struct->modes; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDeviceGroupSwapchainCreateInfoKHR::initialize(const safe_VkDeviceGroupSwapchainCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + modes = copy_src->modes; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), parameters(in_struct->parameters) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR), pNext(nullptr), flags(), parameters() {} + +safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR(const safe_VkDisplayModeCreateInfoKHR& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + parameters = copy_src.parameters; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDisplayModeCreateInfoKHR& safe_VkDisplayModeCreateInfoKHR::operator=(const safe_VkDisplayModeCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + parameters = copy_src.parameters; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDisplayModeCreateInfoKHR::~safe_VkDisplayModeCreateInfoKHR() { FreePnextChain(pNext); } + +void safe_VkDisplayModeCreateInfoKHR::initialize(const VkDisplayModeCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + parameters = in_struct->parameters; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDisplayModeCreateInfoKHR::initialize(const safe_VkDisplayModeCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + parameters = copy_src->parameters; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) + : display(in_struct->display), + physicalDimensions(in_struct->physicalDimensions), + physicalResolution(in_struct->physicalResolution), + supportedTransforms(in_struct->supportedTransforms), + planeReorderPossible(in_struct->planeReorderPossible), + persistentContent(in_struct->persistentContent) { + displayName = SafeStringCopy(in_struct->displayName); +} + +safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR() + : display(), + displayName(nullptr), + physicalDimensions(), + physicalResolution(), + supportedTransforms(), + planeReorderPossible(), + persistentContent() {} + +safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR(const safe_VkDisplayPropertiesKHR& copy_src) { + display = copy_src.display; + physicalDimensions = copy_src.physicalDimensions; + physicalResolution = copy_src.physicalResolution; + supportedTransforms = copy_src.supportedTransforms; + planeReorderPossible = copy_src.planeReorderPossible; + persistentContent = copy_src.persistentContent; + displayName = SafeStringCopy(copy_src.displayName); +} + +safe_VkDisplayPropertiesKHR& safe_VkDisplayPropertiesKHR::operator=(const safe_VkDisplayPropertiesKHR& copy_src) { + if (©_src == this) return *this; + + if (displayName) delete[] displayName; + + display = copy_src.display; + physicalDimensions = copy_src.physicalDimensions; + physicalResolution = copy_src.physicalResolution; + supportedTransforms = copy_src.supportedTransforms; + planeReorderPossible = copy_src.planeReorderPossible; + persistentContent = copy_src.persistentContent; + displayName = SafeStringCopy(copy_src.displayName); + + return *this; +} + +safe_VkDisplayPropertiesKHR::~safe_VkDisplayPropertiesKHR() { + if (displayName) delete[] displayName; +} + +void safe_VkDisplayPropertiesKHR::initialize(const VkDisplayPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (displayName) delete[] displayName; + display = in_struct->display; + physicalDimensions = in_struct->physicalDimensions; + physicalResolution = in_struct->physicalResolution; + supportedTransforms = in_struct->supportedTransforms; + planeReorderPossible = in_struct->planeReorderPossible; + persistentContent = in_struct->persistentContent; + displayName = SafeStringCopy(in_struct->displayName); +} + +void safe_VkDisplayPropertiesKHR::initialize(const safe_VkDisplayPropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + display = copy_src->display; + physicalDimensions = copy_src->physicalDimensions; + physicalResolution = copy_src->physicalResolution; + supportedTransforms = copy_src->supportedTransforms; + planeReorderPossible = copy_src->planeReorderPossible; + persistentContent = copy_src->persistentContent; + displayName = SafeStringCopy(copy_src->displayName); +} + +safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + displayMode(in_struct->displayMode), + planeIndex(in_struct->planeIndex), + planeStackIndex(in_struct->planeStackIndex), + transform(in_struct->transform), + globalAlpha(in_struct->globalAlpha), + alphaMode(in_struct->alphaMode), + imageExtent(in_struct->imageExtent) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR), + pNext(nullptr), + flags(), + displayMode(), + planeIndex(), + planeStackIndex(), + transform(), + globalAlpha(), + alphaMode(), + imageExtent() {} + +safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR(const safe_VkDisplaySurfaceCreateInfoKHR& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + displayMode = copy_src.displayMode; + planeIndex = copy_src.planeIndex; + planeStackIndex = copy_src.planeStackIndex; + transform = copy_src.transform; + globalAlpha = copy_src.globalAlpha; + alphaMode = copy_src.alphaMode; + imageExtent = copy_src.imageExtent; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDisplaySurfaceCreateInfoKHR& safe_VkDisplaySurfaceCreateInfoKHR::operator=( + const safe_VkDisplaySurfaceCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + displayMode = copy_src.displayMode; + planeIndex = copy_src.planeIndex; + planeStackIndex = copy_src.planeStackIndex; + transform = copy_src.transform; + globalAlpha = copy_src.globalAlpha; + alphaMode = copy_src.alphaMode; + imageExtent = copy_src.imageExtent; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDisplaySurfaceCreateInfoKHR::~safe_VkDisplaySurfaceCreateInfoKHR() { FreePnextChain(pNext); } + +void safe_VkDisplaySurfaceCreateInfoKHR::initialize(const VkDisplaySurfaceCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + displayMode = in_struct->displayMode; + planeIndex = in_struct->planeIndex; + planeStackIndex = in_struct->planeStackIndex; + transform = in_struct->transform; + globalAlpha = in_struct->globalAlpha; + alphaMode = in_struct->alphaMode; + imageExtent = in_struct->imageExtent; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDisplaySurfaceCreateInfoKHR::initialize(const safe_VkDisplaySurfaceCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + displayMode = copy_src->displayMode; + planeIndex = copy_src->planeIndex; + planeStackIndex = copy_src->planeStackIndex; + transform = copy_src->transform; + globalAlpha = copy_src->globalAlpha; + alphaMode = copy_src->alphaMode; + imageExtent = copy_src->imageExtent; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), srcRect(in_struct->srcRect), dstRect(in_struct->dstRect), persistent(in_struct->persistent) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR() + : sType(VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR), pNext(nullptr), srcRect(), dstRect(), persistent() {} + +safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR(const safe_VkDisplayPresentInfoKHR& copy_src) { + sType = copy_src.sType; + srcRect = copy_src.srcRect; + dstRect = copy_src.dstRect; + persistent = copy_src.persistent; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDisplayPresentInfoKHR& safe_VkDisplayPresentInfoKHR::operator=(const safe_VkDisplayPresentInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + srcRect = copy_src.srcRect; + dstRect = copy_src.dstRect; + persistent = copy_src.persistent; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDisplayPresentInfoKHR::~safe_VkDisplayPresentInfoKHR() { FreePnextChain(pNext); } + +void safe_VkDisplayPresentInfoKHR::initialize(const VkDisplayPresentInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + srcRect = in_struct->srcRect; + dstRect = in_struct->dstRect; + persistent = in_struct->persistent; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDisplayPresentInfoKHR::initialize(const safe_VkDisplayPresentInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcRect = copy_src->srcRect; + dstRect = copy_src->dstRect; + persistent = copy_src->persistent; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkQueueFamilyQueryResultStatusPropertiesKHR::safe_VkQueueFamilyQueryResultStatusPropertiesKHR( + const VkQueueFamilyQueryResultStatusPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), queryResultStatusSupport(in_struct->queryResultStatusSupport) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkQueueFamilyQueryResultStatusPropertiesKHR::safe_VkQueueFamilyQueryResultStatusPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR), pNext(nullptr), queryResultStatusSupport() {} + +safe_VkQueueFamilyQueryResultStatusPropertiesKHR::safe_VkQueueFamilyQueryResultStatusPropertiesKHR( + const safe_VkQueueFamilyQueryResultStatusPropertiesKHR& copy_src) { + sType = copy_src.sType; + queryResultStatusSupport = copy_src.queryResultStatusSupport; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkQueueFamilyQueryResultStatusPropertiesKHR& safe_VkQueueFamilyQueryResultStatusPropertiesKHR::operator=( + const safe_VkQueueFamilyQueryResultStatusPropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + queryResultStatusSupport = copy_src.queryResultStatusSupport; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkQueueFamilyQueryResultStatusPropertiesKHR::~safe_VkQueueFamilyQueryResultStatusPropertiesKHR() { FreePnextChain(pNext); } + +void safe_VkQueueFamilyQueryResultStatusPropertiesKHR::initialize(const VkQueueFamilyQueryResultStatusPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + queryResultStatusSupport = in_struct->queryResultStatusSupport; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkQueueFamilyQueryResultStatusPropertiesKHR::initialize(const safe_VkQueueFamilyQueryResultStatusPropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + queryResultStatusSupport = copy_src->queryResultStatusSupport; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkQueueFamilyVideoPropertiesKHR::safe_VkQueueFamilyVideoPropertiesKHR(const VkQueueFamilyVideoPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), videoCodecOperations(in_struct->videoCodecOperations) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkQueueFamilyVideoPropertiesKHR::safe_VkQueueFamilyVideoPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR), pNext(nullptr), videoCodecOperations() {} + +safe_VkQueueFamilyVideoPropertiesKHR::safe_VkQueueFamilyVideoPropertiesKHR(const safe_VkQueueFamilyVideoPropertiesKHR& copy_src) { + sType = copy_src.sType; + videoCodecOperations = copy_src.videoCodecOperations; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkQueueFamilyVideoPropertiesKHR& safe_VkQueueFamilyVideoPropertiesKHR::operator=( + const safe_VkQueueFamilyVideoPropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + videoCodecOperations = copy_src.videoCodecOperations; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkQueueFamilyVideoPropertiesKHR::~safe_VkQueueFamilyVideoPropertiesKHR() { FreePnextChain(pNext); } + +void safe_VkQueueFamilyVideoPropertiesKHR::initialize(const VkQueueFamilyVideoPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + videoCodecOperations = in_struct->videoCodecOperations; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkQueueFamilyVideoPropertiesKHR::initialize(const safe_VkQueueFamilyVideoPropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + videoCodecOperations = copy_src->videoCodecOperations; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoProfileInfoKHR::safe_VkVideoProfileInfoKHR(const VkVideoProfileInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + videoCodecOperation(in_struct->videoCodecOperation), + chromaSubsampling(in_struct->chromaSubsampling), + lumaBitDepth(in_struct->lumaBitDepth), + chromaBitDepth(in_struct->chromaBitDepth) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoProfileInfoKHR::safe_VkVideoProfileInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR), + pNext(nullptr), + videoCodecOperation(), + chromaSubsampling(), + lumaBitDepth(), + chromaBitDepth() {} + +safe_VkVideoProfileInfoKHR::safe_VkVideoProfileInfoKHR(const safe_VkVideoProfileInfoKHR& copy_src) { + sType = copy_src.sType; + videoCodecOperation = copy_src.videoCodecOperation; + chromaSubsampling = copy_src.chromaSubsampling; + lumaBitDepth = copy_src.lumaBitDepth; + chromaBitDepth = copy_src.chromaBitDepth; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoProfileInfoKHR& safe_VkVideoProfileInfoKHR::operator=(const safe_VkVideoProfileInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + videoCodecOperation = copy_src.videoCodecOperation; + chromaSubsampling = copy_src.chromaSubsampling; + lumaBitDepth = copy_src.lumaBitDepth; + chromaBitDepth = copy_src.chromaBitDepth; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoProfileInfoKHR::~safe_VkVideoProfileInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoProfileInfoKHR::initialize(const VkVideoProfileInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + videoCodecOperation = in_struct->videoCodecOperation; + chromaSubsampling = in_struct->chromaSubsampling; + lumaBitDepth = in_struct->lumaBitDepth; + chromaBitDepth = in_struct->chromaBitDepth; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoProfileInfoKHR::initialize(const safe_VkVideoProfileInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + videoCodecOperation = copy_src->videoCodecOperation; + chromaSubsampling = copy_src->chromaSubsampling; + lumaBitDepth = copy_src->lumaBitDepth; + chromaBitDepth = copy_src->chromaBitDepth; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoProfileListInfoKHR::safe_VkVideoProfileListInfoKHR(const VkVideoProfileListInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), profileCount(in_struct->profileCount), pProfiles(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (profileCount && in_struct->pProfiles) { + pProfiles = new safe_VkVideoProfileInfoKHR[profileCount]; + for (uint32_t i = 0; i < profileCount; ++i) { + pProfiles[i].initialize(&in_struct->pProfiles[i]); + } + } +} + +safe_VkVideoProfileListInfoKHR::safe_VkVideoProfileListInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR), pNext(nullptr), profileCount(), pProfiles(nullptr) {} + +safe_VkVideoProfileListInfoKHR::safe_VkVideoProfileListInfoKHR(const safe_VkVideoProfileListInfoKHR& copy_src) { + sType = copy_src.sType; + profileCount = copy_src.profileCount; + pProfiles = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (profileCount && copy_src.pProfiles) { + pProfiles = new safe_VkVideoProfileInfoKHR[profileCount]; + for (uint32_t i = 0; i < profileCount; ++i) { + pProfiles[i].initialize(©_src.pProfiles[i]); + } + } +} + +safe_VkVideoProfileListInfoKHR& safe_VkVideoProfileListInfoKHR::operator=(const safe_VkVideoProfileListInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pProfiles) delete[] pProfiles; + FreePnextChain(pNext); + + sType = copy_src.sType; + profileCount = copy_src.profileCount; + pProfiles = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (profileCount && copy_src.pProfiles) { + pProfiles = new safe_VkVideoProfileInfoKHR[profileCount]; + for (uint32_t i = 0; i < profileCount; ++i) { + pProfiles[i].initialize(©_src.pProfiles[i]); + } + } + + return *this; +} + +safe_VkVideoProfileListInfoKHR::~safe_VkVideoProfileListInfoKHR() { + if (pProfiles) delete[] pProfiles; + FreePnextChain(pNext); +} + +void safe_VkVideoProfileListInfoKHR::initialize(const VkVideoProfileListInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pProfiles) delete[] pProfiles; + FreePnextChain(pNext); + sType = in_struct->sType; + profileCount = in_struct->profileCount; + pProfiles = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (profileCount && in_struct->pProfiles) { + pProfiles = new safe_VkVideoProfileInfoKHR[profileCount]; + for (uint32_t i = 0; i < profileCount; ++i) { + pProfiles[i].initialize(&in_struct->pProfiles[i]); + } + } +} + +void safe_VkVideoProfileListInfoKHR::initialize(const safe_VkVideoProfileListInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + profileCount = copy_src->profileCount; + pProfiles = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (profileCount && copy_src->pProfiles) { + pProfiles = new safe_VkVideoProfileInfoKHR[profileCount]; + for (uint32_t i = 0; i < profileCount; ++i) { + pProfiles[i].initialize(©_src->pProfiles[i]); + } + } +} + +safe_VkVideoCapabilitiesKHR::safe_VkVideoCapabilitiesKHR(const VkVideoCapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + minBitstreamBufferOffsetAlignment(in_struct->minBitstreamBufferOffsetAlignment), + minBitstreamBufferSizeAlignment(in_struct->minBitstreamBufferSizeAlignment), + pictureAccessGranularity(in_struct->pictureAccessGranularity), + minCodedExtent(in_struct->minCodedExtent), + maxCodedExtent(in_struct->maxCodedExtent), + maxDpbSlots(in_struct->maxDpbSlots), + maxActiveReferencePictures(in_struct->maxActiveReferencePictures), + stdHeaderVersion(in_struct->stdHeaderVersion) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoCapabilitiesKHR::safe_VkVideoCapabilitiesKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR), + pNext(nullptr), + flags(), + minBitstreamBufferOffsetAlignment(), + minBitstreamBufferSizeAlignment(), + pictureAccessGranularity(), + minCodedExtent(), + maxCodedExtent(), + maxDpbSlots(), + maxActiveReferencePictures(), + stdHeaderVersion() {} + +safe_VkVideoCapabilitiesKHR::safe_VkVideoCapabilitiesKHR(const safe_VkVideoCapabilitiesKHR& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + minBitstreamBufferOffsetAlignment = copy_src.minBitstreamBufferOffsetAlignment; + minBitstreamBufferSizeAlignment = copy_src.minBitstreamBufferSizeAlignment; + pictureAccessGranularity = copy_src.pictureAccessGranularity; + minCodedExtent = copy_src.minCodedExtent; + maxCodedExtent = copy_src.maxCodedExtent; + maxDpbSlots = copy_src.maxDpbSlots; + maxActiveReferencePictures = copy_src.maxActiveReferencePictures; + stdHeaderVersion = copy_src.stdHeaderVersion; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoCapabilitiesKHR& safe_VkVideoCapabilitiesKHR::operator=(const safe_VkVideoCapabilitiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + minBitstreamBufferOffsetAlignment = copy_src.minBitstreamBufferOffsetAlignment; + minBitstreamBufferSizeAlignment = copy_src.minBitstreamBufferSizeAlignment; + pictureAccessGranularity = copy_src.pictureAccessGranularity; + minCodedExtent = copy_src.minCodedExtent; + maxCodedExtent = copy_src.maxCodedExtent; + maxDpbSlots = copy_src.maxDpbSlots; + maxActiveReferencePictures = copy_src.maxActiveReferencePictures; + stdHeaderVersion = copy_src.stdHeaderVersion; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoCapabilitiesKHR::~safe_VkVideoCapabilitiesKHR() { FreePnextChain(pNext); } + +void safe_VkVideoCapabilitiesKHR::initialize(const VkVideoCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + minBitstreamBufferOffsetAlignment = in_struct->minBitstreamBufferOffsetAlignment; + minBitstreamBufferSizeAlignment = in_struct->minBitstreamBufferSizeAlignment; + pictureAccessGranularity = in_struct->pictureAccessGranularity; + minCodedExtent = in_struct->minCodedExtent; + maxCodedExtent = in_struct->maxCodedExtent; + maxDpbSlots = in_struct->maxDpbSlots; + maxActiveReferencePictures = in_struct->maxActiveReferencePictures; + stdHeaderVersion = in_struct->stdHeaderVersion; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoCapabilitiesKHR::initialize(const safe_VkVideoCapabilitiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + minBitstreamBufferOffsetAlignment = copy_src->minBitstreamBufferOffsetAlignment; + minBitstreamBufferSizeAlignment = copy_src->minBitstreamBufferSizeAlignment; + pictureAccessGranularity = copy_src->pictureAccessGranularity; + minCodedExtent = copy_src->minCodedExtent; + maxCodedExtent = copy_src->maxCodedExtent; + maxDpbSlots = copy_src->maxDpbSlots; + maxActiveReferencePictures = copy_src->maxActiveReferencePictures; + stdHeaderVersion = copy_src->stdHeaderVersion; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceVideoFormatInfoKHR::safe_VkPhysicalDeviceVideoFormatInfoKHR( + const VkPhysicalDeviceVideoFormatInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), imageUsage(in_struct->imageUsage) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceVideoFormatInfoKHR::safe_VkPhysicalDeviceVideoFormatInfoKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR), pNext(nullptr), imageUsage() {} + +safe_VkPhysicalDeviceVideoFormatInfoKHR::safe_VkPhysicalDeviceVideoFormatInfoKHR( + const safe_VkPhysicalDeviceVideoFormatInfoKHR& copy_src) { + sType = copy_src.sType; + imageUsage = copy_src.imageUsage; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceVideoFormatInfoKHR& safe_VkPhysicalDeviceVideoFormatInfoKHR::operator=( + const safe_VkPhysicalDeviceVideoFormatInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + imageUsage = copy_src.imageUsage; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceVideoFormatInfoKHR::~safe_VkPhysicalDeviceVideoFormatInfoKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceVideoFormatInfoKHR::initialize(const VkPhysicalDeviceVideoFormatInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + imageUsage = in_struct->imageUsage; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceVideoFormatInfoKHR::initialize(const safe_VkPhysicalDeviceVideoFormatInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + imageUsage = copy_src->imageUsage; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoFormatPropertiesKHR::safe_VkVideoFormatPropertiesKHR(const VkVideoFormatPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + format(in_struct->format), + componentMapping(in_struct->componentMapping), + imageCreateFlags(in_struct->imageCreateFlags), + imageType(in_struct->imageType), + imageTiling(in_struct->imageTiling), + imageUsageFlags(in_struct->imageUsageFlags) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoFormatPropertiesKHR::safe_VkVideoFormatPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR), + pNext(nullptr), + format(), + componentMapping(), + imageCreateFlags(), + imageType(), + imageTiling(), + imageUsageFlags() {} + +safe_VkVideoFormatPropertiesKHR::safe_VkVideoFormatPropertiesKHR(const safe_VkVideoFormatPropertiesKHR& copy_src) { + sType = copy_src.sType; + format = copy_src.format; + componentMapping = copy_src.componentMapping; + imageCreateFlags = copy_src.imageCreateFlags; + imageType = copy_src.imageType; + imageTiling = copy_src.imageTiling; + imageUsageFlags = copy_src.imageUsageFlags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoFormatPropertiesKHR& safe_VkVideoFormatPropertiesKHR::operator=(const safe_VkVideoFormatPropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + format = copy_src.format; + componentMapping = copy_src.componentMapping; + imageCreateFlags = copy_src.imageCreateFlags; + imageType = copy_src.imageType; + imageTiling = copy_src.imageTiling; + imageUsageFlags = copy_src.imageUsageFlags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoFormatPropertiesKHR::~safe_VkVideoFormatPropertiesKHR() { FreePnextChain(pNext); } + +void safe_VkVideoFormatPropertiesKHR::initialize(const VkVideoFormatPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + format = in_struct->format; + componentMapping = in_struct->componentMapping; + imageCreateFlags = in_struct->imageCreateFlags; + imageType = in_struct->imageType; + imageTiling = in_struct->imageTiling; + imageUsageFlags = in_struct->imageUsageFlags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoFormatPropertiesKHR::initialize(const safe_VkVideoFormatPropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + format = copy_src->format; + componentMapping = copy_src->componentMapping; + imageCreateFlags = copy_src->imageCreateFlags; + imageType = copy_src->imageType; + imageTiling = copy_src->imageTiling; + imageUsageFlags = copy_src->imageUsageFlags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoPictureResourceInfoKHR::safe_VkVideoPictureResourceInfoKHR(const VkVideoPictureResourceInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + codedOffset(in_struct->codedOffset), + codedExtent(in_struct->codedExtent), + baseArrayLayer(in_struct->baseArrayLayer), + imageViewBinding(in_struct->imageViewBinding) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoPictureResourceInfoKHR::safe_VkVideoPictureResourceInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR), + pNext(nullptr), + codedOffset(), + codedExtent(), + baseArrayLayer(), + imageViewBinding() {} + +safe_VkVideoPictureResourceInfoKHR::safe_VkVideoPictureResourceInfoKHR(const safe_VkVideoPictureResourceInfoKHR& copy_src) { + sType = copy_src.sType; + codedOffset = copy_src.codedOffset; + codedExtent = copy_src.codedExtent; + baseArrayLayer = copy_src.baseArrayLayer; + imageViewBinding = copy_src.imageViewBinding; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoPictureResourceInfoKHR& safe_VkVideoPictureResourceInfoKHR::operator=( + const safe_VkVideoPictureResourceInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + codedOffset = copy_src.codedOffset; + codedExtent = copy_src.codedExtent; + baseArrayLayer = copy_src.baseArrayLayer; + imageViewBinding = copy_src.imageViewBinding; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoPictureResourceInfoKHR::~safe_VkVideoPictureResourceInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoPictureResourceInfoKHR::initialize(const VkVideoPictureResourceInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + codedOffset = in_struct->codedOffset; + codedExtent = in_struct->codedExtent; + baseArrayLayer = in_struct->baseArrayLayer; + imageViewBinding = in_struct->imageViewBinding; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoPictureResourceInfoKHR::initialize(const safe_VkVideoPictureResourceInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + codedOffset = copy_src->codedOffset; + codedExtent = copy_src->codedExtent; + baseArrayLayer = copy_src->baseArrayLayer; + imageViewBinding = copy_src->imageViewBinding; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoReferenceSlotInfoKHR::safe_VkVideoReferenceSlotInfoKHR(const VkVideoReferenceSlotInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), slotIndex(in_struct->slotIndex), pPictureResource(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pPictureResource) pPictureResource = new safe_VkVideoPictureResourceInfoKHR(in_struct->pPictureResource); +} + +safe_VkVideoReferenceSlotInfoKHR::safe_VkVideoReferenceSlotInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR), pNext(nullptr), slotIndex(), pPictureResource(nullptr) {} + +safe_VkVideoReferenceSlotInfoKHR::safe_VkVideoReferenceSlotInfoKHR(const safe_VkVideoReferenceSlotInfoKHR& copy_src) { + sType = copy_src.sType; + slotIndex = copy_src.slotIndex; + pPictureResource = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pPictureResource) pPictureResource = new safe_VkVideoPictureResourceInfoKHR(*copy_src.pPictureResource); +} + +safe_VkVideoReferenceSlotInfoKHR& safe_VkVideoReferenceSlotInfoKHR::operator=(const safe_VkVideoReferenceSlotInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pPictureResource) delete pPictureResource; + FreePnextChain(pNext); + + sType = copy_src.sType; + slotIndex = copy_src.slotIndex; + pPictureResource = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pPictureResource) pPictureResource = new safe_VkVideoPictureResourceInfoKHR(*copy_src.pPictureResource); + + return *this; +} + +safe_VkVideoReferenceSlotInfoKHR::~safe_VkVideoReferenceSlotInfoKHR() { + if (pPictureResource) delete pPictureResource; + FreePnextChain(pNext); +} + +void safe_VkVideoReferenceSlotInfoKHR::initialize(const VkVideoReferenceSlotInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPictureResource) delete pPictureResource; + FreePnextChain(pNext); + sType = in_struct->sType; + slotIndex = in_struct->slotIndex; + pPictureResource = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (in_struct->pPictureResource) pPictureResource = new safe_VkVideoPictureResourceInfoKHR(in_struct->pPictureResource); +} + +void safe_VkVideoReferenceSlotInfoKHR::initialize(const safe_VkVideoReferenceSlotInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + slotIndex = copy_src->slotIndex; + pPictureResource = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (copy_src->pPictureResource) pPictureResource = new safe_VkVideoPictureResourceInfoKHR(*copy_src->pPictureResource); +} + +safe_VkVideoSessionMemoryRequirementsKHR::safe_VkVideoSessionMemoryRequirementsKHR( + const VkVideoSessionMemoryRequirementsKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), memoryBindIndex(in_struct->memoryBindIndex), memoryRequirements(in_struct->memoryRequirements) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoSessionMemoryRequirementsKHR::safe_VkVideoSessionMemoryRequirementsKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR), pNext(nullptr), memoryBindIndex(), memoryRequirements() {} + +safe_VkVideoSessionMemoryRequirementsKHR::safe_VkVideoSessionMemoryRequirementsKHR( + const safe_VkVideoSessionMemoryRequirementsKHR& copy_src) { + sType = copy_src.sType; + memoryBindIndex = copy_src.memoryBindIndex; + memoryRequirements = copy_src.memoryRequirements; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoSessionMemoryRequirementsKHR& safe_VkVideoSessionMemoryRequirementsKHR::operator=( + const safe_VkVideoSessionMemoryRequirementsKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memoryBindIndex = copy_src.memoryBindIndex; + memoryRequirements = copy_src.memoryRequirements; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoSessionMemoryRequirementsKHR::~safe_VkVideoSessionMemoryRequirementsKHR() { FreePnextChain(pNext); } + +void safe_VkVideoSessionMemoryRequirementsKHR::initialize(const VkVideoSessionMemoryRequirementsKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memoryBindIndex = in_struct->memoryBindIndex; + memoryRequirements = in_struct->memoryRequirements; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoSessionMemoryRequirementsKHR::initialize(const safe_VkVideoSessionMemoryRequirementsKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memoryBindIndex = copy_src->memoryBindIndex; + memoryRequirements = copy_src->memoryRequirements; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBindVideoSessionMemoryInfoKHR::safe_VkBindVideoSessionMemoryInfoKHR(const VkBindVideoSessionMemoryInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + memoryBindIndex(in_struct->memoryBindIndex), + memory(in_struct->memory), + memoryOffset(in_struct->memoryOffset), + memorySize(in_struct->memorySize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBindVideoSessionMemoryInfoKHR::safe_VkBindVideoSessionMemoryInfoKHR() + : sType(VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR), + pNext(nullptr), + memoryBindIndex(), + memory(), + memoryOffset(), + memorySize() {} + +safe_VkBindVideoSessionMemoryInfoKHR::safe_VkBindVideoSessionMemoryInfoKHR(const safe_VkBindVideoSessionMemoryInfoKHR& copy_src) { + sType = copy_src.sType; + memoryBindIndex = copy_src.memoryBindIndex; + memory = copy_src.memory; + memoryOffset = copy_src.memoryOffset; + memorySize = copy_src.memorySize; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBindVideoSessionMemoryInfoKHR& safe_VkBindVideoSessionMemoryInfoKHR::operator=( + const safe_VkBindVideoSessionMemoryInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memoryBindIndex = copy_src.memoryBindIndex; + memory = copy_src.memory; + memoryOffset = copy_src.memoryOffset; + memorySize = copy_src.memorySize; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBindVideoSessionMemoryInfoKHR::~safe_VkBindVideoSessionMemoryInfoKHR() { FreePnextChain(pNext); } + +void safe_VkBindVideoSessionMemoryInfoKHR::initialize(const VkBindVideoSessionMemoryInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memoryBindIndex = in_struct->memoryBindIndex; + memory = in_struct->memory; + memoryOffset = in_struct->memoryOffset; + memorySize = in_struct->memorySize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBindVideoSessionMemoryInfoKHR::initialize(const safe_VkBindVideoSessionMemoryInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memoryBindIndex = copy_src->memoryBindIndex; + memory = copy_src->memory; + memoryOffset = copy_src->memoryOffset; + memorySize = copy_src->memorySize; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoSessionCreateInfoKHR::safe_VkVideoSessionCreateInfoKHR(const VkVideoSessionCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + queueFamilyIndex(in_struct->queueFamilyIndex), + flags(in_struct->flags), + pVideoProfile(nullptr), + pictureFormat(in_struct->pictureFormat), + maxCodedExtent(in_struct->maxCodedExtent), + referencePictureFormat(in_struct->referencePictureFormat), + maxDpbSlots(in_struct->maxDpbSlots), + maxActiveReferencePictures(in_struct->maxActiveReferencePictures), + pStdHeaderVersion(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(in_struct->pVideoProfile); + + if (in_struct->pStdHeaderVersion) { + pStdHeaderVersion = new VkExtensionProperties(*in_struct->pStdHeaderVersion); + } +} + +safe_VkVideoSessionCreateInfoKHR::safe_VkVideoSessionCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR), + pNext(nullptr), + queueFamilyIndex(), + flags(), + pVideoProfile(nullptr), + pictureFormat(), + maxCodedExtent(), + referencePictureFormat(), + maxDpbSlots(), + maxActiveReferencePictures(), + pStdHeaderVersion(nullptr) {} + +safe_VkVideoSessionCreateInfoKHR::safe_VkVideoSessionCreateInfoKHR(const safe_VkVideoSessionCreateInfoKHR& copy_src) { + sType = copy_src.sType; + queueFamilyIndex = copy_src.queueFamilyIndex; + flags = copy_src.flags; + pVideoProfile = nullptr; + pictureFormat = copy_src.pictureFormat; + maxCodedExtent = copy_src.maxCodedExtent; + referencePictureFormat = copy_src.referencePictureFormat; + maxDpbSlots = copy_src.maxDpbSlots; + maxActiveReferencePictures = copy_src.maxActiveReferencePictures; + pStdHeaderVersion = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(*copy_src.pVideoProfile); + + if (copy_src.pStdHeaderVersion) { + pStdHeaderVersion = new VkExtensionProperties(*copy_src.pStdHeaderVersion); + } +} + +safe_VkVideoSessionCreateInfoKHR& safe_VkVideoSessionCreateInfoKHR::operator=(const safe_VkVideoSessionCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pVideoProfile) delete pVideoProfile; + if (pStdHeaderVersion) delete pStdHeaderVersion; + FreePnextChain(pNext); + + sType = copy_src.sType; + queueFamilyIndex = copy_src.queueFamilyIndex; + flags = copy_src.flags; + pVideoProfile = nullptr; + pictureFormat = copy_src.pictureFormat; + maxCodedExtent = copy_src.maxCodedExtent; + referencePictureFormat = copy_src.referencePictureFormat; + maxDpbSlots = copy_src.maxDpbSlots; + maxActiveReferencePictures = copy_src.maxActiveReferencePictures; + pStdHeaderVersion = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(*copy_src.pVideoProfile); + + if (copy_src.pStdHeaderVersion) { + pStdHeaderVersion = new VkExtensionProperties(*copy_src.pStdHeaderVersion); + } + + return *this; +} + +safe_VkVideoSessionCreateInfoKHR::~safe_VkVideoSessionCreateInfoKHR() { + if (pVideoProfile) delete pVideoProfile; + if (pStdHeaderVersion) delete pStdHeaderVersion; + FreePnextChain(pNext); +} + +void safe_VkVideoSessionCreateInfoKHR::initialize(const VkVideoSessionCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pVideoProfile) delete pVideoProfile; + if (pStdHeaderVersion) delete pStdHeaderVersion; + FreePnextChain(pNext); + sType = in_struct->sType; + queueFamilyIndex = in_struct->queueFamilyIndex; + flags = in_struct->flags; + pVideoProfile = nullptr; + pictureFormat = in_struct->pictureFormat; + maxCodedExtent = in_struct->maxCodedExtent; + referencePictureFormat = in_struct->referencePictureFormat; + maxDpbSlots = in_struct->maxDpbSlots; + maxActiveReferencePictures = in_struct->maxActiveReferencePictures; + pStdHeaderVersion = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (in_struct->pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(in_struct->pVideoProfile); + + if (in_struct->pStdHeaderVersion) { + pStdHeaderVersion = new VkExtensionProperties(*in_struct->pStdHeaderVersion); + } +} + +void safe_VkVideoSessionCreateInfoKHR::initialize(const safe_VkVideoSessionCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + queueFamilyIndex = copy_src->queueFamilyIndex; + flags = copy_src->flags; + pVideoProfile = nullptr; + pictureFormat = copy_src->pictureFormat; + maxCodedExtent = copy_src->maxCodedExtent; + referencePictureFormat = copy_src->referencePictureFormat; + maxDpbSlots = copy_src->maxDpbSlots; + maxActiveReferencePictures = copy_src->maxActiveReferencePictures; + pStdHeaderVersion = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (copy_src->pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(*copy_src->pVideoProfile); + + if (copy_src->pStdHeaderVersion) { + pStdHeaderVersion = new VkExtensionProperties(*copy_src->pStdHeaderVersion); + } +} + +safe_VkVideoSessionParametersCreateInfoKHR::safe_VkVideoSessionParametersCreateInfoKHR( + const VkVideoSessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + videoSessionParametersTemplate(in_struct->videoSessionParametersTemplate), + videoSession(in_struct->videoSession) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoSessionParametersCreateInfoKHR::safe_VkVideoSessionParametersCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR), + pNext(nullptr), + flags(), + videoSessionParametersTemplate(), + videoSession() {} + +safe_VkVideoSessionParametersCreateInfoKHR::safe_VkVideoSessionParametersCreateInfoKHR( + const safe_VkVideoSessionParametersCreateInfoKHR& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + videoSessionParametersTemplate = copy_src.videoSessionParametersTemplate; + videoSession = copy_src.videoSession; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoSessionParametersCreateInfoKHR& safe_VkVideoSessionParametersCreateInfoKHR::operator=( + const safe_VkVideoSessionParametersCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + videoSessionParametersTemplate = copy_src.videoSessionParametersTemplate; + videoSession = copy_src.videoSession; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoSessionParametersCreateInfoKHR::~safe_VkVideoSessionParametersCreateInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoSessionParametersCreateInfoKHR::initialize(const VkVideoSessionParametersCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + videoSessionParametersTemplate = in_struct->videoSessionParametersTemplate; + videoSession = in_struct->videoSession; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoSessionParametersCreateInfoKHR::initialize(const safe_VkVideoSessionParametersCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + videoSessionParametersTemplate = copy_src->videoSessionParametersTemplate; + videoSession = copy_src->videoSession; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoSessionParametersUpdateInfoKHR::safe_VkVideoSessionParametersUpdateInfoKHR( + const VkVideoSessionParametersUpdateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), updateSequenceCount(in_struct->updateSequenceCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoSessionParametersUpdateInfoKHR::safe_VkVideoSessionParametersUpdateInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR), pNext(nullptr), updateSequenceCount() {} + +safe_VkVideoSessionParametersUpdateInfoKHR::safe_VkVideoSessionParametersUpdateInfoKHR( + const safe_VkVideoSessionParametersUpdateInfoKHR& copy_src) { + sType = copy_src.sType; + updateSequenceCount = copy_src.updateSequenceCount; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoSessionParametersUpdateInfoKHR& safe_VkVideoSessionParametersUpdateInfoKHR::operator=( + const safe_VkVideoSessionParametersUpdateInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + updateSequenceCount = copy_src.updateSequenceCount; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoSessionParametersUpdateInfoKHR::~safe_VkVideoSessionParametersUpdateInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoSessionParametersUpdateInfoKHR::initialize(const VkVideoSessionParametersUpdateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + updateSequenceCount = in_struct->updateSequenceCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoSessionParametersUpdateInfoKHR::initialize(const safe_VkVideoSessionParametersUpdateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + updateSequenceCount = copy_src->updateSequenceCount; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoBeginCodingInfoKHR::safe_VkVideoBeginCodingInfoKHR(const VkVideoBeginCodingInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + videoSession(in_struct->videoSession), + videoSessionParameters(in_struct->videoSessionParameters), + referenceSlotCount(in_struct->referenceSlotCount), + pReferenceSlots(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + 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_VkVideoBeginCodingInfoKHR::safe_VkVideoBeginCodingInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR), + pNext(nullptr), + flags(), + videoSession(), + videoSessionParameters(), + referenceSlotCount(), + pReferenceSlots(nullptr) {} + +safe_VkVideoBeginCodingInfoKHR::safe_VkVideoBeginCodingInfoKHR(const safe_VkVideoBeginCodingInfoKHR& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + videoSession = copy_src.videoSession; + videoSessionParameters = copy_src.videoSessionParameters; + referenceSlotCount = copy_src.referenceSlotCount; + pReferenceSlots = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + 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_VkVideoBeginCodingInfoKHR& safe_VkVideoBeginCodingInfoKHR::operator=(const safe_VkVideoBeginCodingInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pReferenceSlots) delete[] pReferenceSlots; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + videoSession = copy_src.videoSession; + videoSessionParameters = copy_src.videoSessionParameters; + referenceSlotCount = copy_src.referenceSlotCount; + pReferenceSlots = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + 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_VkVideoBeginCodingInfoKHR::~safe_VkVideoBeginCodingInfoKHR() { + if (pReferenceSlots) delete[] pReferenceSlots; + FreePnextChain(pNext); +} + +void safe_VkVideoBeginCodingInfoKHR::initialize(const VkVideoBeginCodingInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pReferenceSlots) delete[] pReferenceSlots; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + videoSession = in_struct->videoSession; + videoSessionParameters = in_struct->videoSessionParameters; + referenceSlotCount = in_struct->referenceSlotCount; + pReferenceSlots = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + 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_VkVideoBeginCodingInfoKHR::initialize(const safe_VkVideoBeginCodingInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + videoSession = copy_src->videoSession; + videoSessionParameters = copy_src->videoSessionParameters; + referenceSlotCount = copy_src->referenceSlotCount; + pReferenceSlots = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + 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_VkVideoEndCodingInfoKHR::safe_VkVideoEndCodingInfoKHR(const VkVideoEndCodingInfoKHR* 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_VkVideoEndCodingInfoKHR::safe_VkVideoEndCodingInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR), pNext(nullptr), flags() {} + +safe_VkVideoEndCodingInfoKHR::safe_VkVideoEndCodingInfoKHR(const safe_VkVideoEndCodingInfoKHR& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoEndCodingInfoKHR& safe_VkVideoEndCodingInfoKHR::operator=(const safe_VkVideoEndCodingInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoEndCodingInfoKHR::~safe_VkVideoEndCodingInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEndCodingInfoKHR::initialize(const VkVideoEndCodingInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoEndCodingInfoKHR::initialize(const safe_VkVideoEndCodingInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoCodingControlInfoKHR::safe_VkVideoCodingControlInfoKHR(const VkVideoCodingControlInfoKHR* 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_VkVideoCodingControlInfoKHR::safe_VkVideoCodingControlInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR), pNext(nullptr), flags() {} + +safe_VkVideoCodingControlInfoKHR::safe_VkVideoCodingControlInfoKHR(const safe_VkVideoCodingControlInfoKHR& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoCodingControlInfoKHR& safe_VkVideoCodingControlInfoKHR::operator=(const safe_VkVideoCodingControlInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoCodingControlInfoKHR::~safe_VkVideoCodingControlInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoCodingControlInfoKHR::initialize(const VkVideoCodingControlInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoCodingControlInfoKHR::initialize(const safe_VkVideoCodingControlInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoDecodeCapabilitiesKHR::safe_VkVideoDecodeCapabilitiesKHR(const VkVideoDecodeCapabilitiesKHR* 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_VkVideoDecodeCapabilitiesKHR::safe_VkVideoDecodeCapabilitiesKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR), pNext(nullptr), flags() {} + +safe_VkVideoDecodeCapabilitiesKHR::safe_VkVideoDecodeCapabilitiesKHR(const safe_VkVideoDecodeCapabilitiesKHR& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoDecodeCapabilitiesKHR& safe_VkVideoDecodeCapabilitiesKHR::operator=(const safe_VkVideoDecodeCapabilitiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoDecodeCapabilitiesKHR::~safe_VkVideoDecodeCapabilitiesKHR() { FreePnextChain(pNext); } + +void safe_VkVideoDecodeCapabilitiesKHR::initialize(const VkVideoDecodeCapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoDecodeCapabilitiesKHR::initialize(const safe_VkVideoDecodeCapabilitiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoDecodeUsageInfoKHR::safe_VkVideoDecodeUsageInfoKHR(const VkVideoDecodeUsageInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), videoUsageHints(in_struct->videoUsageHints) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoDecodeUsageInfoKHR::safe_VkVideoDecodeUsageInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR), pNext(nullptr), videoUsageHints() {} + +safe_VkVideoDecodeUsageInfoKHR::safe_VkVideoDecodeUsageInfoKHR(const safe_VkVideoDecodeUsageInfoKHR& copy_src) { + sType = copy_src.sType; + videoUsageHints = copy_src.videoUsageHints; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoDecodeUsageInfoKHR& safe_VkVideoDecodeUsageInfoKHR::operator=(const safe_VkVideoDecodeUsageInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + videoUsageHints = copy_src.videoUsageHints; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoDecodeUsageInfoKHR::~safe_VkVideoDecodeUsageInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoDecodeUsageInfoKHR::initialize(const VkVideoDecodeUsageInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + videoUsageHints = in_struct->videoUsageHints; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoDecodeUsageInfoKHR::initialize(const safe_VkVideoDecodeUsageInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + videoUsageHints = copy_src->videoUsageHints; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoDecodeInfoKHR::safe_VkVideoDecodeInfoKHR(const VkVideoDecodeInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + srcBuffer(in_struct->srcBuffer), + srcBufferOffset(in_struct->srcBufferOffset), + srcBufferRange(in_struct->srcBufferRange), + dstPictureResource(&in_struct->dstPictureResource), + pSetupReferenceSlot(nullptr), + referenceSlotCount(in_struct->referenceSlotCount), + pReferenceSlots(nullptr) { + 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_VkVideoDecodeInfoKHR::safe_VkVideoDecodeInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR), + pNext(nullptr), + flags(), + srcBuffer(), + srcBufferOffset(), + srcBufferRange(), + pSetupReferenceSlot(nullptr), + referenceSlotCount(), + pReferenceSlots(nullptr) {} + +safe_VkVideoDecodeInfoKHR::safe_VkVideoDecodeInfoKHR(const safe_VkVideoDecodeInfoKHR& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + srcBuffer = copy_src.srcBuffer; + srcBufferOffset = copy_src.srcBufferOffset; + srcBufferRange = copy_src.srcBufferRange; + dstPictureResource.initialize(©_src.dstPictureResource); + pSetupReferenceSlot = nullptr; + referenceSlotCount = copy_src.referenceSlotCount; + pReferenceSlots = nullptr; + 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_VkVideoDecodeInfoKHR& safe_VkVideoDecodeInfoKHR::operator=(const safe_VkVideoDecodeInfoKHR& 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; + srcBuffer = copy_src.srcBuffer; + srcBufferOffset = copy_src.srcBufferOffset; + srcBufferRange = copy_src.srcBufferRange; + dstPictureResource.initialize(©_src.dstPictureResource); + pSetupReferenceSlot = nullptr; + referenceSlotCount = copy_src.referenceSlotCount; + pReferenceSlots = nullptr; + 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_VkVideoDecodeInfoKHR::~safe_VkVideoDecodeInfoKHR() { + if (pSetupReferenceSlot) delete pSetupReferenceSlot; + if (pReferenceSlots) delete[] pReferenceSlots; + FreePnextChain(pNext); +} + +void safe_VkVideoDecodeInfoKHR::initialize(const VkVideoDecodeInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pSetupReferenceSlot) delete pSetupReferenceSlot; + if (pReferenceSlots) delete[] pReferenceSlots; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + srcBuffer = in_struct->srcBuffer; + srcBufferOffset = in_struct->srcBufferOffset; + srcBufferRange = in_struct->srcBufferRange; + dstPictureResource.initialize(&in_struct->dstPictureResource); + pSetupReferenceSlot = nullptr; + referenceSlotCount = in_struct->referenceSlotCount; + pReferenceSlots = nullptr; + 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_VkVideoDecodeInfoKHR::initialize(const safe_VkVideoDecodeInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + srcBuffer = copy_src->srcBuffer; + srcBufferOffset = copy_src->srcBufferOffset; + srcBufferRange = copy_src->srcBufferRange; + dstPictureResource.initialize(©_src->dstPictureResource); + pSetupReferenceSlot = nullptr; + referenceSlotCount = copy_src->referenceSlotCount; + pReferenceSlots = nullptr; + 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_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_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); + + 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_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; + 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_VkVideoEncodeH264QualityLevelPropertiesKHR::~safe_VkVideoEncodeH264QualityLevelPropertiesKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeH264QualityLevelPropertiesKHR::initialize(const VkVideoEncodeH264QualityLevelPropertiesKHR* 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_VkVideoEncodeH264QualityLevelPropertiesKHR::initialize(const safe_VkVideoEncodeH264QualityLevelPropertiesKHR* 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_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_VkVideoEncodeH264SessionCreateInfoKHR::safe_VkVideoEncodeH264SessionCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR), pNext(nullptr), useMaxLevelIdc(), maxLevelIdc() {} + +safe_VkVideoEncodeH264SessionCreateInfoKHR::safe_VkVideoEncodeH264SessionCreateInfoKHR( + const safe_VkVideoEncodeH264SessionCreateInfoKHR& copy_src) { + sType = copy_src.sType; + useMaxLevelIdc = copy_src.useMaxLevelIdc; + maxLevelIdc = copy_src.maxLevelIdc; + pNext = SafePnextCopy(copy_src.pNext); +} + +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; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoEncodeH264SessionCreateInfoKHR::~safe_VkVideoEncodeH264SessionCreateInfoKHR() { FreePnextChain(pNext); } + +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; + pNext = SafePnextCopy(in_struct->pNext, 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; + pNext = SafePnextCopy(copy_src->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), + 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_VkVideoEncodeH264SessionParametersAddInfoKHR::safe_VkVideoEncodeH264SessionParametersAddInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR), + pNext(nullptr), + stdSPSCount(), + pStdSPSs(nullptr), + stdPPSCount(), + pStdPPSs(nullptr) {} + +safe_VkVideoEncodeH264SessionParametersAddInfoKHR::safe_VkVideoEncodeH264SessionParametersAddInfoKHR( + const safe_VkVideoEncodeH264SessionParametersAddInfoKHR& 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_VkVideoEncodeH264SessionParametersAddInfoKHR& safe_VkVideoEncodeH264SessionParametersAddInfoKHR::operator=( + const safe_VkVideoEncodeH264SessionParametersAddInfoKHR& 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_VkVideoEncodeH264SessionParametersAddInfoKHR::~safe_VkVideoEncodeH264SessionParametersAddInfoKHR() { + if (pStdSPSs) delete[] pStdSPSs; + if (pStdPPSs) delete[] pStdPPSs; + FreePnextChain(pNext); +} + +void safe_VkVideoEncodeH264SessionParametersAddInfoKHR::initialize(const VkVideoEncodeH264SessionParametersAddInfoKHR* 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_VkVideoEncodeH264SessionParametersAddInfoKHR::initialize( + const safe_VkVideoEncodeH264SessionParametersAddInfoKHR* 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_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), + pParametersAddInfo(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pParametersAddInfo) + pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoKHR(in_struct->pParametersAddInfo); +} + +safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::safe_VkVideoEncodeH264SessionParametersCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR), + pNext(nullptr), + maxStdSPSCount(), + maxStdPPSCount(), + pParametersAddInfo(nullptr) {} + +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_VkVideoEncodeH264SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo); +} + +safe_VkVideoEncodeH264SessionParametersCreateInfoKHR& safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::operator=( + const safe_VkVideoEncodeH264SessionParametersCreateInfoKHR& 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_VkVideoEncodeH264SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo); + + return *this; +} + +safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::~safe_VkVideoEncodeH264SessionParametersCreateInfoKHR() { + if (pParametersAddInfo) delete pParametersAddInfo; + FreePnextChain(pNext); +} + +void safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::initialize( + const VkVideoEncodeH264SessionParametersCreateInfoKHR* 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_VkVideoEncodeH264SessionParametersAddInfoKHR(in_struct->pParametersAddInfo); +} + +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_VkVideoEncodeH264SessionParametersAddInfoKHR(*copy_src->pParametersAddInfo); +} + +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); + } +} + +safe_VkVideoEncodeH264SessionParametersGetInfoKHR::safe_VkVideoEncodeH264SessionParametersGetInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR), + pNext(nullptr), + writeStdSPS(), + writeStdPPS(), + stdSPSId(), + stdPPSId() {} + +safe_VkVideoEncodeH264SessionParametersGetInfoKHR::safe_VkVideoEncodeH264SessionParametersGetInfoKHR( + const safe_VkVideoEncodeH264SessionParametersGetInfoKHR& 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_VkVideoEncodeH264SessionParametersGetInfoKHR& safe_VkVideoEncodeH264SessionParametersGetInfoKHR::operator=( + const safe_VkVideoEncodeH264SessionParametersGetInfoKHR& 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_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_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::~safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR() { + FreePnextChain(pNext); +} + +void safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::initialize( + const VkVideoEncodeH264SessionParametersFeedbackInfoKHR* 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_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::initialize( + const safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR* 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_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->pStdSliceHeader) { + pStdSliceHeader = new StdVideoEncodeH264SliceHeader(*in_struct->pStdSliceHeader); + } +} + +safe_VkVideoEncodeH264NaluSliceInfoKHR::safe_VkVideoEncodeH264NaluSliceInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR), pNext(nullptr), constantQp(), pStdSliceHeader(nullptr) {} + +safe_VkVideoEncodeH264NaluSliceInfoKHR::safe_VkVideoEncodeH264NaluSliceInfoKHR( + const safe_VkVideoEncodeH264NaluSliceInfoKHR& 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_VkVideoEncodeH264NaluSliceInfoKHR& safe_VkVideoEncodeH264NaluSliceInfoKHR::operator=( + const safe_VkVideoEncodeH264NaluSliceInfoKHR& 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_VkVideoEncodeH264NaluSliceInfoKHR::~safe_VkVideoEncodeH264NaluSliceInfoKHR() { + if (pStdSliceHeader) delete pStdSliceHeader; + FreePnextChain(pNext); +} + +void safe_VkVideoEncodeH264NaluSliceInfoKHR::initialize(const VkVideoEncodeH264NaluSliceInfoKHR* 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_VkVideoEncodeH264NaluSliceInfoKHR::initialize(const safe_VkVideoEncodeH264NaluSliceInfoKHR* 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_VkVideoEncodeH264PictureInfoKHR::safe_VkVideoEncodeH264PictureInfoKHR(const VkVideoEncodeH264PictureInfoKHR* 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_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_VkVideoEncodeH264PictureInfoKHR::safe_VkVideoEncodeH264PictureInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR), + pNext(nullptr), + naluSliceEntryCount(), + pNaluSliceEntries(nullptr), + pStdPictureInfo(nullptr), + generatePrefixNalu() {} + +safe_VkVideoEncodeH264PictureInfoKHR::safe_VkVideoEncodeH264PictureInfoKHR(const safe_VkVideoEncodeH264PictureInfoKHR& 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_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_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; + 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_VkVideoEncodeH264PictureInfoKHR::~safe_VkVideoEncodeH264PictureInfoKHR() { + if (pNaluSliceEntries) delete[] pNaluSliceEntries; + if (pStdPictureInfo) delete pStdPictureInfo; + FreePnextChain(pNext); +} + +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; + 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_VkVideoEncodeH264PictureInfoKHR::initialize(const safe_VkVideoEncodeH264PictureInfoKHR* 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_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_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_VkVideoEncodeH264DpbSlotInfoKHR::safe_VkVideoEncodeH264DpbSlotInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {} + +safe_VkVideoEncodeH264DpbSlotInfoKHR::safe_VkVideoEncodeH264DpbSlotInfoKHR(const safe_VkVideoEncodeH264DpbSlotInfoKHR& copy_src) { + sType = copy_src.sType; + pStdReferenceInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoEncodeH264ReferenceInfo(*copy_src.pStdReferenceInfo); + } +} + +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; + pStdReferenceInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoEncodeH264ReferenceInfo(*copy_src.pStdReferenceInfo); + } + + return *this; +} + +safe_VkVideoEncodeH264DpbSlotInfoKHR::~safe_VkVideoEncodeH264DpbSlotInfoKHR() { + if (pStdReferenceInfo) delete pStdReferenceInfo; + FreePnextChain(pNext); +} + +void safe_VkVideoEncodeH264DpbSlotInfoKHR::initialize(const VkVideoEncodeH264DpbSlotInfoKHR* 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_VkVideoEncodeH264DpbSlotInfoKHR::initialize(const safe_VkVideoEncodeH264DpbSlotInfoKHR* 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_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); + } +} + +safe_VkVideoEncodeH264ProfileInfoKHR::safe_VkVideoEncodeH264ProfileInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR), pNext(nullptr), stdProfileIdc() {} + +safe_VkVideoEncodeH264ProfileInfoKHR::safe_VkVideoEncodeH264ProfileInfoKHR(const safe_VkVideoEncodeH264ProfileInfoKHR& copy_src) { + sType = copy_src.sType; + stdProfileIdc = copy_src.stdProfileIdc; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoEncodeH264ProfileInfoKHR& safe_VkVideoEncodeH264ProfileInfoKHR::operator=( + const safe_VkVideoEncodeH264ProfileInfoKHR& 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_VkVideoEncodeH264ProfileInfoKHR::~safe_VkVideoEncodeH264ProfileInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeH264ProfileInfoKHR::initialize(const VkVideoEncodeH264ProfileInfoKHR* 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_VkVideoEncodeH264ProfileInfoKHR::initialize(const safe_VkVideoEncodeH264ProfileInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stdProfileIdc = copy_src->stdProfileIdc; + pNext = SafePnextCopy(copy_src->pNext); +} + +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_VkVideoEncodeH264RateControlInfoKHR::safe_VkVideoEncodeH264RateControlInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR), + pNext(nullptr), + flags(), + gopFrameCount(), + idrPeriod(), + consecutiveBFrameCount(), + temporalLayerCount() {} + +safe_VkVideoEncodeH264RateControlInfoKHR::safe_VkVideoEncodeH264RateControlInfoKHR( + const safe_VkVideoEncodeH264RateControlInfoKHR& 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_VkVideoEncodeH264RateControlInfoKHR& safe_VkVideoEncodeH264RateControlInfoKHR::operator=( + const safe_VkVideoEncodeH264RateControlInfoKHR& 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_VkVideoEncodeH264RateControlInfoKHR::~safe_VkVideoEncodeH264RateControlInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeH264RateControlInfoKHR::initialize(const VkVideoEncodeH264RateControlInfoKHR* 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_VkVideoEncodeH264RateControlInfoKHR::initialize(const safe_VkVideoEncodeH264RateControlInfoKHR* 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_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_VkVideoEncodeH264RateControlLayerInfoKHR::safe_VkVideoEncodeH264RateControlLayerInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR), + pNext(nullptr), + useMinQp(), + minQp(), + useMaxQp(), + maxQp(), + useMaxFrameSize(), + maxFrameSize() {} + +safe_VkVideoEncodeH264RateControlLayerInfoKHR::safe_VkVideoEncodeH264RateControlLayerInfoKHR( + const safe_VkVideoEncodeH264RateControlLayerInfoKHR& 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_VkVideoEncodeH264RateControlLayerInfoKHR& safe_VkVideoEncodeH264RateControlLayerInfoKHR::operator=( + const safe_VkVideoEncodeH264RateControlLayerInfoKHR& 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_VkVideoEncodeH264RateControlLayerInfoKHR::~safe_VkVideoEncodeH264RateControlLayerInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeH264RateControlLayerInfoKHR::initialize(const VkVideoEncodeH264RateControlLayerInfoKHR* 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_VkVideoEncodeH264RateControlLayerInfoKHR::initialize(const safe_VkVideoEncodeH264RateControlLayerInfoKHR* 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_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_VkVideoEncodeH264GopRemainingFrameInfoKHR::safe_VkVideoEncodeH264GopRemainingFrameInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR), + pNext(nullptr), + useGopRemainingFrames(), + gopRemainingI(), + gopRemainingP(), + gopRemainingB() {} + +safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::safe_VkVideoEncodeH264GopRemainingFrameInfoKHR( + const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR& 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_VkVideoEncodeH264GopRemainingFrameInfoKHR& safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::operator=( + const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR& 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_VkVideoEncodeH264GopRemainingFrameInfoKHR::~safe_VkVideoEncodeH264GopRemainingFrameInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::initialize(const VkVideoEncodeH264GopRemainingFrameInfoKHR* 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_VkVideoEncodeH264GopRemainingFrameInfoKHR::initialize(const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR* 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_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_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); + + 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_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; + useMaxLevelIdc = copy_src.useMaxLevelIdc; + maxLevelIdc = copy_src.maxLevelIdc; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoEncodeH265SessionCreateInfoKHR::~safe_VkVideoEncodeH265SessionCreateInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeH265SessionCreateInfoKHR::initialize(const VkVideoEncodeH265SessionCreateInfoKHR* 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_VkVideoEncodeH265SessionCreateInfoKHR::initialize(const safe_VkVideoEncodeH265SessionCreateInfoKHR* 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_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_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_VkVideoEncodeH265QualityLevelPropertiesKHR::safe_VkVideoEncodeH265QualityLevelPropertiesKHR( + const safe_VkVideoEncodeH265QualityLevelPropertiesKHR& 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_VkVideoEncodeH265QualityLevelPropertiesKHR& safe_VkVideoEncodeH265QualityLevelPropertiesKHR::operator=( + const safe_VkVideoEncodeH265QualityLevelPropertiesKHR& 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_VkVideoEncodeH265QualityLevelPropertiesKHR::~safe_VkVideoEncodeH265QualityLevelPropertiesKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeH265QualityLevelPropertiesKHR::initialize(const VkVideoEncodeH265QualityLevelPropertiesKHR* 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_VkVideoEncodeH265QualityLevelPropertiesKHR::initialize(const safe_VkVideoEncodeH265QualityLevelPropertiesKHR* 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_VkVideoEncodeH265SessionParametersAddInfoKHR::safe_VkVideoEncodeH265SessionParametersAddInfoKHR( + const VkVideoEncodeH265SessionParametersAddInfoKHR* 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_VkVideoEncodeH265SessionParametersAddInfoKHR::safe_VkVideoEncodeH265SessionParametersAddInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR), + pNext(nullptr), + stdVPSCount(), + pStdVPSs(nullptr), + stdSPSCount(), + pStdSPSs(nullptr), + stdPPSCount(), + pStdPPSs(nullptr) {} + +safe_VkVideoEncodeH265SessionParametersAddInfoKHR::safe_VkVideoEncodeH265SessionParametersAddInfoKHR( + const safe_VkVideoEncodeH265SessionParametersAddInfoKHR& 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_VkVideoEncodeH265SessionParametersAddInfoKHR& safe_VkVideoEncodeH265SessionParametersAddInfoKHR::operator=( + const safe_VkVideoEncodeH265SessionParametersAddInfoKHR& 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_VkVideoEncodeH265SessionParametersAddInfoKHR::~safe_VkVideoEncodeH265SessionParametersAddInfoKHR() { + if (pStdVPSs) delete[] pStdVPSs; + if (pStdSPSs) delete[] pStdSPSs; + if (pStdPPSs) delete[] pStdPPSs; + FreePnextChain(pNext); +} + +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; + 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_VkVideoEncodeH265SessionParametersAddInfoKHR::initialize( + const safe_VkVideoEncodeH265SessionParametersAddInfoKHR* 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_VkVideoEncodeH265SessionParametersCreateInfoKHR::safe_VkVideoEncodeH265SessionParametersCreateInfoKHR( + const VkVideoEncodeH265SessionParametersCreateInfoKHR* 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_VkVideoEncodeH265SessionParametersAddInfoKHR(in_struct->pParametersAddInfo); +} + +safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::safe_VkVideoEncodeH265SessionParametersCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR), + pNext(nullptr), + maxStdVPSCount(), + maxStdSPSCount(), + maxStdPPSCount(), + pParametersAddInfo(nullptr) {} + +safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::safe_VkVideoEncodeH265SessionParametersCreateInfoKHR( + const safe_VkVideoEncodeH265SessionParametersCreateInfoKHR& 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_VkVideoEncodeH265SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo); +} + +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; + 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_VkVideoEncodeH265SessionParametersCreateInfoKHR::~safe_VkVideoEncodeH265SessionParametersCreateInfoKHR() { + if (pParametersAddInfo) delete pParametersAddInfo; + FreePnextChain(pNext); +} + +void safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::initialize( + const VkVideoEncodeH265SessionParametersCreateInfoKHR* 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_VkVideoEncodeH265SessionParametersAddInfoKHR(in_struct->pParametersAddInfo); +} + +void safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::initialize( + const safe_VkVideoEncodeH265SessionParametersCreateInfoKHR* 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_VkVideoEncodeH265SessionParametersAddInfoKHR(*copy_src->pParametersAddInfo); +} + +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); + } +} + +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_VkVideoEncodeH265SessionParametersGetInfoKHR::safe_VkVideoEncodeH265SessionParametersGetInfoKHR( + const safe_VkVideoEncodeH265SessionParametersGetInfoKHR& 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_VkVideoEncodeH265SessionParametersGetInfoKHR& safe_VkVideoEncodeH265SessionParametersGetInfoKHR::operator=( + const safe_VkVideoEncodeH265SessionParametersGetInfoKHR& 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_VkVideoEncodeH265SessionParametersGetInfoKHR::~safe_VkVideoEncodeH265SessionParametersGetInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeH265SessionParametersGetInfoKHR::initialize(const VkVideoEncodeH265SessionParametersGetInfoKHR* 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_VkVideoEncodeH265SessionParametersGetInfoKHR::initialize( + const safe_VkVideoEncodeH265SessionParametersGetInfoKHR* 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_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR( + const VkVideoEncodeH265SessionParametersFeedbackInfoKHR* 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_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR), + pNext(nullptr), + hasStdVPSOverrides(), + hasStdSPSOverrides(), + hasStdPPSOverrides() {} + +safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR( + const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR& copy_src) { + sType = copy_src.sType; + hasStdVPSOverrides = copy_src.hasStdVPSOverrides; + hasStdSPSOverrides = copy_src.hasStdSPSOverrides; + hasStdPPSOverrides = copy_src.hasStdPPSOverrides; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR& safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::operator=( + const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR& 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_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::~safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR() { + FreePnextChain(pNext); +} + +void safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::initialize( + const VkVideoEncodeH265SessionParametersFeedbackInfoKHR* 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_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::initialize( + const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR* 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_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_VkVideoEncodeH265NaluSliceSegmentInfoKHR::safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR), + pNext(nullptr), + constantQp(), + pStdSliceSegmentHeader(nullptr) {} + +safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR( + const safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR& 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_VkVideoEncodeH265NaluSliceSegmentInfoKHR& safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::operator=( + const safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR& 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_VkVideoEncodeH265NaluSliceSegmentInfoKHR::~safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR() { + if (pStdSliceSegmentHeader) delete pStdSliceSegmentHeader; + FreePnextChain(pNext); +} + +void safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::initialize(const VkVideoEncodeH265NaluSliceSegmentInfoKHR* 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_VkVideoEncodeH265NaluSliceSegmentInfoKHR::initialize(const safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR* 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_VkVideoEncodeH265PictureInfoKHR::safe_VkVideoEncodeH265PictureInfoKHR(const VkVideoEncodeH265PictureInfoKHR* 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_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_VkVideoEncodeH265PictureInfoKHR::safe_VkVideoEncodeH265PictureInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR), + pNext(nullptr), + naluSliceSegmentEntryCount(), + pNaluSliceSegmentEntries(nullptr), + pStdPictureInfo(nullptr) {} + +safe_VkVideoEncodeH265PictureInfoKHR::safe_VkVideoEncodeH265PictureInfoKHR(const safe_VkVideoEncodeH265PictureInfoKHR& 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_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_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; + 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_VkVideoEncodeH265PictureInfoKHR::~safe_VkVideoEncodeH265PictureInfoKHR() { + if (pNaluSliceSegmentEntries) delete[] pNaluSliceSegmentEntries; + if (pStdPictureInfo) delete pStdPictureInfo; + FreePnextChain(pNext); +} + +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; + 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_VkVideoEncodeH265PictureInfoKHR::initialize(const safe_VkVideoEncodeH265PictureInfoKHR* 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_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_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_VkVideoEncodeH265DpbSlotInfoKHR::safe_VkVideoEncodeH265DpbSlotInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {} + +safe_VkVideoEncodeH265DpbSlotInfoKHR::safe_VkVideoEncodeH265DpbSlotInfoKHR(const safe_VkVideoEncodeH265DpbSlotInfoKHR& copy_src) { + sType = copy_src.sType; + pStdReferenceInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoEncodeH265ReferenceInfo(*copy_src.pStdReferenceInfo); + } +} + +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; + pStdReferenceInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoEncodeH265ReferenceInfo(*copy_src.pStdReferenceInfo); + } + + return *this; +} + +safe_VkVideoEncodeH265DpbSlotInfoKHR::~safe_VkVideoEncodeH265DpbSlotInfoKHR() { + if (pStdReferenceInfo) delete pStdReferenceInfo; + FreePnextChain(pNext); +} + +void safe_VkVideoEncodeH265DpbSlotInfoKHR::initialize(const VkVideoEncodeH265DpbSlotInfoKHR* 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_VkVideoEncodeH265DpbSlotInfoKHR::initialize(const safe_VkVideoEncodeH265DpbSlotInfoKHR* 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_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_VkVideoEncodeH265ProfileInfoKHR::safe_VkVideoEncodeH265ProfileInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR), pNext(nullptr), stdProfileIdc() {} + +safe_VkVideoEncodeH265ProfileInfoKHR::safe_VkVideoEncodeH265ProfileInfoKHR(const safe_VkVideoEncodeH265ProfileInfoKHR& copy_src) { + sType = copy_src.sType; + stdProfileIdc = copy_src.stdProfileIdc; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoEncodeH265ProfileInfoKHR& safe_VkVideoEncodeH265ProfileInfoKHR::operator=( + const safe_VkVideoEncodeH265ProfileInfoKHR& 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_VkVideoEncodeH265ProfileInfoKHR::~safe_VkVideoEncodeH265ProfileInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeH265ProfileInfoKHR::initialize(const VkVideoEncodeH265ProfileInfoKHR* 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_VkVideoEncodeH265ProfileInfoKHR::initialize(const safe_VkVideoEncodeH265ProfileInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stdProfileIdc = copy_src->stdProfileIdc; + pNext = SafePnextCopy(copy_src->pNext); +} + +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_VkVideoEncodeH265RateControlInfoKHR::safe_VkVideoEncodeH265RateControlInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR), + pNext(nullptr), + flags(), + gopFrameCount(), + idrPeriod(), + consecutiveBFrameCount(), + subLayerCount() {} + +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_VkVideoEncodeH265RateControlInfoKHR& safe_VkVideoEncodeH265RateControlInfoKHR::operator=( + const safe_VkVideoEncodeH265RateControlInfoKHR& 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_VkVideoEncodeH265RateControlInfoKHR::~safe_VkVideoEncodeH265RateControlInfoKHR() { FreePnextChain(pNext); } + +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_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_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); + } +} + +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_VkVideoEncodeH265RateControlLayerInfoKHR::safe_VkVideoEncodeH265RateControlLayerInfoKHR( + const safe_VkVideoEncodeH265RateControlLayerInfoKHR& 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_VkVideoEncodeH265RateControlLayerInfoKHR& safe_VkVideoEncodeH265RateControlLayerInfoKHR::operator=( + const safe_VkVideoEncodeH265RateControlLayerInfoKHR& 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_VkVideoEncodeH265RateControlLayerInfoKHR::~safe_VkVideoEncodeH265RateControlLayerInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeH265RateControlLayerInfoKHR::initialize(const VkVideoEncodeH265RateControlLayerInfoKHR* 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_VkVideoEncodeH265RateControlLayerInfoKHR::initialize(const safe_VkVideoEncodeH265RateControlLayerInfoKHR* 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_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_VkVideoEncodeH265GopRemainingFrameInfoKHR::safe_VkVideoEncodeH265GopRemainingFrameInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR), + pNext(nullptr), + useGopRemainingFrames(), + gopRemainingI(), + gopRemainingP(), + gopRemainingB() {} + +safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::safe_VkVideoEncodeH265GopRemainingFrameInfoKHR( + const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR& 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_VkVideoEncodeH265GopRemainingFrameInfoKHR& safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::operator=( + const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR& 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_VkVideoEncodeH265GopRemainingFrameInfoKHR::~safe_VkVideoEncodeH265GopRemainingFrameInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::initialize(const VkVideoEncodeH265GopRemainingFrameInfoKHR* 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_VkVideoEncodeH265GopRemainingFrameInfoKHR::initialize(const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR* 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_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) { + 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_VkVideoDecodeH264ProfileInfoKHR::safe_VkVideoDecodeH264ProfileInfoKHR(const safe_VkVideoDecodeH264ProfileInfoKHR& copy_src) { + sType = copy_src.sType; + stdProfileIdc = copy_src.stdProfileIdc; + pictureLayout = copy_src.pictureLayout; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoDecodeH264ProfileInfoKHR& safe_VkVideoDecodeH264ProfileInfoKHR::operator=( + const safe_VkVideoDecodeH264ProfileInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + stdProfileIdc = copy_src.stdProfileIdc; + pictureLayout = copy_src.pictureLayout; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoDecodeH264ProfileInfoKHR::~safe_VkVideoDecodeH264ProfileInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoDecodeH264ProfileInfoKHR::initialize(const VkVideoDecodeH264ProfileInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + stdProfileIdc = in_struct->stdProfileIdc; + pictureLayout = in_struct->pictureLayout; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoDecodeH264ProfileInfoKHR::initialize(const safe_VkVideoDecodeH264ProfileInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stdProfileIdc = copy_src->stdProfileIdc; + pictureLayout = copy_src->pictureLayout; + 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) { + 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_VkVideoDecodeH264CapabilitiesKHR::safe_VkVideoDecodeH264CapabilitiesKHR( + const safe_VkVideoDecodeH264CapabilitiesKHR& copy_src) { + sType = copy_src.sType; + maxLevelIdc = copy_src.maxLevelIdc; + fieldOffsetGranularity = copy_src.fieldOffsetGranularity; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoDecodeH264CapabilitiesKHR& safe_VkVideoDecodeH264CapabilitiesKHR::operator=( + const safe_VkVideoDecodeH264CapabilitiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxLevelIdc = copy_src.maxLevelIdc; + fieldOffsetGranularity = copy_src.fieldOffsetGranularity; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoDecodeH264CapabilitiesKHR::~safe_VkVideoDecodeH264CapabilitiesKHR() { FreePnextChain(pNext); } + +void safe_VkVideoDecodeH264CapabilitiesKHR::initialize(const VkVideoDecodeH264CapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + 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) { + sType = copy_src->sType; + 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) + : 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_VkVideoDecodeH264SessionParametersAddInfoKHR::safe_VkVideoDecodeH264SessionParametersAddInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR), + pNext(nullptr), + stdSPSCount(), + pStdSPSs(nullptr), + stdPPSCount(), + pStdPPSs(nullptr) {} + +safe_VkVideoDecodeH264SessionParametersAddInfoKHR::safe_VkVideoDecodeH264SessionParametersAddInfoKHR( + const safe_VkVideoDecodeH264SessionParametersAddInfoKHR& 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_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; + 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_VkVideoDecodeH264SessionParametersAddInfoKHR::~safe_VkVideoDecodeH264SessionParametersAddInfoKHR() { + if (pStdSPSs) delete[] pStdSPSs; + if (pStdPPSs) delete[] pStdPPSs; + FreePnextChain(pNext); +} + +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; + 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_VkVideoDecodeH264SessionParametersAddInfoKHR::initialize( + const safe_VkVideoDecodeH264SessionParametersAddInfoKHR* 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_VkVideoDecodeH264SessionParametersCreateInfoKHR::safe_VkVideoDecodeH264SessionParametersCreateInfoKHR( + const VkVideoDecodeH264SessionParametersCreateInfoKHR* 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_VkVideoDecodeH264SessionParametersAddInfoKHR(in_struct->pParametersAddInfo); +} + +safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::safe_VkVideoDecodeH264SessionParametersCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR), + pNext(nullptr), + maxStdSPSCount(), + maxStdPPSCount(), + pParametersAddInfo(nullptr) {} + +safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::safe_VkVideoDecodeH264SessionParametersCreateInfoKHR( + const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& 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); +} + +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; + 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_VkVideoDecodeH264SessionParametersCreateInfoKHR::~safe_VkVideoDecodeH264SessionParametersCreateInfoKHR() { + if (pParametersAddInfo) delete pParametersAddInfo; + FreePnextChain(pNext); +} + +void safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::initialize( + const VkVideoDecodeH264SessionParametersCreateInfoKHR* 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_VkVideoDecodeH264SessionParametersAddInfoKHR(in_struct->pParametersAddInfo); +} + +void safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::initialize( + const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR* 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); +} + +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); + } + 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), + 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; + 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_VkVideoDecodeH264PictureInfoKHR::~safe_VkVideoDecodeH264PictureInfoKHR() { + if (pStdPictureInfo) delete pStdPictureInfo; + if (pSliceOffsets) delete[] pSliceOffsets; + FreePnextChain(pNext); +} + +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; + 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_VkVideoDecodeH264PictureInfoKHR::initialize(const safe_VkVideoDecodeH264PictureInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + 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_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_VkVideoDecodeH264DpbSlotInfoKHR::safe_VkVideoDecodeH264DpbSlotInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {} + +safe_VkVideoDecodeH264DpbSlotInfoKHR::safe_VkVideoDecodeH264DpbSlotInfoKHR(const safe_VkVideoDecodeH264DpbSlotInfoKHR& copy_src) { + sType = copy_src.sType; + pStdReferenceInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*copy_src.pStdReferenceInfo); + } +} + +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; + pStdReferenceInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*copy_src.pStdReferenceInfo); + } + + return *this; +} + +safe_VkVideoDecodeH264DpbSlotInfoKHR::~safe_VkVideoDecodeH264DpbSlotInfoKHR() { + if (pStdReferenceInfo) delete pStdReferenceInfo; + FreePnextChain(pNext); +} + +void safe_VkVideoDecodeH264DpbSlotInfoKHR::initialize(const VkVideoDecodeH264DpbSlotInfoKHR* 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 StdVideoDecodeH264ReferenceInfo(*in_struct->pStdReferenceInfo); + } +} + +void safe_VkVideoDecodeH264DpbSlotInfoKHR::initialize(const safe_VkVideoDecodeH264DpbSlotInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pStdReferenceInfo = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*copy_src->pStdReferenceInfo); + } +} + +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_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR() + : sType(VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR), + pNext(nullptr), + imageView(), + imageLayout(), + shadingRateAttachmentTexelSize() {} + +safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR( + const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src) { + sType = copy_src.sType; + imageView = copy_src.imageView; + imageLayout = copy_src.imageLayout; + shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::operator=( + const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + imageView = copy_src.imageView; + imageLayout = copy_src.imageLayout; + shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::~safe_VkRenderingFragmentShadingRateAttachmentInfoKHR() { + FreePnextChain(pNext); +} + +void safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::initialize( + const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + imageView = in_struct->imageView; + imageLayout = in_struct->imageLayout; + shadingRateAttachmentTexelSize = in_struct->shadingRateAttachmentTexelSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::initialize( + const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + imageView = copy_src->imageView; + imageLayout = copy_src->imageLayout; + shadingRateAttachmentTexelSize = copy_src->shadingRateAttachmentTexelSize; + pNext = SafePnextCopy(copy_src->pNext); +} +#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) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR() + : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR), pNext(nullptr), handleType(), handle(), name() {} + +safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR( + const safe_VkImportMemoryWin32HandleInfoKHR& copy_src) { + sType = copy_src.sType; + handleType = copy_src.handleType; + handle = copy_src.handle; + name = copy_src.name; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImportMemoryWin32HandleInfoKHR& safe_VkImportMemoryWin32HandleInfoKHR::operator=( + const safe_VkImportMemoryWin32HandleInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + handleType = copy_src.handleType; + handle = copy_src.handle; + name = copy_src.name; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImportMemoryWin32HandleInfoKHR::~safe_VkImportMemoryWin32HandleInfoKHR() { FreePnextChain(pNext); } + +void safe_VkImportMemoryWin32HandleInfoKHR::initialize(const VkImportMemoryWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + handleType = in_struct->handleType; + handle = in_struct->handle; + name = in_struct->name; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImportMemoryWin32HandleInfoKHR::initialize(const safe_VkImportMemoryWin32HandleInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + handleType = copy_src->handleType; + handle = copy_src->handle; + name = copy_src->name; + pNext = SafePnextCopy(copy_src->pNext); +} + +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); + } + 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_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR( + const safe_VkExportMemoryWin32HandleInfoKHR& copy_src) { + 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); + } +} + +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; + 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_VkExportMemoryWin32HandleInfoKHR::~safe_VkExportMemoryWin32HandleInfoKHR() { + if (pAttributes) delete pAttributes; + FreePnextChain(pNext); +} + +void safe_VkExportMemoryWin32HandleInfoKHR::initialize(const VkExportMemoryWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pAttributes) delete pAttributes; + FreePnextChain(pNext); + sType = in_struct->sType; + 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_VkExportMemoryWin32HandleInfoKHR::initialize(const safe_VkExportMemoryWin32HandleInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + 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); + } +} + +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); + } +} + +safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR() + : sType(VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR), pNext(nullptr), memoryTypeBits() {} + +safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR( + const safe_VkMemoryWin32HandlePropertiesKHR& copy_src) { + sType = copy_src.sType; + memoryTypeBits = copy_src.memoryTypeBits; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryWin32HandlePropertiesKHR& safe_VkMemoryWin32HandlePropertiesKHR::operator=( + const safe_VkMemoryWin32HandlePropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memoryTypeBits = copy_src.memoryTypeBits; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryWin32HandlePropertiesKHR::~safe_VkMemoryWin32HandlePropertiesKHR() { FreePnextChain(pNext); } + +void safe_VkMemoryWin32HandlePropertiesKHR::initialize(const VkMemoryWin32HandlePropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memoryTypeBits = in_struct->memoryTypeBits; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryWin32HandlePropertiesKHR::initialize(const safe_VkMemoryWin32HandlePropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memoryTypeBits = copy_src->memoryTypeBits; + 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) { + 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_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR(const safe_VkMemoryGetWin32HandleInfoKHR& copy_src) { + sType = copy_src.sType; + memory = copy_src.memory; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryGetWin32HandleInfoKHR& safe_VkMemoryGetWin32HandleInfoKHR::operator=( + const safe_VkMemoryGetWin32HandleInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memory = copy_src.memory; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryGetWin32HandleInfoKHR::~safe_VkMemoryGetWin32HandleInfoKHR() { FreePnextChain(pNext); } + +void safe_VkMemoryGetWin32HandleInfoKHR::initialize(const VkMemoryGetWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memory = in_struct->memory; + handleType = in_struct->handleType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryGetWin32HandleInfoKHR::initialize(const safe_VkMemoryGetWin32HandleInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memory = copy_src->memory; + handleType = copy_src->handleType; + 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) { + 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_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR(const safe_VkImportMemoryFdInfoKHR& copy_src) { + sType = copy_src.sType; + handleType = copy_src.handleType; + fd = copy_src.fd; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImportMemoryFdInfoKHR& safe_VkImportMemoryFdInfoKHR::operator=(const safe_VkImportMemoryFdInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + handleType = copy_src.handleType; + fd = copy_src.fd; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImportMemoryFdInfoKHR::~safe_VkImportMemoryFdInfoKHR() { FreePnextChain(pNext); } + +void safe_VkImportMemoryFdInfoKHR::initialize(const VkImportMemoryFdInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + handleType = in_struct->handleType; + fd = in_struct->fd; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImportMemoryFdInfoKHR::initialize(const safe_VkImportMemoryFdInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + handleType = copy_src->handleType; + fd = copy_src->fd; + 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) { + 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_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR(const safe_VkMemoryFdPropertiesKHR& copy_src) { + sType = copy_src.sType; + memoryTypeBits = copy_src.memoryTypeBits; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryFdPropertiesKHR& safe_VkMemoryFdPropertiesKHR::operator=(const safe_VkMemoryFdPropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memoryTypeBits = copy_src.memoryTypeBits; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryFdPropertiesKHR::~safe_VkMemoryFdPropertiesKHR() { FreePnextChain(pNext); } + +void safe_VkMemoryFdPropertiesKHR::initialize(const VkMemoryFdPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memoryTypeBits = in_struct->memoryTypeBits; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryFdPropertiesKHR::initialize(const safe_VkMemoryFdPropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memoryTypeBits = copy_src->memoryTypeBits; + 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) { + 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_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR(const safe_VkMemoryGetFdInfoKHR& copy_src) { + sType = copy_src.sType; + memory = copy_src.memory; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryGetFdInfoKHR& safe_VkMemoryGetFdInfoKHR::operator=(const safe_VkMemoryGetFdInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memory = copy_src.memory; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryGetFdInfoKHR::~safe_VkMemoryGetFdInfoKHR() { FreePnextChain(pNext); } + +void safe_VkMemoryGetFdInfoKHR::initialize(const VkMemoryGetFdInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memory = in_struct->memory; + handleType = in_struct->handleType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryGetFdInfoKHR::initialize(const safe_VkMemoryGetFdInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memory = copy_src->memory; + handleType = copy_src->handleType; + 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) + : 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]; + } + } + + 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); + } +} + +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; + 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_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; + 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); + } + + 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; + 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_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR* 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; + 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_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_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR() + : sType(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR), + pNext(nullptr), + semaphore(), + flags(), + handleType(), + handle(), + name() {} + +safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR( + const safe_VkImportSemaphoreWin32HandleInfoKHR& 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; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImportSemaphoreWin32HandleInfoKHR& safe_VkImportSemaphoreWin32HandleInfoKHR::operator=( + const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src) { + if (©_src == this) return *this; + + 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; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImportSemaphoreWin32HandleInfoKHR::~safe_VkImportSemaphoreWin32HandleInfoKHR() { FreePnextChain(pNext); } + +void safe_VkImportSemaphoreWin32HandleInfoKHR::initialize(const VkImportSemaphoreWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + 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; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImportSemaphoreWin32HandleInfoKHR::initialize(const safe_VkImportSemaphoreWin32HandleInfoKHR* 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; + pNext = SafePnextCopy(copy_src->pNext); +} + +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_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR() + : sType(VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR), pNext(nullptr), pAttributes(nullptr), dwAccess(), name() {} + +safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR( + const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src) { + 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); + } +} + +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; + 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_VkExportSemaphoreWin32HandleInfoKHR::~safe_VkExportSemaphoreWin32HandleInfoKHR() { + if (pAttributes) delete pAttributes; + FreePnextChain(pNext); +} + +void safe_VkExportSemaphoreWin32HandleInfoKHR::initialize(const VkExportSemaphoreWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pAttributes) delete pAttributes; + FreePnextChain(pNext); + sType = in_struct->sType; + 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_VkExportSemaphoreWin32HandleInfoKHR::initialize(const safe_VkExportSemaphoreWin32HandleInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + 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); + } +} + +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); + } + + 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), + pNext(nullptr), + waitSemaphoreValuesCount(), + pWaitSemaphoreValues(nullptr), + signalSemaphoreValuesCount(), + pSignalSemaphoreValues(nullptr) {} + +safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR(const safe_VkD3D12FenceSubmitInfoKHR& copy_src) { + sType = copy_src.sType; + 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_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; + 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_VkD3D12FenceSubmitInfoKHR::~safe_VkD3D12FenceSubmitInfoKHR() { + if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues; + if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues; + FreePnextChain(pNext); +} + +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; + 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_VkD3D12FenceSubmitInfoKHR::initialize(const safe_VkD3D12FenceSubmitInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + 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_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_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR() + : sType(VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR), pNext(nullptr), semaphore(), handleType() {} + +safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR( + const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src) { + sType = copy_src.sType; + semaphore = copy_src.semaphore; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSemaphoreGetWin32HandleInfoKHR& safe_VkSemaphoreGetWin32HandleInfoKHR::operator=( + const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + semaphore = copy_src.semaphore; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSemaphoreGetWin32HandleInfoKHR::~safe_VkSemaphoreGetWin32HandleInfoKHR() { FreePnextChain(pNext); } + +void safe_VkSemaphoreGetWin32HandleInfoKHR::initialize(const VkSemaphoreGetWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + semaphore = in_struct->semaphore; + handleType = in_struct->handleType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSemaphoreGetWin32HandleInfoKHR::initialize(const safe_VkSemaphoreGetWin32HandleInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + semaphore = copy_src->semaphore; + handleType = copy_src->handleType; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_WIN32_KHR + +safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR* 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) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR() + : sType(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR), pNext(nullptr), semaphore(), flags(), handleType(), fd() {} + +safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR(const safe_VkImportSemaphoreFdInfoKHR& copy_src) { + sType = copy_src.sType; + semaphore = copy_src.semaphore; + flags = copy_src.flags; + handleType = copy_src.handleType; + fd = copy_src.fd; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImportSemaphoreFdInfoKHR& safe_VkImportSemaphoreFdInfoKHR::operator=(const safe_VkImportSemaphoreFdInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + semaphore = copy_src.semaphore; + flags = copy_src.flags; + handleType = copy_src.handleType; + fd = copy_src.fd; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImportSemaphoreFdInfoKHR::~safe_VkImportSemaphoreFdInfoKHR() { FreePnextChain(pNext); } + +void safe_VkImportSemaphoreFdInfoKHR::initialize(const VkImportSemaphoreFdInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + 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_VkImportSemaphoreFdInfoKHR::initialize(const safe_VkImportSemaphoreFdInfoKHR* 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; + pNext = SafePnextCopy(copy_src->pNext); +} + +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_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR() + : sType(VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR), pNext(nullptr), semaphore(), handleType() {} + +safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR(const safe_VkSemaphoreGetFdInfoKHR& copy_src) { + sType = copy_src.sType; + semaphore = copy_src.semaphore; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSemaphoreGetFdInfoKHR& safe_VkSemaphoreGetFdInfoKHR::operator=(const safe_VkSemaphoreGetFdInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + semaphore = copy_src.semaphore; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSemaphoreGetFdInfoKHR::~safe_VkSemaphoreGetFdInfoKHR() { FreePnextChain(pNext); } + +void safe_VkSemaphoreGetFdInfoKHR::initialize(const VkSemaphoreGetFdInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + semaphore = in_struct->semaphore; + handleType = in_struct->handleType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSemaphoreGetFdInfoKHR::initialize(const safe_VkSemaphoreGetFdInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + semaphore = copy_src->semaphore; + handleType = copy_src->handleType; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR( + const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), maxPushDescriptors(in_struct->maxPushDescriptors) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR), pNext(nullptr), maxPushDescriptors() {} + +safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR( + const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src) { + sType = copy_src.sType; + maxPushDescriptors = copy_src.maxPushDescriptors; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePushDescriptorPropertiesKHR& safe_VkPhysicalDevicePushDescriptorPropertiesKHR::operator=( + const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxPushDescriptors = copy_src.maxPushDescriptors; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePushDescriptorPropertiesKHR::~safe_VkPhysicalDevicePushDescriptorPropertiesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxPushDescriptors = in_struct->maxPushDescriptors; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxPushDescriptors = copy_src->maxPushDescriptors; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPresentRegionKHR::safe_VkPresentRegionKHR(const VkPresentRegionKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) + : rectangleCount(in_struct->rectangleCount), pRectangles(nullptr) { + if (in_struct->pRectangles) { + pRectangles = new VkRectLayerKHR[in_struct->rectangleCount]; + memcpy((void*)pRectangles, (void*)in_struct->pRectangles, sizeof(VkRectLayerKHR) * in_struct->rectangleCount); + } +} + +safe_VkPresentRegionKHR::safe_VkPresentRegionKHR() : rectangleCount(), pRectangles(nullptr) {} + +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_VkPresentRegionKHR& safe_VkPresentRegionKHR::operator=(const safe_VkPresentRegionKHR& copy_src) { + if (©_src == this) return *this; + + if (pRectangles) delete[] pRectangles; + + 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_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; + + if (in_struct->pRectangles) { + pRectangles = new VkRectLayerKHR[in_struct->rectangleCount]; + memcpy((void*)pRectangles, (void*)in_struct->pRectangles, sizeof(VkRectLayerKHR) * in_struct->rectangleCount); + } +} + +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_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_VkPresentRegionsKHR::safe_VkPresentRegionsKHR() + : sType(VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR), pNext(nullptr), swapchainCount(), pRegions(nullptr) {} + +safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR(const safe_VkPresentRegionsKHR& copy_src) { + sType = copy_src.sType; + 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_VkPresentRegionsKHR& safe_VkPresentRegionsKHR::operator=(const safe_VkPresentRegionsKHR& copy_src) { + if (©_src == this) return *this; + + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + + sType = copy_src.sType; + 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_VkPresentRegionsKHR::~safe_VkPresentRegionsKHR() { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); +} + +void safe_VkPresentRegionsKHR::initialize(const VkPresentRegionsKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + sType = in_struct->sType; + 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_VkPresentRegionsKHR::initialize(const safe_VkPresentRegionsKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + 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_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); + } +} + +safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR() + : sType(VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR), pNext(nullptr), sharedPresentSupportedUsageFlags() {} + +safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR( + const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src) { + sType = copy_src.sType; + sharedPresentSupportedUsageFlags = copy_src.sharedPresentSupportedUsageFlags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSharedPresentSurfaceCapabilitiesKHR& safe_VkSharedPresentSurfaceCapabilitiesKHR::operator=( + const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + sharedPresentSupportedUsageFlags = copy_src.sharedPresentSupportedUsageFlags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSharedPresentSurfaceCapabilitiesKHR::~safe_VkSharedPresentSurfaceCapabilitiesKHR() { FreePnextChain(pNext); } + +void safe_VkSharedPresentSurfaceCapabilitiesKHR::initialize(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + sharedPresentSupportedUsageFlags = in_struct->sharedPresentSupportedUsageFlags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSharedPresentSurfaceCapabilitiesKHR::initialize(const safe_VkSharedPresentSurfaceCapabilitiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + sharedPresentSupportedUsageFlags = copy_src->sharedPresentSupportedUsageFlags; + pNext = SafePnextCopy(copy_src->pNext); +} +#ifdef VK_USE_PLATFORM_WIN32_KHR + +safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR* 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) { + 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_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR(const safe_VkImportFenceWin32HandleInfoKHR& 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; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImportFenceWin32HandleInfoKHR& safe_VkImportFenceWin32HandleInfoKHR::operator=( + const safe_VkImportFenceWin32HandleInfoKHR& 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; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImportFenceWin32HandleInfoKHR::~safe_VkImportFenceWin32HandleInfoKHR() { FreePnextChain(pNext); } + +void safe_VkImportFenceWin32HandleInfoKHR::initialize(const VkImportFenceWin32HandleInfoKHR* 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; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImportFenceWin32HandleInfoKHR::initialize(const safe_VkImportFenceWin32HandleInfoKHR* 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; + 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) { + 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_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR(const safe_VkExportFenceWin32HandleInfoKHR& copy_src) { + 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); + } +} + +safe_VkExportFenceWin32HandleInfoKHR& safe_VkExportFenceWin32HandleInfoKHR::operator=( + const safe_VkExportFenceWin32HandleInfoKHR& 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); + } + + return *this; +} + +safe_VkExportFenceWin32HandleInfoKHR::~safe_VkExportFenceWin32HandleInfoKHR() { + if (pAttributes) delete pAttributes; + FreePnextChain(pNext); +} + +void safe_VkExportFenceWin32HandleInfoKHR::initialize(const VkExportFenceWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pAttributes) delete pAttributes; + FreePnextChain(pNext); + sType = in_struct->sType; + 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_VkExportFenceWin32HandleInfoKHR::initialize(const safe_VkExportFenceWin32HandleInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + 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); + } +} + +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); + } +} + +safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR() + : sType(VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR), pNext(nullptr), fence(), handleType() {} + +safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR(const safe_VkFenceGetWin32HandleInfoKHR& copy_src) { + sType = copy_src.sType; + fence = copy_src.fence; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkFenceGetWin32HandleInfoKHR& safe_VkFenceGetWin32HandleInfoKHR::operator=(const safe_VkFenceGetWin32HandleInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + fence = copy_src.fence; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkFenceGetWin32HandleInfoKHR::~safe_VkFenceGetWin32HandleInfoKHR() { FreePnextChain(pNext); } + +void safe_VkFenceGetWin32HandleInfoKHR::initialize(const VkFenceGetWin32HandleInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + fence = in_struct->fence; + handleType = in_struct->handleType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkFenceGetWin32HandleInfoKHR::initialize(const safe_VkFenceGetWin32HandleInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + fence = copy_src->fence; + handleType = copy_src->handleType; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_WIN32_KHR + +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_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR() + : sType(VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR), pNext(nullptr), fence(), flags(), handleType(), fd() {} + +safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR(const safe_VkImportFenceFdInfoKHR& copy_src) { + sType = copy_src.sType; + fence = copy_src.fence; + flags = copy_src.flags; + handleType = copy_src.handleType; + fd = copy_src.fd; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImportFenceFdInfoKHR& safe_VkImportFenceFdInfoKHR::operator=(const safe_VkImportFenceFdInfoKHR& 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; + fd = copy_src.fd; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImportFenceFdInfoKHR::~safe_VkImportFenceFdInfoKHR() { FreePnextChain(pNext); } + +void safe_VkImportFenceFdInfoKHR::initialize(const VkImportFenceFdInfoKHR* 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; + fd = in_struct->fd; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImportFenceFdInfoKHR::initialize(const safe_VkImportFenceFdInfoKHR* 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; + pNext = SafePnextCopy(copy_src->pNext); +} + +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_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR() + : sType(VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR), pNext(nullptr), fence(), handleType() {} + +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); +} + +safe_VkFenceGetFdInfoKHR& safe_VkFenceGetFdInfoKHR::operator=(const safe_VkFenceGetFdInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + fence = copy_src.fence; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkFenceGetFdInfoKHR::~safe_VkFenceGetFdInfoKHR() { FreePnextChain(pNext); } + +void safe_VkFenceGetFdInfoKHR::initialize(const VkFenceGetFdInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + fence = in_struct->fence; + handleType = in_struct->handleType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkFenceGetFdInfoKHR::initialize(const safe_VkFenceGetFdInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + fence = copy_src->fence; + handleType = copy_src->handleType; + pNext = SafePnextCopy(copy_src->pNext); +} + +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); + } +} + +safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::safe_VkPhysicalDevicePerformanceQueryFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR), + pNext(nullptr), + performanceCounterQueryPools(), + performanceCounterMultipleQueryPools() {} + +safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::safe_VkPhysicalDevicePerformanceQueryFeaturesKHR( + const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src) { + sType = copy_src.sType; + performanceCounterQueryPools = copy_src.performanceCounterQueryPools; + performanceCounterMultipleQueryPools = copy_src.performanceCounterMultipleQueryPools; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::operator=( + const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + performanceCounterQueryPools = copy_src.performanceCounterQueryPools; + performanceCounterMultipleQueryPools = copy_src.performanceCounterMultipleQueryPools; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::~safe_VkPhysicalDevicePerformanceQueryFeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::initialize(const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + performanceCounterQueryPools = in_struct->performanceCounterQueryPools; + performanceCounterMultipleQueryPools = in_struct->performanceCounterMultipleQueryPools; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::initialize(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + performanceCounterQueryPools = copy_src->performanceCounterQueryPools; + performanceCounterMultipleQueryPools = copy_src->performanceCounterMultipleQueryPools; + pNext = SafePnextCopy(copy_src->pNext); +} + +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); + } +} + +safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::safe_VkPhysicalDevicePerformanceQueryPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR), pNext(nullptr), allowCommandBufferQueryCopies() {} + +safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::safe_VkPhysicalDevicePerformanceQueryPropertiesKHR( + const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src) { + sType = copy_src.sType; + allowCommandBufferQueryCopies = copy_src.allowCommandBufferQueryCopies; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::operator=( + const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + allowCommandBufferQueryCopies = copy_src.allowCommandBufferQueryCopies; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::~safe_VkPhysicalDevicePerformanceQueryPropertiesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::initialize(const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + allowCommandBufferQueryCopies = in_struct->allowCommandBufferQueryCopies; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::initialize( + const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + allowCommandBufferQueryCopies = copy_src->allowCommandBufferQueryCopies; + pNext = SafePnextCopy(copy_src->pNext); +} + +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 < 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_VkPerformanceCounterKHR::safe_VkPerformanceCounterKHR(const safe_VkPerformanceCounterKHR& copy_src) { + sType = copy_src.sType; + unit = copy_src.unit; + scope = copy_src.scope; + storage = copy_src.storage; + 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) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + unit = copy_src.unit; + scope = copy_src.scope; + storage = copy_src.storage; + 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); } + +void safe_VkPerformanceCounterKHR::initialize(const VkPerformanceCounterKHR* 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; + 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) { + sType = copy_src->sType; + unit = copy_src->unit; + scope = copy_src->scope; + storage = copy_src->storage; + 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) { + 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_VkPerformanceCounterDescriptionKHR::safe_VkPerformanceCounterDescriptionKHR() + : sType(VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR), pNext(nullptr), flags() {} + +safe_VkPerformanceCounterDescriptionKHR::safe_VkPerformanceCounterDescriptionKHR( + const safe_VkPerformanceCounterDescriptionKHR& copy_src) { + sType = copy_src.sType; + 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_VkPerformanceCounterDescriptionKHR& safe_VkPerformanceCounterDescriptionKHR::operator=( + const safe_VkPerformanceCounterDescriptionKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + 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]; + } + + 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; + 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_VkPerformanceCounterDescriptionKHR::initialize(const safe_VkPerformanceCounterDescriptionKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + 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_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) { + 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_VkQueryPoolPerformanceCreateInfoKHR::safe_VkQueryPoolPerformanceCreateInfoKHR( + const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src) { + 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_VkQueryPoolPerformanceCreateInfoKHR& safe_VkQueryPoolPerformanceCreateInfoKHR::operator=( + const safe_VkQueryPoolPerformanceCreateInfoKHR& 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; + 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); +} + +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_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR( + const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), dynamicRenderingLocalRead(in_struct->dynamicRenderingLocalRead) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR), + pNext(nullptr), + dynamicRenderingLocalRead() {} + +safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR( + const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src) { + sType = copy_src.sType; + dynamicRenderingLocalRead = copy_src.dynamicRenderingLocalRead; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::operator=( + const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + dynamicRenderingLocalRead = copy_src.dynamicRenderingLocalRead; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::~safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::initialize( + const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + dynamicRenderingLocalRead = in_struct->dynamicRenderingLocalRead; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::initialize( + const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + dynamicRenderingLocalRead = copy_src->dynamicRenderingLocalRead; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkRenderingAttachmentLocationInfoKHR::safe_VkRenderingAttachmentLocationInfoKHR( + const VkRenderingAttachmentLocationInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), colorAttachmentCount(in_struct->colorAttachmentCount), pColorAttachmentLocations(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pColorAttachmentLocations) { + pColorAttachmentLocations = new uint32_t[in_struct->colorAttachmentCount]; + memcpy((void*)pColorAttachmentLocations, (void*)in_struct->pColorAttachmentLocations, + sizeof(uint32_t) * in_struct->colorAttachmentCount); + } +} + +safe_VkRenderingAttachmentLocationInfoKHR::safe_VkRenderingAttachmentLocationInfoKHR() + : sType(VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR), + pNext(nullptr), + colorAttachmentCount(), + pColorAttachmentLocations(nullptr) {} + +safe_VkRenderingAttachmentLocationInfoKHR::safe_VkRenderingAttachmentLocationInfoKHR( + const safe_VkRenderingAttachmentLocationInfoKHR& copy_src) { + sType = copy_src.sType; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachmentLocations = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pColorAttachmentLocations) { + pColorAttachmentLocations = new uint32_t[copy_src.colorAttachmentCount]; + memcpy((void*)pColorAttachmentLocations, (void*)copy_src.pColorAttachmentLocations, + sizeof(uint32_t) * copy_src.colorAttachmentCount); + } +} + +safe_VkRenderingAttachmentLocationInfoKHR& safe_VkRenderingAttachmentLocationInfoKHR::operator=( + const safe_VkRenderingAttachmentLocationInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pColorAttachmentLocations) delete[] pColorAttachmentLocations; + FreePnextChain(pNext); + + sType = copy_src.sType; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachmentLocations = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pColorAttachmentLocations) { + pColorAttachmentLocations = new uint32_t[copy_src.colorAttachmentCount]; + memcpy((void*)pColorAttachmentLocations, (void*)copy_src.pColorAttachmentLocations, + sizeof(uint32_t) * copy_src.colorAttachmentCount); + } + + return *this; +} + +safe_VkRenderingAttachmentLocationInfoKHR::~safe_VkRenderingAttachmentLocationInfoKHR() { + if (pColorAttachmentLocations) delete[] pColorAttachmentLocations; + FreePnextChain(pNext); +} + +void safe_VkRenderingAttachmentLocationInfoKHR::initialize(const VkRenderingAttachmentLocationInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pColorAttachmentLocations) delete[] pColorAttachmentLocations; + FreePnextChain(pNext); + sType = in_struct->sType; + colorAttachmentCount = in_struct->colorAttachmentCount; + pColorAttachmentLocations = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pColorAttachmentLocations) { + pColorAttachmentLocations = new uint32_t[in_struct->colorAttachmentCount]; + memcpy((void*)pColorAttachmentLocations, (void*)in_struct->pColorAttachmentLocations, + sizeof(uint32_t) * in_struct->colorAttachmentCount); + } +} + +void safe_VkRenderingAttachmentLocationInfoKHR::initialize(const safe_VkRenderingAttachmentLocationInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + colorAttachmentCount = copy_src->colorAttachmentCount; + pColorAttachmentLocations = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pColorAttachmentLocations) { + pColorAttachmentLocations = new uint32_t[copy_src->colorAttachmentCount]; + memcpy((void*)pColorAttachmentLocations, (void*)copy_src->pColorAttachmentLocations, + sizeof(uint32_t) * copy_src->colorAttachmentCount); + } +} + +safe_VkRenderingInputAttachmentIndexInfoKHR::safe_VkRenderingInputAttachmentIndexInfoKHR( + const VkRenderingInputAttachmentIndexInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + colorAttachmentCount(in_struct->colorAttachmentCount), + pColorAttachmentInputIndices(nullptr), + pDepthInputAttachmentIndex(nullptr), + pStencilInputAttachmentIndex(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pColorAttachmentInputIndices) { + pColorAttachmentInputIndices = new uint32_t[in_struct->colorAttachmentCount]; + memcpy((void*)pColorAttachmentInputIndices, (void*)in_struct->pColorAttachmentInputIndices, + sizeof(uint32_t) * in_struct->colorAttachmentCount); + } + + if (in_struct->pDepthInputAttachmentIndex) { + pDepthInputAttachmentIndex = new uint32_t(*in_struct->pDepthInputAttachmentIndex); + } + + if (in_struct->pStencilInputAttachmentIndex) { + pStencilInputAttachmentIndex = new uint32_t(*in_struct->pStencilInputAttachmentIndex); + } +} + +safe_VkRenderingInputAttachmentIndexInfoKHR::safe_VkRenderingInputAttachmentIndexInfoKHR() + : sType(VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR), + pNext(nullptr), + colorAttachmentCount(), + pColorAttachmentInputIndices(nullptr), + pDepthInputAttachmentIndex(nullptr), + pStencilInputAttachmentIndex(nullptr) {} + +safe_VkRenderingInputAttachmentIndexInfoKHR::safe_VkRenderingInputAttachmentIndexInfoKHR( + const safe_VkRenderingInputAttachmentIndexInfoKHR& copy_src) { + sType = copy_src.sType; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachmentInputIndices = nullptr; + pDepthInputAttachmentIndex = nullptr; + pStencilInputAttachmentIndex = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pColorAttachmentInputIndices) { + pColorAttachmentInputIndices = new uint32_t[copy_src.colorAttachmentCount]; + memcpy((void*)pColorAttachmentInputIndices, (void*)copy_src.pColorAttachmentInputIndices, + sizeof(uint32_t) * copy_src.colorAttachmentCount); + } + + if (copy_src.pDepthInputAttachmentIndex) { + pDepthInputAttachmentIndex = new uint32_t(*copy_src.pDepthInputAttachmentIndex); + } + + if (copy_src.pStencilInputAttachmentIndex) { + pStencilInputAttachmentIndex = new uint32_t(*copy_src.pStencilInputAttachmentIndex); + } +} + +safe_VkRenderingInputAttachmentIndexInfoKHR& safe_VkRenderingInputAttachmentIndexInfoKHR::operator=( + const safe_VkRenderingInputAttachmentIndexInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pColorAttachmentInputIndices) delete[] pColorAttachmentInputIndices; + if (pDepthInputAttachmentIndex) delete pDepthInputAttachmentIndex; + if (pStencilInputAttachmentIndex) delete pStencilInputAttachmentIndex; + FreePnextChain(pNext); + + sType = copy_src.sType; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachmentInputIndices = nullptr; + pDepthInputAttachmentIndex = nullptr; + pStencilInputAttachmentIndex = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pColorAttachmentInputIndices) { + pColorAttachmentInputIndices = new uint32_t[copy_src.colorAttachmentCount]; + memcpy((void*)pColorAttachmentInputIndices, (void*)copy_src.pColorAttachmentInputIndices, + sizeof(uint32_t) * copy_src.colorAttachmentCount); + } + + if (copy_src.pDepthInputAttachmentIndex) { + pDepthInputAttachmentIndex = new uint32_t(*copy_src.pDepthInputAttachmentIndex); + } + + if (copy_src.pStencilInputAttachmentIndex) { + pStencilInputAttachmentIndex = new uint32_t(*copy_src.pStencilInputAttachmentIndex); + } + + return *this; +} + +safe_VkRenderingInputAttachmentIndexInfoKHR::~safe_VkRenderingInputAttachmentIndexInfoKHR() { + if (pColorAttachmentInputIndices) delete[] pColorAttachmentInputIndices; + if (pDepthInputAttachmentIndex) delete pDepthInputAttachmentIndex; + if (pStencilInputAttachmentIndex) delete pStencilInputAttachmentIndex; + FreePnextChain(pNext); +} + +void safe_VkRenderingInputAttachmentIndexInfoKHR::initialize(const VkRenderingInputAttachmentIndexInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pColorAttachmentInputIndices) delete[] pColorAttachmentInputIndices; + if (pDepthInputAttachmentIndex) delete pDepthInputAttachmentIndex; + if (pStencilInputAttachmentIndex) delete pStencilInputAttachmentIndex; + FreePnextChain(pNext); + sType = in_struct->sType; + colorAttachmentCount = in_struct->colorAttachmentCount; + pColorAttachmentInputIndices = nullptr; + pDepthInputAttachmentIndex = nullptr; + pStencilInputAttachmentIndex = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pColorAttachmentInputIndices) { + pColorAttachmentInputIndices = new uint32_t[in_struct->colorAttachmentCount]; + memcpy((void*)pColorAttachmentInputIndices, (void*)in_struct->pColorAttachmentInputIndices, + sizeof(uint32_t) * in_struct->colorAttachmentCount); + } + + if (in_struct->pDepthInputAttachmentIndex) { + pDepthInputAttachmentIndex = new uint32_t(*in_struct->pDepthInputAttachmentIndex); + } + + if (in_struct->pStencilInputAttachmentIndex) { + pStencilInputAttachmentIndex = new uint32_t(*in_struct->pStencilInputAttachmentIndex); + } +} + +void safe_VkRenderingInputAttachmentIndexInfoKHR::initialize(const safe_VkRenderingInputAttachmentIndexInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + colorAttachmentCount = copy_src->colorAttachmentCount; + pColorAttachmentInputIndices = nullptr; + pDepthInputAttachmentIndex = nullptr; + pStencilInputAttachmentIndex = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pColorAttachmentInputIndices) { + pColorAttachmentInputIndices = new uint32_t[copy_src->colorAttachmentCount]; + memcpy((void*)pColorAttachmentInputIndices, (void*)copy_src->pColorAttachmentInputIndices, + sizeof(uint32_t) * copy_src->colorAttachmentCount); + } + + if (copy_src->pDepthInputAttachmentIndex) { + pDepthInputAttachmentIndex = new uint32_t(*copy_src->pDepthInputAttachmentIndex); + } + + if (copy_src->pStencilInputAttachmentIndex) { + pStencilInputAttachmentIndex = new uint32_t(*copy_src->pStencilInputAttachmentIndex); + } +} + +safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR( + const VkPhysicalDeviceShaderQuadControlFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), shaderQuadControl(in_struct->shaderQuadControl) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR), pNext(nullptr), shaderQuadControl() {} + +safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR( + const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& copy_src) { + sType = copy_src.sType; + shaderQuadControl = copy_src.shaderQuadControl; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::operator=( + const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderQuadControl = copy_src.shaderQuadControl; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::~safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::initialize(const VkPhysicalDeviceShaderQuadControlFeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderQuadControl = in_struct->shaderQuadControl; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::initialize( + const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderQuadControl = copy_src->shaderQuadControl; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), supportsProtected(in_struct->supportsProtected) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR() + : sType(VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR), pNext(nullptr), supportsProtected() {} + +safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR( + const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src) { + sType = copy_src.sType; + supportsProtected = copy_src.supportsProtected; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSurfaceProtectedCapabilitiesKHR& safe_VkSurfaceProtectedCapabilitiesKHR::operator=( + const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + supportsProtected = copy_src.supportsProtected; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSurfaceProtectedCapabilitiesKHR::~safe_VkSurfaceProtectedCapabilitiesKHR() { FreePnextChain(pNext); } + +void safe_VkSurfaceProtectedCapabilitiesKHR::initialize(const VkSurfaceProtectedCapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + supportsProtected = in_struct->supportsProtected; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSurfaceProtectedCapabilitiesKHR::initialize(const safe_VkSurfaceProtectedCapabilitiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + supportsProtected = copy_src->supportsProtected; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePresentWaitFeaturesKHR::safe_VkPhysicalDevicePresentWaitFeaturesKHR( + const VkPhysicalDevicePresentWaitFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), presentWait(in_struct->presentWait) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePresentWaitFeaturesKHR::safe_VkPhysicalDevicePresentWaitFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR), pNext(nullptr), presentWait() {} + +safe_VkPhysicalDevicePresentWaitFeaturesKHR::safe_VkPhysicalDevicePresentWaitFeaturesKHR( + const safe_VkPhysicalDevicePresentWaitFeaturesKHR& copy_src) { + sType = copy_src.sType; + presentWait = copy_src.presentWait; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePresentWaitFeaturesKHR& safe_VkPhysicalDevicePresentWaitFeaturesKHR::operator=( + const safe_VkPhysicalDevicePresentWaitFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + presentWait = copy_src.presentWait; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePresentWaitFeaturesKHR::~safe_VkPhysicalDevicePresentWaitFeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePresentWaitFeaturesKHR::initialize(const VkPhysicalDevicePresentWaitFeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + presentWait = in_struct->presentWait; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePresentWaitFeaturesKHR::initialize(const safe_VkPhysicalDevicePresentWaitFeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentWait = copy_src->presentWait; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR( + const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), pipelineExecutableInfo(in_struct->pipelineExecutableInfo) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR), + pNext(nullptr), + pipelineExecutableInfo() {} + +safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR( + 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; + 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_VkPipelineExecutableInternalRepresentationKHR::initialize( + const safe_VkPipelineExecutableInternalRepresentationKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + 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_VkMemoryMapInfoKHR::safe_VkMemoryMapInfoKHR(const VkMemoryMapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + memory(in_struct->memory), + offset(in_struct->offset), + size(in_struct->size) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMemoryMapInfoKHR::safe_VkMemoryMapInfoKHR() + : sType(VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR), pNext(nullptr), flags(), memory(), offset(), size() {} + +safe_VkMemoryMapInfoKHR::safe_VkMemoryMapInfoKHR(const safe_VkMemoryMapInfoKHR& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + memory = copy_src.memory; + offset = copy_src.offset; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryMapInfoKHR& safe_VkMemoryMapInfoKHR::operator=(const safe_VkMemoryMapInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + memory = copy_src.memory; + offset = copy_src.offset; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryMapInfoKHR::~safe_VkMemoryMapInfoKHR() { FreePnextChain(pNext); } + +void safe_VkMemoryMapInfoKHR::initialize(const VkMemoryMapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + memory = in_struct->memory; + offset = in_struct->offset; + size = in_struct->size; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryMapInfoKHR::initialize(const safe_VkMemoryMapInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + memory = copy_src->memory; + offset = copy_src->offset; + size = copy_src->size; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMemoryUnmapInfoKHR::safe_VkMemoryUnmapInfoKHR(const VkMemoryUnmapInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), memory(in_struct->memory) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMemoryUnmapInfoKHR::safe_VkMemoryUnmapInfoKHR() + : sType(VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR), pNext(nullptr), flags(), memory() {} + +safe_VkMemoryUnmapInfoKHR::safe_VkMemoryUnmapInfoKHR(const safe_VkMemoryUnmapInfoKHR& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + memory = copy_src.memory; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryUnmapInfoKHR& safe_VkMemoryUnmapInfoKHR::operator=(const safe_VkMemoryUnmapInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + memory = copy_src.memory; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryUnmapInfoKHR::~safe_VkMemoryUnmapInfoKHR() { FreePnextChain(pNext); } + +void safe_VkMemoryUnmapInfoKHR::initialize(const VkMemoryUnmapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + memory = in_struct->memory; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryUnmapInfoKHR::initialize(const safe_VkMemoryUnmapInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + memory = copy_src->memory; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : 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_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR), pNext(nullptr), libraryCount(), pLibraries(nullptr) {} + +safe_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR(const safe_VkPipelineLibraryCreateInfoKHR& copy_src) { + sType = copy_src.sType; + 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_VkPipelineLibraryCreateInfoKHR& safe_VkPipelineLibraryCreateInfoKHR::operator=( + const safe_VkPipelineLibraryCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pLibraries) delete[] pLibraries; + FreePnextChain(pNext); + + sType = copy_src.sType; + 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_VkPipelineLibraryCreateInfoKHR::~safe_VkPipelineLibraryCreateInfoKHR() { + if (pLibraries) delete[] pLibraries; + FreePnextChain(pNext); +} + +void safe_VkPipelineLibraryCreateInfoKHR::initialize(const VkPipelineLibraryCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pLibraries) delete[] pLibraries; + 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]; + } + } +} + +void safe_VkPipelineLibraryCreateInfoKHR::initialize(const safe_VkPipelineLibraryCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + 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_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_VkPresentIdKHR::safe_VkPresentIdKHR() + : sType(VK_STRUCTURE_TYPE_PRESENT_ID_KHR), pNext(nullptr), swapchainCount(), pPresentIds(nullptr) {} + +safe_VkPresentIdKHR::safe_VkPresentIdKHR(const safe_VkPresentIdKHR& copy_src) { + sType = copy_src.sType; + swapchainCount = copy_src.swapchainCount; + pPresentIds = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPresentIds) { + pPresentIds = new uint64_t[copy_src.swapchainCount]; + memcpy((void*)pPresentIds, (void*)copy_src.pPresentIds, sizeof(uint64_t) * copy_src.swapchainCount); + } +} + +safe_VkPresentIdKHR& safe_VkPresentIdKHR::operator=(const safe_VkPresentIdKHR& copy_src) { + if (©_src == this) return *this; + + if (pPresentIds) delete[] pPresentIds; + FreePnextChain(pNext); + + sType = copy_src.sType; + swapchainCount = copy_src.swapchainCount; + pPresentIds = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPresentIds) { + pPresentIds = new uint64_t[copy_src.swapchainCount]; + memcpy((void*)pPresentIds, (void*)copy_src.pPresentIds, sizeof(uint64_t) * copy_src.swapchainCount); + } + + return *this; +} + +safe_VkPresentIdKHR::~safe_VkPresentIdKHR() { + if (pPresentIds) delete[] pPresentIds; + FreePnextChain(pNext); +} + +void safe_VkPresentIdKHR::initialize(const VkPresentIdKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pPresentIds) delete[] pPresentIds; + FreePnextChain(pNext); + sType = in_struct->sType; + swapchainCount = in_struct->swapchainCount; + pPresentIds = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pPresentIds) { + pPresentIds = new uint64_t[in_struct->swapchainCount]; + memcpy((void*)pPresentIds, (void*)in_struct->pPresentIds, sizeof(uint64_t) * in_struct->swapchainCount); + } +} + +void safe_VkPresentIdKHR::initialize(const safe_VkPresentIdKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + swapchainCount = copy_src->swapchainCount; + pPresentIds = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pPresentIds) { + pPresentIds = new uint64_t[copy_src->swapchainCount]; + memcpy((void*)pPresentIds, (void*)copy_src->pPresentIds, sizeof(uint64_t) * copy_src->swapchainCount); + } +} + +safe_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_VkPhysicalDevicePresentIdFeaturesKHR::safe_VkPhysicalDevicePresentIdFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR), pNext(nullptr), presentId() {} + +safe_VkPhysicalDevicePresentIdFeaturesKHR::safe_VkPhysicalDevicePresentIdFeaturesKHR( + const safe_VkPhysicalDevicePresentIdFeaturesKHR& copy_src) { + sType = copy_src.sType; + presentId = copy_src.presentId; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePresentIdFeaturesKHR& safe_VkPhysicalDevicePresentIdFeaturesKHR::operator=( + const safe_VkPhysicalDevicePresentIdFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + presentId = copy_src.presentId; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePresentIdFeaturesKHR::~safe_VkPhysicalDevicePresentIdFeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePresentIdFeaturesKHR::initialize(const VkPhysicalDevicePresentIdFeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + presentId = in_struct->presentId; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePresentIdFeaturesKHR::initialize(const safe_VkPhysicalDevicePresentIdFeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentId = copy_src->presentId; + pNext = SafePnextCopy(copy_src->pNext); +} + +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); + } + 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_VkVideoEncodeInfoKHR::safe_VkVideoEncodeInfoKHR(const safe_VkVideoEncodeInfoKHR& 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; + 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) { + 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; + 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); +} + +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; + 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); + 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]); + } + } +} + +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_VkVideoEncodeCapabilitiesKHR::safe_VkVideoEncodeCapabilitiesKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR), + pNext(nullptr), + flags(), + rateControlModes(), + maxRateControlLayers(), + maxBitrate(), + maxQualityLevels(), + encodeInputPictureGranularity(), + supportedEncodeFeedbackFlags() {} + +safe_VkVideoEncodeCapabilitiesKHR::safe_VkVideoEncodeCapabilitiesKHR(const safe_VkVideoEncodeCapabilitiesKHR& 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; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoEncodeCapabilitiesKHR& safe_VkVideoEncodeCapabilitiesKHR::operator=(const safe_VkVideoEncodeCapabilitiesKHR& 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; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoEncodeCapabilitiesKHR::~safe_VkVideoEncodeCapabilitiesKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeCapabilitiesKHR::initialize(const VkVideoEncodeCapabilitiesKHR* 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; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoEncodeCapabilitiesKHR::initialize(const safe_VkVideoEncodeCapabilitiesKHR* 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; + 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) { + 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_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR( + const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& copy_src) { + sType = copy_src.sType; + encodeFeedbackFlags = copy_src.encodeFeedbackFlags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::operator=( + const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + encodeFeedbackFlags = copy_src.encodeFeedbackFlags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::~safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR() { FreePnextChain(pNext); } + +void safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::initialize(const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + encodeFeedbackFlags = in_struct->encodeFeedbackFlags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::initialize(const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + encodeFeedbackFlags = copy_src->encodeFeedbackFlags; + pNext = SafePnextCopy(copy_src->pNext); +} + +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); + } +} + +safe_VkVideoEncodeUsageInfoKHR::safe_VkVideoEncodeUsageInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR), pNext(nullptr), videoUsageHints(), videoContentHints(), tuningMode() {} + +safe_VkVideoEncodeUsageInfoKHR::safe_VkVideoEncodeUsageInfoKHR(const safe_VkVideoEncodeUsageInfoKHR& copy_src) { + sType = copy_src.sType; + videoUsageHints = copy_src.videoUsageHints; + videoContentHints = copy_src.videoContentHints; + tuningMode = copy_src.tuningMode; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoEncodeUsageInfoKHR& safe_VkVideoEncodeUsageInfoKHR::operator=(const safe_VkVideoEncodeUsageInfoKHR& 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; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoEncodeUsageInfoKHR::~safe_VkVideoEncodeUsageInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeUsageInfoKHR::initialize(const VkVideoEncodeUsageInfoKHR* 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; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoEncodeUsageInfoKHR::initialize(const safe_VkVideoEncodeUsageInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + videoUsageHints = copy_src->videoUsageHints; + videoContentHints = copy_src->videoContentHints; + tuningMode = copy_src->tuningMode; + 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) { + 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), + pNext(nullptr), + averageBitrate(), + maxBitrate(), + frameRateNumerator(), + frameRateDenominator() {} + +safe_VkVideoEncodeRateControlLayerInfoKHR::safe_VkVideoEncodeRateControlLayerInfoKHR( + const safe_VkVideoEncodeRateControlLayerInfoKHR& copy_src) { + sType = copy_src.sType; + averageBitrate = copy_src.averageBitrate; + maxBitrate = copy_src.maxBitrate; + frameRateNumerator = copy_src.frameRateNumerator; + frameRateDenominator = copy_src.frameRateDenominator; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoEncodeRateControlLayerInfoKHR& safe_VkVideoEncodeRateControlLayerInfoKHR::operator=( + const safe_VkVideoEncodeRateControlLayerInfoKHR& 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; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoEncodeRateControlLayerInfoKHR::~safe_VkVideoEncodeRateControlLayerInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeRateControlLayerInfoKHR::initialize(const VkVideoEncodeRateControlLayerInfoKHR* 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; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoEncodeRateControlLayerInfoKHR::initialize(const safe_VkVideoEncodeRateControlLayerInfoKHR* 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; + pNext = SafePnextCopy(copy_src->pNext); +} + +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_VkVideoEncodeRateControlInfoKHR::safe_VkVideoEncodeRateControlInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR), + pNext(nullptr), + flags(), + rateControlMode(), + layerCount(), + pLayers(nullptr), + virtualBufferSizeInMs(), + initialVirtualBufferSizeInMs() {} + +safe_VkVideoEncodeRateControlInfoKHR::safe_VkVideoEncodeRateControlInfoKHR(const safe_VkVideoEncodeRateControlInfoKHR& 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; + 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) { + 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; + 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; + FreePnextChain(pNext); +} + +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; + 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_VkVideoEncodeRateControlInfoKHR::initialize(const safe_VkVideoEncodeRateControlInfoKHR* 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; + 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) { + 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), + pNext(nullptr), + pVideoProfile(nullptr), + qualityLevel() {} + +safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR( + const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& copy_src) { + sType = copy_src.sType; + pVideoProfile = nullptr; + qualityLevel = copy_src.qualityLevel; + 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) { + if (©_src == this) return *this; + + if (pVideoProfile) delete pVideoProfile; + FreePnextChain(pNext); + + sType = copy_src.sType; + pVideoProfile = nullptr; + qualityLevel = copy_src.qualityLevel; + 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; + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::initialize( + const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pVideoProfile) delete pVideoProfile; + FreePnextChain(pNext); + sType = in_struct->sType; + 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_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::initialize( + const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pVideoProfile = nullptr; + qualityLevel = copy_src->qualityLevel; + 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) { + 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_VkVideoEncodeQualityLevelPropertiesKHR::safe_VkVideoEncodeQualityLevelPropertiesKHR( + const safe_VkVideoEncodeQualityLevelPropertiesKHR& copy_src) { + sType = copy_src.sType; + preferredRateControlMode = copy_src.preferredRateControlMode; + preferredRateControlLayerCount = copy_src.preferredRateControlLayerCount; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoEncodeQualityLevelPropertiesKHR& safe_VkVideoEncodeQualityLevelPropertiesKHR::operator=( + const safe_VkVideoEncodeQualityLevelPropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + preferredRateControlMode = copy_src.preferredRateControlMode; + preferredRateControlLayerCount = copy_src.preferredRateControlLayerCount; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoEncodeQualityLevelPropertiesKHR::~safe_VkVideoEncodeQualityLevelPropertiesKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeQualityLevelPropertiesKHR::initialize(const VkVideoEncodeQualityLevelPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + preferredRateControlMode = in_struct->preferredRateControlMode; + preferredRateControlLayerCount = in_struct->preferredRateControlLayerCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoEncodeQualityLevelPropertiesKHR::initialize(const safe_VkVideoEncodeQualityLevelPropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + preferredRateControlMode = copy_src->preferredRateControlMode; + preferredRateControlLayerCount = copy_src->preferredRateControlLayerCount; + 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) { + 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_VkVideoEncodeQualityLevelInfoKHR::safe_VkVideoEncodeQualityLevelInfoKHR( + const safe_VkVideoEncodeQualityLevelInfoKHR& copy_src) { + sType = copy_src.sType; + qualityLevel = copy_src.qualityLevel; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoEncodeQualityLevelInfoKHR& safe_VkVideoEncodeQualityLevelInfoKHR::operator=( + const safe_VkVideoEncodeQualityLevelInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + qualityLevel = copy_src.qualityLevel; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoEncodeQualityLevelInfoKHR::~safe_VkVideoEncodeQualityLevelInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeQualityLevelInfoKHR::initialize(const VkVideoEncodeQualityLevelInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + qualityLevel = in_struct->qualityLevel; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoEncodeQualityLevelInfoKHR::initialize(const safe_VkVideoEncodeQualityLevelInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + qualityLevel = copy_src->qualityLevel; + 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) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoEncodeSessionParametersGetInfoKHR::safe_VkVideoEncodeSessionParametersGetInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR), pNext(nullptr), videoSessionParameters() {} + +safe_VkVideoEncodeSessionParametersGetInfoKHR::safe_VkVideoEncodeSessionParametersGetInfoKHR( + const safe_VkVideoEncodeSessionParametersGetInfoKHR& copy_src) { + sType = copy_src.sType; + videoSessionParameters = copy_src.videoSessionParameters; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoEncodeSessionParametersGetInfoKHR& safe_VkVideoEncodeSessionParametersGetInfoKHR::operator=( + const safe_VkVideoEncodeSessionParametersGetInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + videoSessionParameters = copy_src.videoSessionParameters; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoEncodeSessionParametersGetInfoKHR::~safe_VkVideoEncodeSessionParametersGetInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeSessionParametersGetInfoKHR::initialize(const VkVideoEncodeSessionParametersGetInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + videoSessionParameters = in_struct->videoSessionParameters; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +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_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_VkVideoEncodeSessionParametersFeedbackInfoKHR::safe_VkVideoEncodeSessionParametersFeedbackInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR), pNext(nullptr), hasOverrides() {} + +safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::safe_VkVideoEncodeSessionParametersFeedbackInfoKHR( + const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& copy_src) { + sType = copy_src.sType; + hasOverrides = copy_src.hasOverrides; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::operator=( + const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + hasOverrides = copy_src.hasOverrides; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::~safe_VkVideoEncodeSessionParametersFeedbackInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::initialize(const VkVideoEncodeSessionParametersFeedbackInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + hasOverrides = in_struct->hasOverrides; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::initialize( + const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + hasOverrides = copy_src->hasOverrides; + pNext = SafePnextCopy(copy_src->pNext); +} + +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_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR), + pNext(nullptr), + fragmentShaderBarycentric() {} + +safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR( + const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& copy_src) { + sType = copy_src.sType; + fragmentShaderBarycentric = copy_src.fragmentShaderBarycentric; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::operator=( + const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + fragmentShaderBarycentric = copy_src.fragmentShaderBarycentric; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::~safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::initialize( + const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + fragmentShaderBarycentric = in_struct->fragmentShaderBarycentric; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::initialize( + const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + fragmentShaderBarycentric = copy_src->fragmentShaderBarycentric; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR( + const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + triStripVertexOrderIndependentOfProvokingVertex(in_struct->triStripVertexOrderIndependentOfProvokingVertex) { + 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_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR( + const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& copy_src) { + sType = copy_src.sType; + triStripVertexOrderIndependentOfProvokingVertex = copy_src.triStripVertexOrderIndependentOfProvokingVertex; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::operator=( + const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + triStripVertexOrderIndependentOfProvokingVertex = copy_src.triStripVertexOrderIndependentOfProvokingVertex; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::~safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::initialize( + const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + triStripVertexOrderIndependentOfProvokingVertex = in_struct->triStripVertexOrderIndependentOfProvokingVertex; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::initialize( + const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + triStripVertexOrderIndependentOfProvokingVertex = copy_src->triStripVertexOrderIndependentOfProvokingVertex; + 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) { + 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) { + sType = copy_src.sType; + shaderSubgroupUniformControlFlow = copy_src.shaderSubgroupUniformControlFlow; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& +safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::operator=( + const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderSubgroupUniformControlFlow = copy_src.shaderSubgroupUniformControlFlow; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR:: + ~safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::initialize( + const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderSubgroupUniformControlFlow = in_struct->shaderSubgroupUniformControlFlow; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::initialize( + const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderSubgroupUniformControlFlow = copy_src->shaderSubgroupUniformControlFlow; + 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) { + 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_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR( + const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& copy_src) { + sType = copy_src.sType; + workgroupMemoryExplicitLayout = copy_src.workgroupMemoryExplicitLayout; + workgroupMemoryExplicitLayoutScalarBlockLayout = copy_src.workgroupMemoryExplicitLayoutScalarBlockLayout; + workgroupMemoryExplicitLayout8BitAccess = copy_src.workgroupMemoryExplicitLayout8BitAccess; + workgroupMemoryExplicitLayout16BitAccess = copy_src.workgroupMemoryExplicitLayout16BitAccess; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& +safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::operator=( + const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& 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; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::~safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::initialize( + const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* 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; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::initialize( + const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* 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; + pNext = SafePnextCopy(copy_src->pNext); +} + +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); + } +} + +safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR), + pNext(nullptr), + rayTracingMaintenance1(), + rayTracingPipelineTraceRaysIndirect2() {} + +safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR( + const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& copy_src) { + sType = copy_src.sType; + rayTracingMaintenance1 = copy_src.rayTracingMaintenance1; + rayTracingPipelineTraceRaysIndirect2 = copy_src.rayTracingPipelineTraceRaysIndirect2; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::operator=( + const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + rayTracingMaintenance1 = copy_src.rayTracingMaintenance1; + rayTracingPipelineTraceRaysIndirect2 = copy_src.rayTracingPipelineTraceRaysIndirect2; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::~safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::initialize( + const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + rayTracingMaintenance1 = in_struct->rayTracingMaintenance1; + rayTracingPipelineTraceRaysIndirect2 = in_struct->rayTracingPipelineTraceRaysIndirect2; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::initialize( + const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + rayTracingMaintenance1 = copy_src->rayTracingMaintenance1; + rayTracingPipelineTraceRaysIndirect2 = copy_src->rayTracingPipelineTraceRaysIndirect2; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR( + const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shaderSubgroupRotate(in_struct->shaderSubgroupRotate), + shaderSubgroupRotateClustered(in_struct->shaderSubgroupRotateClustered) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR), + pNext(nullptr), + shaderSubgroupRotate(), + shaderSubgroupRotateClustered() {} + +safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR( + const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src) { + sType = copy_src.sType; + shaderSubgroupRotate = copy_src.shaderSubgroupRotate; + shaderSubgroupRotateClustered = copy_src.shaderSubgroupRotateClustered; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::operator=( + const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderSubgroupRotate = copy_src.shaderSubgroupRotate; + shaderSubgroupRotateClustered = copy_src.shaderSubgroupRotateClustered; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::~safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::initialize( + const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderSubgroupRotate = in_struct->shaderSubgroupRotate; + shaderSubgroupRotateClustered = in_struct->shaderSubgroupRotateClustered; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::initialize( + const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderSubgroupRotate = copy_src->shaderSubgroupRotate; + shaderSubgroupRotateClustered = copy_src->shaderSubgroupRotateClustered; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( + const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), shaderMaximalReconvergence(in_struct->shaderMaximalReconvergence) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR), + pNext(nullptr), + shaderMaximalReconvergence() {} + +safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( + const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& copy_src) { + sType = copy_src.sType; + shaderMaximalReconvergence = copy_src.shaderMaximalReconvergence; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::operator=( + const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderMaximalReconvergence = copy_src.shaderMaximalReconvergence; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::~safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::initialize( + const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderMaximalReconvergence = in_struct->shaderMaximalReconvergence; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::initialize( + const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderMaximalReconvergence = copy_src->shaderMaximalReconvergence; + 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) { + 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_VkPhysicalDeviceMaintenance5FeaturesKHR::safe_VkPhysicalDeviceMaintenance5FeaturesKHR( + const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src) { + sType = copy_src.sType; + maintenance5 = copy_src.maintenance5; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMaintenance5FeaturesKHR& safe_VkPhysicalDeviceMaintenance5FeaturesKHR::operator=( + const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maintenance5 = copy_src.maintenance5; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMaintenance5FeaturesKHR::~safe_VkPhysicalDeviceMaintenance5FeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMaintenance5FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maintenance5 = in_struct->maintenance5; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMaintenance5FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance5FeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maintenance5 = copy_src->maintenance5; + pNext = SafePnextCopy(copy_src->pNext); +} + +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_VkPhysicalDeviceMaintenance5PropertiesKHR::safe_VkPhysicalDeviceMaintenance5PropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR), + pNext(nullptr), + earlyFragmentMultisampleCoverageAfterSampleCounting(), + earlyFragmentSampleMaskTestBeforeSampleCounting(), + depthStencilSwizzleOneSupport(), + polygonModePointSize(), + nonStrictSinglePixelWideLinesUseParallelogram(), + nonStrictWideLinesUseParallelogram() {} + +safe_VkPhysicalDeviceMaintenance5PropertiesKHR::safe_VkPhysicalDeviceMaintenance5PropertiesKHR( + const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src) { + sType = copy_src.sType; + earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src.earlyFragmentMultisampleCoverageAfterSampleCounting; + earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src.earlyFragmentSampleMaskTestBeforeSampleCounting; + depthStencilSwizzleOneSupport = copy_src.depthStencilSwizzleOneSupport; + polygonModePointSize = copy_src.polygonModePointSize; + nonStrictSinglePixelWideLinesUseParallelogram = copy_src.nonStrictSinglePixelWideLinesUseParallelogram; + nonStrictWideLinesUseParallelogram = copy_src.nonStrictWideLinesUseParallelogram; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMaintenance5PropertiesKHR& safe_VkPhysicalDeviceMaintenance5PropertiesKHR::operator=( + const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src.earlyFragmentMultisampleCoverageAfterSampleCounting; + earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src.earlyFragmentSampleMaskTestBeforeSampleCounting; + depthStencilSwizzleOneSupport = copy_src.depthStencilSwizzleOneSupport; + polygonModePointSize = copy_src.polygonModePointSize; + nonStrictSinglePixelWideLinesUseParallelogram = copy_src.nonStrictSinglePixelWideLinesUseParallelogram; + nonStrictWideLinesUseParallelogram = copy_src.nonStrictWideLinesUseParallelogram; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMaintenance5PropertiesKHR::~safe_VkPhysicalDeviceMaintenance5PropertiesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMaintenance5PropertiesKHR::initialize(const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + earlyFragmentMultisampleCoverageAfterSampleCounting = in_struct->earlyFragmentMultisampleCoverageAfterSampleCounting; + earlyFragmentSampleMaskTestBeforeSampleCounting = in_struct->earlyFragmentSampleMaskTestBeforeSampleCounting; + depthStencilSwizzleOneSupport = in_struct->depthStencilSwizzleOneSupport; + polygonModePointSize = in_struct->polygonModePointSize; + nonStrictSinglePixelWideLinesUseParallelogram = in_struct->nonStrictSinglePixelWideLinesUseParallelogram; + nonStrictWideLinesUseParallelogram = in_struct->nonStrictWideLinesUseParallelogram; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMaintenance5PropertiesKHR::initialize(const safe_VkPhysicalDeviceMaintenance5PropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src->earlyFragmentMultisampleCoverageAfterSampleCounting; + earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src->earlyFragmentSampleMaskTestBeforeSampleCounting; + depthStencilSwizzleOneSupport = copy_src->depthStencilSwizzleOneSupport; + polygonModePointSize = copy_src->polygonModePointSize; + nonStrictSinglePixelWideLinesUseParallelogram = copy_src->nonStrictSinglePixelWideLinesUseParallelogram; + nonStrictWideLinesUseParallelogram = copy_src->nonStrictWideLinesUseParallelogram; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_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_VkRenderingAreaInfoKHR::safe_VkRenderingAreaInfoKHR() + : sType(VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR), + pNext(nullptr), + viewMask(), + colorAttachmentCount(), + pColorAttachmentFormats(nullptr), + depthAttachmentFormat(), + stencilAttachmentFormat() {} + +safe_VkRenderingAreaInfoKHR::safe_VkRenderingAreaInfoKHR(const safe_VkRenderingAreaInfoKHR& copy_src) { + sType = copy_src.sType; + viewMask = copy_src.viewMask; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachmentFormats = nullptr; + depthAttachmentFormat = copy_src.depthAttachmentFormat; + stencilAttachmentFormat = copy_src.stencilAttachmentFormat; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pColorAttachmentFormats) { + pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount]; + memcpy((void*)pColorAttachmentFormats, (void*)copy_src.pColorAttachmentFormats, + sizeof(VkFormat) * copy_src.colorAttachmentCount); + } +} + +safe_VkRenderingAreaInfoKHR& safe_VkRenderingAreaInfoKHR::operator=(const safe_VkRenderingAreaInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pColorAttachmentFormats) delete[] pColorAttachmentFormats; + FreePnextChain(pNext); + + sType = copy_src.sType; + viewMask = copy_src.viewMask; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachmentFormats = nullptr; + depthAttachmentFormat = copy_src.depthAttachmentFormat; + stencilAttachmentFormat = copy_src.stencilAttachmentFormat; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pColorAttachmentFormats) { + pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount]; + memcpy((void*)pColorAttachmentFormats, (void*)copy_src.pColorAttachmentFormats, + sizeof(VkFormat) * copy_src.colorAttachmentCount); + } + + return *this; +} + +safe_VkRenderingAreaInfoKHR::~safe_VkRenderingAreaInfoKHR() { + if (pColorAttachmentFormats) delete[] pColorAttachmentFormats; + FreePnextChain(pNext); +} + +void safe_VkRenderingAreaInfoKHR::initialize(const VkRenderingAreaInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pColorAttachmentFormats) delete[] pColorAttachmentFormats; + FreePnextChain(pNext); + sType = in_struct->sType; + viewMask = in_struct->viewMask; + colorAttachmentCount = in_struct->colorAttachmentCount; + pColorAttachmentFormats = nullptr; + depthAttachmentFormat = in_struct->depthAttachmentFormat; + stencilAttachmentFormat = in_struct->stencilAttachmentFormat; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pColorAttachmentFormats) { + pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount]; + memcpy((void*)pColorAttachmentFormats, (void*)in_struct->pColorAttachmentFormats, + sizeof(VkFormat) * in_struct->colorAttachmentCount); + } +} + +void safe_VkRenderingAreaInfoKHR::initialize(const safe_VkRenderingAreaInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + viewMask = copy_src->viewMask; + colorAttachmentCount = copy_src->colorAttachmentCount; + pColorAttachmentFormats = nullptr; + depthAttachmentFormat = copy_src->depthAttachmentFormat; + stencilAttachmentFormat = copy_src->stencilAttachmentFormat; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pColorAttachmentFormats) { + pColorAttachmentFormats = new VkFormat[copy_src->colorAttachmentCount]; + memcpy((void*)pColorAttachmentFormats, (void*)copy_src->pColorAttachmentFormats, + sizeof(VkFormat) * copy_src->colorAttachmentCount); + } +} + +safe_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_VkImageSubresource2KHR::safe_VkImageSubresource2KHR() + : sType(VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR), pNext(nullptr), imageSubresource() {} + +safe_VkImageSubresource2KHR::safe_VkImageSubresource2KHR(const safe_VkImageSubresource2KHR& copy_src) { + sType = copy_src.sType; + imageSubresource = copy_src.imageSubresource; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageSubresource2KHR& safe_VkImageSubresource2KHR::operator=(const safe_VkImageSubresource2KHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + imageSubresource = copy_src.imageSubresource; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageSubresource2KHR::~safe_VkImageSubresource2KHR() { FreePnextChain(pNext); } + +void safe_VkImageSubresource2KHR::initialize(const VkImageSubresource2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + imageSubresource = in_struct->imageSubresource; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageSubresource2KHR::initialize(const safe_VkImageSubresource2KHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + imageSubresource = copy_src->imageSubresource; + 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) { + 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_VkDeviceImageSubresourceInfoKHR::safe_VkDeviceImageSubresourceInfoKHR(const safe_VkDeviceImageSubresourceInfoKHR& copy_src) { + sType = copy_src.sType; + pCreateInfo = nullptr; + pSubresource = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src.pCreateInfo); + if (copy_src.pSubresource) pSubresource = new safe_VkImageSubresource2KHR(*copy_src.pSubresource); +} + +safe_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; + 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_VkDeviceImageSubresourceInfoKHR::~safe_VkDeviceImageSubresourceInfoKHR() { + if (pCreateInfo) delete pCreateInfo; + if (pSubresource) delete pSubresource; + FreePnextChain(pNext); +} + +void safe_VkDeviceImageSubresourceInfoKHR::initialize(const VkDeviceImageSubresourceInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pCreateInfo) delete pCreateInfo; + if (pSubresource) delete pSubresource; + FreePnextChain(pNext); + sType = in_struct->sType; + pCreateInfo = nullptr; + pSubresource = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (in_struct->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(in_struct->pCreateInfo); + if (in_struct->pSubresource) pSubresource = new safe_VkImageSubresource2KHR(in_struct->pSubresource); +} + +void safe_VkDeviceImageSubresourceInfoKHR::initialize(const safe_VkDeviceImageSubresourceInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pCreateInfo = nullptr; + pSubresource = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (copy_src->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src->pCreateInfo); + if (copy_src->pSubresource) pSubresource = new safe_VkImageSubresource2KHR(*copy_src->pSubresource); +} + +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_VkSubresourceLayout2KHR::safe_VkSubresourceLayout2KHR() + : sType(VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR), pNext(nullptr), subresourceLayout() {} + +safe_VkSubresourceLayout2KHR::safe_VkSubresourceLayout2KHR(const safe_VkSubresourceLayout2KHR& copy_src) { + sType = copy_src.sType; + subresourceLayout = copy_src.subresourceLayout; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSubresourceLayout2KHR& safe_VkSubresourceLayout2KHR::operator=(const safe_VkSubresourceLayout2KHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + subresourceLayout = copy_src.subresourceLayout; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSubresourceLayout2KHR::~safe_VkSubresourceLayout2KHR() { FreePnextChain(pNext); } + +void safe_VkSubresourceLayout2KHR::initialize(const VkSubresourceLayout2KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + subresourceLayout = in_struct->subresourceLayout; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSubresourceLayout2KHR::initialize(const safe_VkSubresourceLayout2KHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + subresourceLayout = copy_src->subresourceLayout; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineCreateFlags2CreateInfoKHR::safe_VkPipelineCreateFlags2CreateInfoKHR( + const VkPipelineCreateFlags2CreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_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; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineCreateFlags2CreateInfoKHR& safe_VkPipelineCreateFlags2CreateInfoKHR::operator=( + const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineCreateFlags2CreateInfoKHR::~safe_VkPipelineCreateFlags2CreateInfoKHR() { FreePnextChain(pNext); } + +void safe_VkPipelineCreateFlags2CreateInfoKHR::initialize(const VkPipelineCreateFlags2CreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineCreateFlags2CreateInfoKHR::initialize(const safe_VkPipelineCreateFlags2CreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pNext = SafePnextCopy(copy_src->pNext); +} + +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_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR), pNext(nullptr), usage() {} + +safe_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR( + const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src) { + sType = copy_src.sType; + usage = copy_src.usage; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBufferUsageFlags2CreateInfoKHR& safe_VkBufferUsageFlags2CreateInfoKHR::operator=( + const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + usage = copy_src.usage; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBufferUsageFlags2CreateInfoKHR::~safe_VkBufferUsageFlags2CreateInfoKHR() { FreePnextChain(pNext); } + +void safe_VkBufferUsageFlags2CreateInfoKHR::initialize(const VkBufferUsageFlags2CreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + usage = in_struct->usage; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBufferUsageFlags2CreateInfoKHR::initialize(const safe_VkBufferUsageFlags2CreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + usage = copy_src->usage; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR( + const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), rayTracingPositionFetch(in_struct->rayTracingPositionFetch) { + 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_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR( + const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src) { + sType = copy_src.sType; + rayTracingPositionFetch = copy_src.rayTracingPositionFetch; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::operator=( + const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + rayTracingPositionFetch = copy_src.rayTracingPositionFetch; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::~safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::initialize( + const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + rayTracingPositionFetch = in_struct->rayTracingPositionFetch; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::initialize( + const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + rayTracingPositionFetch = copy_src->rayTracingPositionFetch; + 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) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR), + pNext(nullptr), + MSize(), + NSize(), + KSize(), + AType(), + BType(), + CType(), + ResultType(), + saturatingAccumulation(), + scope() {} + +safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR( + const safe_VkCooperativeMatrixPropertiesKHR& copy_src) { + sType = copy_src.sType; + MSize = copy_src.MSize; + NSize = copy_src.NSize; + KSize = copy_src.KSize; + AType = copy_src.AType; + BType = copy_src.BType; + CType = copy_src.CType; + ResultType = copy_src.ResultType; + saturatingAccumulation = copy_src.saturatingAccumulation; + scope = copy_src.scope; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCooperativeMatrixPropertiesKHR& safe_VkCooperativeMatrixPropertiesKHR::operator=( + const safe_VkCooperativeMatrixPropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + MSize = copy_src.MSize; + NSize = copy_src.NSize; + KSize = copy_src.KSize; + AType = copy_src.AType; + BType = copy_src.BType; + CType = copy_src.CType; + ResultType = copy_src.ResultType; + saturatingAccumulation = copy_src.saturatingAccumulation; + scope = copy_src.scope; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCooperativeMatrixPropertiesKHR::~safe_VkCooperativeMatrixPropertiesKHR() { FreePnextChain(pNext); } + +void safe_VkCooperativeMatrixPropertiesKHR::initialize(const VkCooperativeMatrixPropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + MSize = in_struct->MSize; + NSize = in_struct->NSize; + KSize = in_struct->KSize; + AType = in_struct->AType; + BType = in_struct->BType; + CType = in_struct->CType; + ResultType = in_struct->ResultType; + saturatingAccumulation = in_struct->saturatingAccumulation; + scope = in_struct->scope; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCooperativeMatrixPropertiesKHR::initialize(const safe_VkCooperativeMatrixPropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + MSize = copy_src->MSize; + NSize = copy_src->NSize; + KSize = copy_src->KSize; + AType = copy_src->AType; + BType = copy_src->BType; + CType = copy_src->CType; + ResultType = copy_src->ResultType; + saturatingAccumulation = copy_src->saturatingAccumulation; + scope = copy_src->scope; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR( + const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + cooperativeMatrix(in_struct->cooperativeMatrix), + cooperativeMatrixRobustBufferAccess(in_struct->cooperativeMatrixRobustBufferAccess) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR), + pNext(nullptr), + cooperativeMatrix(), + cooperativeMatrixRobustBufferAccess() {} + +safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR( + const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src) { + sType = copy_src.sType; + cooperativeMatrix = copy_src.cooperativeMatrix; + cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::operator=( + const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + cooperativeMatrix = copy_src.cooperativeMatrix; + cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::~safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + cooperativeMatrix = in_struct->cooperativeMatrix; + cooperativeMatrixRobustBufferAccess = in_struct->cooperativeMatrixRobustBufferAccess; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::initialize( + const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + cooperativeMatrix = copy_src->cooperativeMatrix; + cooperativeMatrixRobustBufferAccess = copy_src->cooperativeMatrixRobustBufferAccess; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR( + const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), cooperativeMatrixSupportedStages(in_struct->cooperativeMatrixSupportedStages) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR), + pNext(nullptr), + cooperativeMatrixSupportedStages() {} + +safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR( + const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src) { + sType = copy_src.sType; + cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::operator=( + const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::~safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::initialize( + const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + cooperativeMatrixSupportedStages = in_struct->cooperativeMatrixSupportedStages; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::initialize( + const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + cooperativeMatrixSupportedStages = copy_src->cooperativeMatrixSupportedStages; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoDecodeAV1ProfileInfoKHR::safe_VkVideoDecodeAV1ProfileInfoKHR(const VkVideoDecodeAV1ProfileInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), stdProfile(in_struct->stdProfile), filmGrainSupport(in_struct->filmGrainSupport) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoDecodeAV1ProfileInfoKHR::safe_VkVideoDecodeAV1ProfileInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR), pNext(nullptr), stdProfile(), filmGrainSupport() {} + +safe_VkVideoDecodeAV1ProfileInfoKHR::safe_VkVideoDecodeAV1ProfileInfoKHR(const safe_VkVideoDecodeAV1ProfileInfoKHR& copy_src) { + sType = copy_src.sType; + stdProfile = copy_src.stdProfile; + filmGrainSupport = copy_src.filmGrainSupport; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoDecodeAV1ProfileInfoKHR& safe_VkVideoDecodeAV1ProfileInfoKHR::operator=( + const safe_VkVideoDecodeAV1ProfileInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + stdProfile = copy_src.stdProfile; + filmGrainSupport = copy_src.filmGrainSupport; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoDecodeAV1ProfileInfoKHR::~safe_VkVideoDecodeAV1ProfileInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoDecodeAV1ProfileInfoKHR::initialize(const VkVideoDecodeAV1ProfileInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + stdProfile = in_struct->stdProfile; + filmGrainSupport = in_struct->filmGrainSupport; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoDecodeAV1ProfileInfoKHR::initialize(const safe_VkVideoDecodeAV1ProfileInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stdProfile = copy_src->stdProfile; + filmGrainSupport = copy_src->filmGrainSupport; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoDecodeAV1CapabilitiesKHR::safe_VkVideoDecodeAV1CapabilitiesKHR(const VkVideoDecodeAV1CapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), maxLevel(in_struct->maxLevel) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoDecodeAV1CapabilitiesKHR::safe_VkVideoDecodeAV1CapabilitiesKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR), pNext(nullptr), maxLevel() {} + +safe_VkVideoDecodeAV1CapabilitiesKHR::safe_VkVideoDecodeAV1CapabilitiesKHR(const safe_VkVideoDecodeAV1CapabilitiesKHR& copy_src) { + sType = copy_src.sType; + maxLevel = copy_src.maxLevel; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoDecodeAV1CapabilitiesKHR& safe_VkVideoDecodeAV1CapabilitiesKHR::operator=( + const safe_VkVideoDecodeAV1CapabilitiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxLevel = copy_src.maxLevel; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoDecodeAV1CapabilitiesKHR::~safe_VkVideoDecodeAV1CapabilitiesKHR() { FreePnextChain(pNext); } + +void safe_VkVideoDecodeAV1CapabilitiesKHR::initialize(const VkVideoDecodeAV1CapabilitiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxLevel = in_struct->maxLevel; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoDecodeAV1CapabilitiesKHR::initialize(const safe_VkVideoDecodeAV1CapabilitiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxLevel = copy_src->maxLevel; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR( + const VkVideoDecodeAV1SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pStdSequenceHeader(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pStdSequenceHeader) { + pStdSequenceHeader = new StdVideoAV1SequenceHeader(*in_struct->pStdSequenceHeader); + } +} + +safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR), pNext(nullptr), pStdSequenceHeader(nullptr) {} + +safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR( + const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& copy_src) { + sType = copy_src.sType; + pStdSequenceHeader = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdSequenceHeader) { + pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src.pStdSequenceHeader); + } +} + +safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::operator=( + const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pStdSequenceHeader) delete pStdSequenceHeader; + FreePnextChain(pNext); + + sType = copy_src.sType; + pStdSequenceHeader = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdSequenceHeader) { + pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src.pStdSequenceHeader); + } + + return *this; +} + +safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::~safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR() { + if (pStdSequenceHeader) delete pStdSequenceHeader; + FreePnextChain(pNext); +} + +void safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::initialize( + const VkVideoDecodeAV1SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdSequenceHeader) delete pStdSequenceHeader; + FreePnextChain(pNext); + sType = in_struct->sType; + pStdSequenceHeader = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pStdSequenceHeader) { + pStdSequenceHeader = new StdVideoAV1SequenceHeader(*in_struct->pStdSequenceHeader); + } +} + +void safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::initialize( + const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pStdSequenceHeader = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdSequenceHeader) { + pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src->pStdSequenceHeader); + } +} + +safe_VkVideoDecodeAV1PictureInfoKHR::safe_VkVideoDecodeAV1PictureInfoKHR(const VkVideoDecodeAV1PictureInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + pStdPictureInfo(nullptr), + frameHeaderOffset(in_struct->frameHeaderOffset), + tileCount(in_struct->tileCount), + pTileOffsets(nullptr), + pTileSizes(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*in_struct->pStdPictureInfo); + } + + for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = in_struct->referenceNameSlotIndices[i]; + } + + if (in_struct->pTileOffsets) { + pTileOffsets = new uint32_t[in_struct->tileCount]; + memcpy((void*)pTileOffsets, (void*)in_struct->pTileOffsets, sizeof(uint32_t) * in_struct->tileCount); + } + + if (in_struct->pTileSizes) { + pTileSizes = new uint32_t[in_struct->tileCount]; + memcpy((void*)pTileSizes, (void*)in_struct->pTileSizes, sizeof(uint32_t) * in_struct->tileCount); + } +} + +safe_VkVideoDecodeAV1PictureInfoKHR::safe_VkVideoDecodeAV1PictureInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR), + pNext(nullptr), + pStdPictureInfo(nullptr), + frameHeaderOffset(), + tileCount(), + pTileOffsets(nullptr), + pTileSizes(nullptr) {} + +safe_VkVideoDecodeAV1PictureInfoKHR::safe_VkVideoDecodeAV1PictureInfoKHR(const safe_VkVideoDecodeAV1PictureInfoKHR& copy_src) { + sType = copy_src.sType; + pStdPictureInfo = nullptr; + frameHeaderOffset = copy_src.frameHeaderOffset; + tileCount = copy_src.tileCount; + pTileOffsets = nullptr; + pTileSizes = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*copy_src.pStdPictureInfo); + } + + for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = copy_src.referenceNameSlotIndices[i]; + } + + if (copy_src.pTileOffsets) { + pTileOffsets = new uint32_t[copy_src.tileCount]; + memcpy((void*)pTileOffsets, (void*)copy_src.pTileOffsets, sizeof(uint32_t) * copy_src.tileCount); + } + + if (copy_src.pTileSizes) { + pTileSizes = new uint32_t[copy_src.tileCount]; + memcpy((void*)pTileSizes, (void*)copy_src.pTileSizes, sizeof(uint32_t) * copy_src.tileCount); + } +} + +safe_VkVideoDecodeAV1PictureInfoKHR& safe_VkVideoDecodeAV1PictureInfoKHR::operator=( + const safe_VkVideoDecodeAV1PictureInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pStdPictureInfo) delete pStdPictureInfo; + if (pTileOffsets) delete[] pTileOffsets; + if (pTileSizes) delete[] pTileSizes; + FreePnextChain(pNext); + + sType = copy_src.sType; + pStdPictureInfo = nullptr; + frameHeaderOffset = copy_src.frameHeaderOffset; + tileCount = copy_src.tileCount; + pTileOffsets = nullptr; + pTileSizes = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*copy_src.pStdPictureInfo); + } + + for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = copy_src.referenceNameSlotIndices[i]; + } + + if (copy_src.pTileOffsets) { + pTileOffsets = new uint32_t[copy_src.tileCount]; + memcpy((void*)pTileOffsets, (void*)copy_src.pTileOffsets, sizeof(uint32_t) * copy_src.tileCount); + } + + if (copy_src.pTileSizes) { + pTileSizes = new uint32_t[copy_src.tileCount]; + memcpy((void*)pTileSizes, (void*)copy_src.pTileSizes, sizeof(uint32_t) * copy_src.tileCount); + } + + return *this; +} + +safe_VkVideoDecodeAV1PictureInfoKHR::~safe_VkVideoDecodeAV1PictureInfoKHR() { + if (pStdPictureInfo) delete pStdPictureInfo; + if (pTileOffsets) delete[] pTileOffsets; + if (pTileSizes) delete[] pTileSizes; + FreePnextChain(pNext); +} + +void safe_VkVideoDecodeAV1PictureInfoKHR::initialize(const VkVideoDecodeAV1PictureInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdPictureInfo) delete pStdPictureInfo; + if (pTileOffsets) delete[] pTileOffsets; + if (pTileSizes) delete[] pTileSizes; + FreePnextChain(pNext); + sType = in_struct->sType; + pStdPictureInfo = nullptr; + frameHeaderOffset = in_struct->frameHeaderOffset; + tileCount = in_struct->tileCount; + pTileOffsets = nullptr; + pTileSizes = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*in_struct->pStdPictureInfo); + } + + for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = in_struct->referenceNameSlotIndices[i]; + } + + if (in_struct->pTileOffsets) { + pTileOffsets = new uint32_t[in_struct->tileCount]; + memcpy((void*)pTileOffsets, (void*)in_struct->pTileOffsets, sizeof(uint32_t) * in_struct->tileCount); + } + + if (in_struct->pTileSizes) { + pTileSizes = new uint32_t[in_struct->tileCount]; + memcpy((void*)pTileSizes, (void*)in_struct->pTileSizes, sizeof(uint32_t) * in_struct->tileCount); + } +} + +void safe_VkVideoDecodeAV1PictureInfoKHR::initialize(const safe_VkVideoDecodeAV1PictureInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pStdPictureInfo = nullptr; + frameHeaderOffset = copy_src->frameHeaderOffset; + tileCount = copy_src->tileCount; + pTileOffsets = nullptr; + pTileSizes = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdPictureInfo) { + pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*copy_src->pStdPictureInfo); + } + + for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) { + referenceNameSlotIndices[i] = copy_src->referenceNameSlotIndices[i]; + } + + if (copy_src->pTileOffsets) { + pTileOffsets = new uint32_t[copy_src->tileCount]; + memcpy((void*)pTileOffsets, (void*)copy_src->pTileOffsets, sizeof(uint32_t) * copy_src->tileCount); + } + + if (copy_src->pTileSizes) { + pTileSizes = new uint32_t[copy_src->tileCount]; + memcpy((void*)pTileSizes, (void*)copy_src->pTileSizes, sizeof(uint32_t) * copy_src->tileCount); + } +} + +safe_VkVideoDecodeAV1DpbSlotInfoKHR::safe_VkVideoDecodeAV1DpbSlotInfoKHR(const VkVideoDecodeAV1DpbSlotInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), pStdReferenceInfo(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*in_struct->pStdReferenceInfo); + } +} + +safe_VkVideoDecodeAV1DpbSlotInfoKHR::safe_VkVideoDecodeAV1DpbSlotInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {} + +safe_VkVideoDecodeAV1DpbSlotInfoKHR::safe_VkVideoDecodeAV1DpbSlotInfoKHR(const safe_VkVideoDecodeAV1DpbSlotInfoKHR& copy_src) { + sType = copy_src.sType; + pStdReferenceInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*copy_src.pStdReferenceInfo); + } +} + +safe_VkVideoDecodeAV1DpbSlotInfoKHR& safe_VkVideoDecodeAV1DpbSlotInfoKHR::operator=( + const safe_VkVideoDecodeAV1DpbSlotInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pStdReferenceInfo) delete pStdReferenceInfo; + FreePnextChain(pNext); + + sType = copy_src.sType; + pStdReferenceInfo = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*copy_src.pStdReferenceInfo); + } + + return *this; +} + +safe_VkVideoDecodeAV1DpbSlotInfoKHR::~safe_VkVideoDecodeAV1DpbSlotInfoKHR() { + if (pStdReferenceInfo) delete pStdReferenceInfo; + FreePnextChain(pNext); +} + +void safe_VkVideoDecodeAV1DpbSlotInfoKHR::initialize(const VkVideoDecodeAV1DpbSlotInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStdReferenceInfo) delete pStdReferenceInfo; + FreePnextChain(pNext); + sType = in_struct->sType; + pStdReferenceInfo = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*in_struct->pStdReferenceInfo); + } +} + +void safe_VkVideoDecodeAV1DpbSlotInfoKHR::initialize(const safe_VkVideoDecodeAV1DpbSlotInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pStdReferenceInfo = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pStdReferenceInfo) { + pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*copy_src->pStdReferenceInfo); + } +} + +safe_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_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR), pNext(nullptr), videoMaintenance1() {} + +safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR( + const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src) { + sType = copy_src.sType; + videoMaintenance1 = copy_src.videoMaintenance1; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::operator=( + const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + videoMaintenance1 = copy_src.videoMaintenance1; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::~safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::initialize(const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + videoMaintenance1 = in_struct->videoMaintenance1; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::initialize( + const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + videoMaintenance1 = copy_src->videoMaintenance1; + pNext = SafePnextCopy(copy_src->pNext); +} + +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); + } +} + +safe_VkVideoInlineQueryInfoKHR::safe_VkVideoInlineQueryInfoKHR() + : sType(VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR), pNext(nullptr), queryPool(), firstQuery(), queryCount() {} + +safe_VkVideoInlineQueryInfoKHR::safe_VkVideoInlineQueryInfoKHR(const safe_VkVideoInlineQueryInfoKHR& copy_src) { + sType = copy_src.sType; + queryPool = copy_src.queryPool; + firstQuery = copy_src.firstQuery; + queryCount = copy_src.queryCount; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoInlineQueryInfoKHR& safe_VkVideoInlineQueryInfoKHR::operator=(const safe_VkVideoInlineQueryInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + queryPool = copy_src.queryPool; + firstQuery = copy_src.firstQuery; + queryCount = copy_src.queryCount; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoInlineQueryInfoKHR::~safe_VkVideoInlineQueryInfoKHR() { FreePnextChain(pNext); } + +void safe_VkVideoInlineQueryInfoKHR::initialize(const VkVideoInlineQueryInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + queryPool = in_struct->queryPool; + firstQuery = in_struct->firstQuery; + queryCount = in_struct->queryCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoInlineQueryInfoKHR::initialize(const safe_VkVideoInlineQueryInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + queryPool = copy_src->queryPool; + firstQuery = copy_src->firstQuery; + queryCount = copy_src->queryCount; + pNext = SafePnextCopy(copy_src->pNext); +} + +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_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR), + pNext(nullptr), + maxVertexAttribDivisor(), + supportsNonZeroFirstInstance() {} + +safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR( + const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src) { + sType = copy_src.sType; + maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor; + supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::operator=( + const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor; + supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::~safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::initialize( + const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxVertexAttribDivisor = in_struct->maxVertexAttribDivisor; + supportsNonZeroFirstInstance = in_struct->supportsNonZeroFirstInstance; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::initialize( + const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxVertexAttribDivisor = copy_src->maxVertexAttribDivisor; + supportsNonZeroFirstInstance = copy_src->supportsNonZeroFirstInstance; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_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_VkPipelineVertexInputDivisorStateCreateInfoKHR::safe_VkPipelineVertexInputDivisorStateCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR), + pNext(nullptr), + vertexBindingDivisorCount(), + pVertexBindingDivisors(nullptr) {} + +safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::safe_VkPipelineVertexInputDivisorStateCreateInfoKHR( + const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src) { + sType = copy_src.sType; + 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_VkPipelineVertexInputDivisorStateCreateInfoKHR& safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::operator=( + const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pVertexBindingDivisors) delete[] pVertexBindingDivisors; + FreePnextChain(pNext); + + sType = copy_src.sType; + vertexBindingDivisorCount = copy_src.vertexBindingDivisorCount; + pVertexBindingDivisors = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pVertexBindingDivisors) { + pVertexBindingDivisors = new 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); +} + +void safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::initialize( + const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pVertexBindingDivisors) delete[] pVertexBindingDivisors; + FreePnextChain(pNext); + sType = in_struct->sType; + vertexBindingDivisorCount = in_struct->vertexBindingDivisorCount; + pVertexBindingDivisors = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pVertexBindingDivisors) { + pVertexBindingDivisors = new 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) { + sType = copy_src->sType; + 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_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_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR), + pNext(nullptr), + vertexAttributeInstanceRateDivisor(), + vertexAttributeInstanceRateZeroDivisor() {} + +safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR( + const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src) { + sType = copy_src.sType; + vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor; + vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::operator=( + const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor; + vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::~safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::initialize( + const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + vertexAttributeInstanceRateDivisor = in_struct->vertexAttributeInstanceRateDivisor; + vertexAttributeInstanceRateZeroDivisor = in_struct->vertexAttributeInstanceRateZeroDivisor; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::initialize( + const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + vertexAttributeInstanceRateDivisor = copy_src->vertexAttributeInstanceRateDivisor; + vertexAttributeInstanceRateZeroDivisor = copy_src->vertexAttributeInstanceRateZeroDivisor; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR( + const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), shaderFloatControls2(in_struct->shaderFloatControls2) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR), pNext(nullptr), shaderFloatControls2() {} + +safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR( + const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src) { + sType = copy_src.sType; + shaderFloatControls2 = copy_src.shaderFloatControls2; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::operator=( + const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderFloatControls2 = copy_src.shaderFloatControls2; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::~safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::initialize( + const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderFloatControls2 = in_struct->shaderFloatControls2; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::initialize( + const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderFloatControls2 = copy_src->shaderFloatControls2; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR( + const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), indexTypeUint8(in_struct->indexTypeUint8) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR), pNext(nullptr), indexTypeUint8() {} + +safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR( + const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src) { + sType = copy_src.sType; + indexTypeUint8 = copy_src.indexTypeUint8; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::operator=( + const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + indexTypeUint8 = copy_src.indexTypeUint8; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::~safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::initialize(const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + indexTypeUint8 = in_struct->indexTypeUint8; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::initialize(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + indexTypeUint8 = copy_src->indexTypeUint8; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::safe_VkPhysicalDeviceLineRasterizationFeaturesKHR( + const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + rectangularLines(in_struct->rectangularLines), + bresenhamLines(in_struct->bresenhamLines), + smoothLines(in_struct->smoothLines), + stippledRectangularLines(in_struct->stippledRectangularLines), + stippledBresenhamLines(in_struct->stippledBresenhamLines), + stippledSmoothLines(in_struct->stippledSmoothLines) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::safe_VkPhysicalDeviceLineRasterizationFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR), + pNext(nullptr), + rectangularLines(), + bresenhamLines(), + smoothLines(), + stippledRectangularLines(), + stippledBresenhamLines(), + stippledSmoothLines() {} + +safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::safe_VkPhysicalDeviceLineRasterizationFeaturesKHR( + const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& copy_src) { + sType = copy_src.sType; + rectangularLines = copy_src.rectangularLines; + bresenhamLines = copy_src.bresenhamLines; + smoothLines = copy_src.smoothLines; + stippledRectangularLines = copy_src.stippledRectangularLines; + stippledBresenhamLines = copy_src.stippledBresenhamLines; + stippledSmoothLines = copy_src.stippledSmoothLines; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::operator=( + const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + rectangularLines = copy_src.rectangularLines; + bresenhamLines = copy_src.bresenhamLines; + smoothLines = copy_src.smoothLines; + stippledRectangularLines = copy_src.stippledRectangularLines; + stippledBresenhamLines = copy_src.stippledBresenhamLines; + stippledSmoothLines = copy_src.stippledSmoothLines; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::~safe_VkPhysicalDeviceLineRasterizationFeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::initialize(const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + rectangularLines = in_struct->rectangularLines; + bresenhamLines = in_struct->bresenhamLines; + smoothLines = in_struct->smoothLines; + stippledRectangularLines = in_struct->stippledRectangularLines; + stippledBresenhamLines = in_struct->stippledBresenhamLines; + stippledSmoothLines = in_struct->stippledSmoothLines; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::initialize( + const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + rectangularLines = copy_src->rectangularLines; + bresenhamLines = copy_src->bresenhamLines; + smoothLines = copy_src->smoothLines; + stippledRectangularLines = copy_src->stippledRectangularLines; + stippledBresenhamLines = copy_src->stippledBresenhamLines; + stippledSmoothLines = copy_src->stippledSmoothLines; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::safe_VkPhysicalDeviceLineRasterizationPropertiesKHR( + const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), lineSubPixelPrecisionBits(in_struct->lineSubPixelPrecisionBits) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::safe_VkPhysicalDeviceLineRasterizationPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR), pNext(nullptr), lineSubPixelPrecisionBits() {} + +safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::safe_VkPhysicalDeviceLineRasterizationPropertiesKHR( + const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& copy_src) { + sType = copy_src.sType; + lineSubPixelPrecisionBits = copy_src.lineSubPixelPrecisionBits; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::operator=( + const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + lineSubPixelPrecisionBits = copy_src.lineSubPixelPrecisionBits; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::~safe_VkPhysicalDeviceLineRasterizationPropertiesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::initialize( + const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + lineSubPixelPrecisionBits = in_struct->lineSubPixelPrecisionBits; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::initialize( + const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + lineSubPixelPrecisionBits = copy_src->lineSubPixelPrecisionBits; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineRasterizationLineStateCreateInfoKHR::safe_VkPipelineRasterizationLineStateCreateInfoKHR( + const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + lineRasterizationMode(in_struct->lineRasterizationMode), + stippledLineEnable(in_struct->stippledLineEnable), + lineStippleFactor(in_struct->lineStippleFactor), + lineStipplePattern(in_struct->lineStipplePattern) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineRasterizationLineStateCreateInfoKHR::safe_VkPipelineRasterizationLineStateCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR), + pNext(nullptr), + lineRasterizationMode(), + stippledLineEnable(), + lineStippleFactor(), + lineStipplePattern() {} + +safe_VkPipelineRasterizationLineStateCreateInfoKHR::safe_VkPipelineRasterizationLineStateCreateInfoKHR( + const safe_VkPipelineRasterizationLineStateCreateInfoKHR& copy_src) { + sType = copy_src.sType; + lineRasterizationMode = copy_src.lineRasterizationMode; + stippledLineEnable = copy_src.stippledLineEnable; + lineStippleFactor = copy_src.lineStippleFactor; + lineStipplePattern = copy_src.lineStipplePattern; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineRasterizationLineStateCreateInfoKHR& safe_VkPipelineRasterizationLineStateCreateInfoKHR::operator=( + const safe_VkPipelineRasterizationLineStateCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + lineRasterizationMode = copy_src.lineRasterizationMode; + stippledLineEnable = copy_src.stippledLineEnable; + lineStippleFactor = copy_src.lineStippleFactor; + lineStipplePattern = copy_src.lineStipplePattern; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineRasterizationLineStateCreateInfoKHR::~safe_VkPipelineRasterizationLineStateCreateInfoKHR() { FreePnextChain(pNext); } + +void safe_VkPipelineRasterizationLineStateCreateInfoKHR::initialize(const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + lineRasterizationMode = in_struct->lineRasterizationMode; + stippledLineEnable = in_struct->stippledLineEnable; + lineStippleFactor = in_struct->lineStippleFactor; + lineStipplePattern = in_struct->lineStipplePattern; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineRasterizationLineStateCreateInfoKHR::initialize( + const safe_VkPipelineRasterizationLineStateCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + lineRasterizationMode = copy_src->lineRasterizationMode; + stippledLineEnable = copy_src->stippledLineEnable; + lineStippleFactor = copy_src->lineStippleFactor; + lineStipplePattern = copy_src->lineStipplePattern; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR(const VkCalibratedTimestampInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), timeDomain(in_struct->timeDomain) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR() + : sType(VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR), pNext(nullptr), timeDomain() {} + +safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR(const safe_VkCalibratedTimestampInfoKHR& copy_src) { + sType = copy_src.sType; + timeDomain = copy_src.timeDomain; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCalibratedTimestampInfoKHR& safe_VkCalibratedTimestampInfoKHR::operator=(const safe_VkCalibratedTimestampInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + timeDomain = copy_src.timeDomain; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCalibratedTimestampInfoKHR::~safe_VkCalibratedTimestampInfoKHR() { FreePnextChain(pNext); } + +void safe_VkCalibratedTimestampInfoKHR::initialize(const VkCalibratedTimestampInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + timeDomain = in_struct->timeDomain; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCalibratedTimestampInfoKHR::initialize(const safe_VkCalibratedTimestampInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + timeDomain = copy_src->timeDomain; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR( + const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), shaderExpectAssume(in_struct->shaderExpectAssume) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR), pNext(nullptr), shaderExpectAssume() {} + +safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR( + const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src) { + sType = copy_src.sType; + shaderExpectAssume = copy_src.shaderExpectAssume; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::operator=( + const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderExpectAssume = copy_src.shaderExpectAssume; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::~safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::initialize(const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderExpectAssume = in_struct->shaderExpectAssume; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::initialize( + const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderExpectAssume = copy_src->shaderExpectAssume; + pNext = SafePnextCopy(copy_src->pNext); +} + +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_VkPhysicalDeviceMaintenance6FeaturesKHR::safe_VkPhysicalDeviceMaintenance6FeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR), pNext(nullptr), maintenance6() {} + +safe_VkPhysicalDeviceMaintenance6FeaturesKHR::safe_VkPhysicalDeviceMaintenance6FeaturesKHR( + const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& copy_src) { + sType = copy_src.sType; + maintenance6 = copy_src.maintenance6; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMaintenance6FeaturesKHR& safe_VkPhysicalDeviceMaintenance6FeaturesKHR::operator=( + const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maintenance6 = copy_src.maintenance6; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMaintenance6FeaturesKHR::~safe_VkPhysicalDeviceMaintenance6FeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMaintenance6FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance6FeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maintenance6 = in_struct->maintenance6; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMaintenance6FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance6FeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maintenance6 = copy_src->maintenance6; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMaintenance6PropertiesKHR::safe_VkPhysicalDeviceMaintenance6PropertiesKHR( + const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + blockTexelViewCompatibleMultipleLayers(in_struct->blockTexelViewCompatibleMultipleLayers), + maxCombinedImageSamplerDescriptorCount(in_struct->maxCombinedImageSamplerDescriptorCount), + fragmentShadingRateClampCombinerInputs(in_struct->fragmentShadingRateClampCombinerInputs) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMaintenance6PropertiesKHR::safe_VkPhysicalDeviceMaintenance6PropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR), + pNext(nullptr), + blockTexelViewCompatibleMultipleLayers(), + maxCombinedImageSamplerDescriptorCount(), + fragmentShadingRateClampCombinerInputs() {} + +safe_VkPhysicalDeviceMaintenance6PropertiesKHR::safe_VkPhysicalDeviceMaintenance6PropertiesKHR( + const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src) { + sType = copy_src.sType; + blockTexelViewCompatibleMultipleLayers = copy_src.blockTexelViewCompatibleMultipleLayers; + maxCombinedImageSamplerDescriptorCount = copy_src.maxCombinedImageSamplerDescriptorCount; + fragmentShadingRateClampCombinerInputs = copy_src.fragmentShadingRateClampCombinerInputs; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMaintenance6PropertiesKHR& safe_VkPhysicalDeviceMaintenance6PropertiesKHR::operator=( + const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + blockTexelViewCompatibleMultipleLayers = copy_src.blockTexelViewCompatibleMultipleLayers; + maxCombinedImageSamplerDescriptorCount = copy_src.maxCombinedImageSamplerDescriptorCount; + fragmentShadingRateClampCombinerInputs = copy_src.fragmentShadingRateClampCombinerInputs; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMaintenance6PropertiesKHR::~safe_VkPhysicalDeviceMaintenance6PropertiesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMaintenance6PropertiesKHR::initialize(const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + blockTexelViewCompatibleMultipleLayers = in_struct->blockTexelViewCompatibleMultipleLayers; + maxCombinedImageSamplerDescriptorCount = in_struct->maxCombinedImageSamplerDescriptorCount; + fragmentShadingRateClampCombinerInputs = in_struct->fragmentShadingRateClampCombinerInputs; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMaintenance6PropertiesKHR::initialize(const safe_VkPhysicalDeviceMaintenance6PropertiesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + blockTexelViewCompatibleMultipleLayers = copy_src->blockTexelViewCompatibleMultipleLayers; + maxCombinedImageSamplerDescriptorCount = copy_src->maxCombinedImageSamplerDescriptorCount; + fragmentShadingRateClampCombinerInputs = copy_src->fragmentShadingRateClampCombinerInputs; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_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_VkBindMemoryStatusKHR::safe_VkBindMemoryStatusKHR() + : sType(VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR), pNext(nullptr), pResult(nullptr) {} + +safe_VkBindMemoryStatusKHR::safe_VkBindMemoryStatusKHR(const safe_VkBindMemoryStatusKHR& copy_src) { + sType = copy_src.sType; + pResult = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pResult) { + pResult = new VkResult(*copy_src.pResult); + } +} + +safe_VkBindMemoryStatusKHR& safe_VkBindMemoryStatusKHR::operator=(const safe_VkBindMemoryStatusKHR& copy_src) { + if (©_src == this) return *this; + + if (pResult) delete pResult; + FreePnextChain(pNext); + + sType = copy_src.sType; + pResult = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pResult) { + pResult = new VkResult(*copy_src.pResult); + } + + return *this; +} + +safe_VkBindMemoryStatusKHR::~safe_VkBindMemoryStatusKHR() { + if (pResult) delete pResult; + FreePnextChain(pNext); +} + +void safe_VkBindMemoryStatusKHR::initialize(const VkBindMemoryStatusKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pResult) delete pResult; + FreePnextChain(pNext); + sType = in_struct->sType; + pResult = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pResult) { + pResult = new VkResult(*in_struct->pResult); + } +} + +void safe_VkBindMemoryStatusKHR::initialize(const safe_VkBindMemoryStatusKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pResult = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pResult) { + pResult = new VkResult(*copy_src->pResult); + } +} + +safe_VkBindDescriptorSetsInfoKHR::safe_VkBindDescriptorSetsInfoKHR(const VkBindDescriptorSetsInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + stageFlags(in_struct->stageFlags), + layout(in_struct->layout), + firstSet(in_struct->firstSet), + descriptorSetCount(in_struct->descriptorSetCount), + pDescriptorSets(nullptr), + dynamicOffsetCount(in_struct->dynamicOffsetCount), + pDynamicOffsets(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (descriptorSetCount && in_struct->pDescriptorSets) { + pDescriptorSets = new VkDescriptorSet[descriptorSetCount]; + for (uint32_t i = 0; i < descriptorSetCount; ++i) { + pDescriptorSets[i] = in_struct->pDescriptorSets[i]; + } + } + + if (in_struct->pDynamicOffsets) { + pDynamicOffsets = new uint32_t[in_struct->dynamicOffsetCount]; + memcpy((void*)pDynamicOffsets, (void*)in_struct->pDynamicOffsets, sizeof(uint32_t) * in_struct->dynamicOffsetCount); + } +} + +safe_VkBindDescriptorSetsInfoKHR::safe_VkBindDescriptorSetsInfoKHR() + : sType(VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR), + pNext(nullptr), + stageFlags(), + layout(), + firstSet(), + descriptorSetCount(), + pDescriptorSets(nullptr), + dynamicOffsetCount(), + pDynamicOffsets(nullptr) {} + +safe_VkBindDescriptorSetsInfoKHR::safe_VkBindDescriptorSetsInfoKHR(const safe_VkBindDescriptorSetsInfoKHR& copy_src) { + sType = copy_src.sType; + stageFlags = copy_src.stageFlags; + layout = copy_src.layout; + firstSet = copy_src.firstSet; + descriptorSetCount = copy_src.descriptorSetCount; + pDescriptorSets = nullptr; + dynamicOffsetCount = copy_src.dynamicOffsetCount; + pDynamicOffsets = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (descriptorSetCount && copy_src.pDescriptorSets) { + pDescriptorSets = new VkDescriptorSet[descriptorSetCount]; + for (uint32_t i = 0; i < descriptorSetCount; ++i) { + pDescriptorSets[i] = copy_src.pDescriptorSets[i]; + } + } + + if (copy_src.pDynamicOffsets) { + pDynamicOffsets = new uint32_t[copy_src.dynamicOffsetCount]; + memcpy((void*)pDynamicOffsets, (void*)copy_src.pDynamicOffsets, sizeof(uint32_t) * copy_src.dynamicOffsetCount); + } +} + +safe_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; + 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_VkBindDescriptorSetsInfoKHR::~safe_VkBindDescriptorSetsInfoKHR() { + if (pDescriptorSets) delete[] pDescriptorSets; + if (pDynamicOffsets) delete[] pDynamicOffsets; + FreePnextChain(pNext); +} + +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; + 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_VkBindDescriptorSetsInfoKHR::initialize(const safe_VkBindDescriptorSetsInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stageFlags = copy_src->stageFlags; + layout = copy_src->layout; + firstSet = copy_src->firstSet; + descriptorSetCount = copy_src->descriptorSetCount; + pDescriptorSets = nullptr; + dynamicOffsetCount = copy_src->dynamicOffsetCount; + pDynamicOffsets = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (descriptorSetCount && copy_src->pDescriptorSets) { + pDescriptorSets = new VkDescriptorSet[descriptorSetCount]; + for (uint32_t i = 0; i < descriptorSetCount; ++i) { + pDescriptorSets[i] = copy_src->pDescriptorSets[i]; + } + } + + if (copy_src->pDynamicOffsets) { + pDynamicOffsets = new uint32_t[copy_src->dynamicOffsetCount]; + memcpy((void*)pDynamicOffsets, (void*)copy_src->pDynamicOffsets, sizeof(uint32_t) * copy_src->dynamicOffsetCount); + } +} + +safe_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); + } +} + +safe_VkPushConstantsInfoKHR::safe_VkPushConstantsInfoKHR() + : sType(VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR), + pNext(nullptr), + layout(), + stageFlags(), + offset(), + size(), + pValues(nullptr) {} + +safe_VkPushConstantsInfoKHR::safe_VkPushConstantsInfoKHR(const safe_VkPushConstantsInfoKHR& copy_src) { + sType = copy_src.sType; + layout = copy_src.layout; + stageFlags = copy_src.stageFlags; + offset = copy_src.offset; + size = copy_src.size; + pValues = copy_src.pValues; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPushConstantsInfoKHR& safe_VkPushConstantsInfoKHR::operator=(const safe_VkPushConstantsInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + layout = copy_src.layout; + stageFlags = copy_src.stageFlags; + offset = copy_src.offset; + size = copy_src.size; + pValues = copy_src.pValues; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPushConstantsInfoKHR::~safe_VkPushConstantsInfoKHR() { FreePnextChain(pNext); } + +void safe_VkPushConstantsInfoKHR::initialize(const VkPushConstantsInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + layout = in_struct->layout; + stageFlags = in_struct->stageFlags; + offset = in_struct->offset; + size = in_struct->size; + pValues = in_struct->pValues; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPushConstantsInfoKHR::initialize(const safe_VkPushConstantsInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + layout = copy_src->layout; + stageFlags = copy_src->stageFlags; + offset = copy_src->offset; + size = copy_src->size; + pValues = copy_src->pValues; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPushDescriptorSetInfoKHR::safe_VkPushDescriptorSetInfoKHR(const VkPushDescriptorSetInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + stageFlags(in_struct->stageFlags), + layout(in_struct->layout), + set(in_struct->set), + descriptorWriteCount(in_struct->descriptorWriteCount), + pDescriptorWrites(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (descriptorWriteCount && in_struct->pDescriptorWrites) { + pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount]; + for (uint32_t i = 0; i < descriptorWriteCount; ++i) { + pDescriptorWrites[i].initialize(&in_struct->pDescriptorWrites[i]); + } + } +} + +safe_VkPushDescriptorSetInfoKHR::safe_VkPushDescriptorSetInfoKHR() + : sType(VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR), + pNext(nullptr), + stageFlags(), + layout(), + set(), + descriptorWriteCount(), + pDescriptorWrites(nullptr) {} + +safe_VkPushDescriptorSetInfoKHR::safe_VkPushDescriptorSetInfoKHR(const safe_VkPushDescriptorSetInfoKHR& copy_src) { + sType = copy_src.sType; + stageFlags = copy_src.stageFlags; + layout = copy_src.layout; + set = copy_src.set; + descriptorWriteCount = copy_src.descriptorWriteCount; + pDescriptorWrites = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (descriptorWriteCount && copy_src.pDescriptorWrites) { + pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount]; + for (uint32_t i = 0; i < descriptorWriteCount; ++i) { + pDescriptorWrites[i].initialize(©_src.pDescriptorWrites[i]); + } + } +} + +safe_VkPushDescriptorSetInfoKHR& safe_VkPushDescriptorSetInfoKHR::operator=(const safe_VkPushDescriptorSetInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pDescriptorWrites) delete[] pDescriptorWrites; + FreePnextChain(pNext); + + sType = copy_src.sType; + stageFlags = copy_src.stageFlags; + layout = copy_src.layout; + set = copy_src.set; + descriptorWriteCount = copy_src.descriptorWriteCount; + pDescriptorWrites = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (descriptorWriteCount && copy_src.pDescriptorWrites) { + pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount]; + for (uint32_t i = 0; i < descriptorWriteCount; ++i) { + pDescriptorWrites[i].initialize(©_src.pDescriptorWrites[i]); + } + } + + return *this; +} + +safe_VkPushDescriptorSetInfoKHR::~safe_VkPushDescriptorSetInfoKHR() { + if (pDescriptorWrites) delete[] pDescriptorWrites; + FreePnextChain(pNext); +} + +void safe_VkPushDescriptorSetInfoKHR::initialize(const VkPushDescriptorSetInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDescriptorWrites) delete[] pDescriptorWrites; + FreePnextChain(pNext); + sType = in_struct->sType; + stageFlags = in_struct->stageFlags; + layout = in_struct->layout; + set = in_struct->set; + descriptorWriteCount = in_struct->descriptorWriteCount; + pDescriptorWrites = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (descriptorWriteCount && in_struct->pDescriptorWrites) { + pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount]; + for (uint32_t i = 0; i < descriptorWriteCount; ++i) { + pDescriptorWrites[i].initialize(&in_struct->pDescriptorWrites[i]); + } + } +} + +void safe_VkPushDescriptorSetInfoKHR::initialize(const safe_VkPushDescriptorSetInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stageFlags = copy_src->stageFlags; + layout = copy_src->layout; + set = copy_src->set; + descriptorWriteCount = copy_src->descriptorWriteCount; + pDescriptorWrites = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (descriptorWriteCount && copy_src->pDescriptorWrites) { + pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount]; + for (uint32_t i = 0; i < descriptorWriteCount; ++i) { + pDescriptorWrites[i].initialize(©_src->pDescriptorWrites[i]); + } + } +} + +safe_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_VkPushDescriptorSetWithTemplateInfoKHR::safe_VkPushDescriptorSetWithTemplateInfoKHR() + : sType(VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR), + pNext(nullptr), + descriptorUpdateTemplate(), + layout(), + set(), + pData(nullptr) {} + +safe_VkPushDescriptorSetWithTemplateInfoKHR::safe_VkPushDescriptorSetWithTemplateInfoKHR( + const safe_VkPushDescriptorSetWithTemplateInfoKHR& copy_src) { + sType = copy_src.sType; + descriptorUpdateTemplate = copy_src.descriptorUpdateTemplate; + layout = copy_src.layout; + set = copy_src.set; + pNext = SafePnextCopy(copy_src.pNext); +} + +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; + descriptorUpdateTemplate = copy_src.descriptorUpdateTemplate; + layout = copy_src.layout; + set = copy_src.set; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPushDescriptorSetWithTemplateInfoKHR::~safe_VkPushDescriptorSetWithTemplateInfoKHR() { + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + FreePnextChain(pNext); +} + +void safe_VkPushDescriptorSetWithTemplateInfoKHR::initialize(const VkPushDescriptorSetWithTemplateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + FreePnextChain(pNext); + sType = in_struct->sType; + descriptorUpdateTemplate = in_struct->descriptorUpdateTemplate; + layout = in_struct->layout; + set = in_struct->set; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPushDescriptorSetWithTemplateInfoKHR::initialize(const safe_VkPushDescriptorSetWithTemplateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + descriptorUpdateTemplate = copy_src->descriptorUpdateTemplate; + layout = copy_src->layout; + set = copy_src->set; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDeviceOrHostAddressConstKHR::safe_VkDeviceOrHostAddressConstKHR(const VkDeviceOrHostAddressConstKHR* in_struct, + PNextCopyState*) { + initialize(in_struct); +} + +safe_VkDeviceOrHostAddressConstKHR::safe_VkDeviceOrHostAddressConstKHR() : hostAddress(nullptr) {} + +safe_VkDeviceOrHostAddressConstKHR::safe_VkDeviceOrHostAddressConstKHR(const safe_VkDeviceOrHostAddressConstKHR& copy_src) { + deviceAddress = copy_src.deviceAddress; + hostAddress = copy_src.hostAddress; +} + +safe_VkDeviceOrHostAddressConstKHR& safe_VkDeviceOrHostAddressConstKHR::operator=( + const safe_VkDeviceOrHostAddressConstKHR& copy_src) { + if (©_src == this) return *this; + + deviceAddress = copy_src.deviceAddress; + hostAddress = copy_src.hostAddress; + + return *this; +} + +safe_VkDeviceOrHostAddressConstKHR::~safe_VkDeviceOrHostAddressConstKHR() {} + +void safe_VkDeviceOrHostAddressConstKHR::initialize(const VkDeviceOrHostAddressConstKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + deviceAddress = in_struct->deviceAddress; + hostAddress = in_struct->hostAddress; +} + +void safe_VkDeviceOrHostAddressConstKHR::initialize(const safe_VkDeviceOrHostAddressConstKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + deviceAddress = copy_src->deviceAddress; + hostAddress = copy_src->hostAddress; +} + +safe_VkDeviceOrHostAddressKHR::safe_VkDeviceOrHostAddressKHR(const VkDeviceOrHostAddressKHR* in_struct, PNextCopyState*) { + initialize(in_struct); +} + +safe_VkDeviceOrHostAddressKHR::safe_VkDeviceOrHostAddressKHR() : hostAddress(nullptr) {} + +safe_VkDeviceOrHostAddressKHR::safe_VkDeviceOrHostAddressKHR(const safe_VkDeviceOrHostAddressKHR& copy_src) { + deviceAddress = copy_src.deviceAddress; + hostAddress = copy_src.hostAddress; +} + +safe_VkDeviceOrHostAddressKHR& safe_VkDeviceOrHostAddressKHR::operator=(const safe_VkDeviceOrHostAddressKHR& copy_src) { + if (©_src == this) return *this; + + deviceAddress = copy_src.deviceAddress; + hostAddress = copy_src.hostAddress; + + return *this; +} + +safe_VkDeviceOrHostAddressKHR::~safe_VkDeviceOrHostAddressKHR() {} + +void safe_VkDeviceOrHostAddressKHR::initialize(const VkDeviceOrHostAddressKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + deviceAddress = in_struct->deviceAddress; + hostAddress = in_struct->hostAddress; +} + +void safe_VkDeviceOrHostAddressKHR::initialize(const safe_VkDeviceOrHostAddressKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + deviceAddress = copy_src->deviceAddress; + hostAddress = copy_src->hostAddress; +} + +safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR( + const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + vertexFormat(in_struct->vertexFormat), + vertexData(&in_struct->vertexData), + vertexStride(in_struct->vertexStride), + maxVertex(in_struct->maxVertex), + indexType(in_struct->indexType), + indexData(&in_struct->indexData), + transformData(&in_struct->transformData) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR), + pNext(nullptr), + vertexFormat(), + vertexStride(), + maxVertex(), + indexType() {} + +safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR( + const safe_VkAccelerationStructureGeometryTrianglesDataKHR& copy_src) { + sType = copy_src.sType; + vertexFormat = copy_src.vertexFormat; + vertexData.initialize(©_src.vertexData); + vertexStride = copy_src.vertexStride; + maxVertex = copy_src.maxVertex; + indexType = copy_src.indexType; + indexData.initialize(©_src.indexData); + transformData.initialize(©_src.transformData); + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAccelerationStructureGeometryTrianglesDataKHR& safe_VkAccelerationStructureGeometryTrianglesDataKHR::operator=( + const safe_VkAccelerationStructureGeometryTrianglesDataKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + vertexFormat = copy_src.vertexFormat; + vertexData.initialize(©_src.vertexData); + vertexStride = copy_src.vertexStride; + maxVertex = copy_src.maxVertex; + indexType = copy_src.indexType; + indexData.initialize(©_src.indexData); + transformData.initialize(©_src.transformData); + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAccelerationStructureGeometryTrianglesDataKHR::~safe_VkAccelerationStructureGeometryTrianglesDataKHR() { + FreePnextChain(pNext); +} + +void safe_VkAccelerationStructureGeometryTrianglesDataKHR::initialize( + const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + vertexFormat = in_struct->vertexFormat; + vertexData.initialize(&in_struct->vertexData); + vertexStride = in_struct->vertexStride; + maxVertex = in_struct->maxVertex; + indexType = in_struct->indexType; + indexData.initialize(&in_struct->indexData); + transformData.initialize(&in_struct->transformData); + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAccelerationStructureGeometryTrianglesDataKHR::initialize( + const safe_VkAccelerationStructureGeometryTrianglesDataKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + vertexFormat = copy_src->vertexFormat; + vertexData.initialize(©_src->vertexData); + vertexStride = copy_src->vertexStride; + maxVertex = copy_src->maxVertex; + indexType = copy_src->indexType; + indexData.initialize(©_src->indexData); + transformData.initialize(©_src->transformData); + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAccelerationStructureGeometryAabbsDataKHR::safe_VkAccelerationStructureGeometryAabbsDataKHR( + const VkAccelerationStructureGeometryAabbsDataKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), data(&in_struct->data), stride(in_struct->stride) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAccelerationStructureGeometryAabbsDataKHR::safe_VkAccelerationStructureGeometryAabbsDataKHR() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR), pNext(nullptr), stride() {} + +safe_VkAccelerationStructureGeometryAabbsDataKHR::safe_VkAccelerationStructureGeometryAabbsDataKHR( + const safe_VkAccelerationStructureGeometryAabbsDataKHR& copy_src) { + sType = copy_src.sType; + data.initialize(©_src.data); + stride = copy_src.stride; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAccelerationStructureGeometryAabbsDataKHR& safe_VkAccelerationStructureGeometryAabbsDataKHR::operator=( + const safe_VkAccelerationStructureGeometryAabbsDataKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + data.initialize(©_src.data); + stride = copy_src.stride; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAccelerationStructureGeometryAabbsDataKHR::~safe_VkAccelerationStructureGeometryAabbsDataKHR() { FreePnextChain(pNext); } + +void safe_VkAccelerationStructureGeometryAabbsDataKHR::initialize(const VkAccelerationStructureGeometryAabbsDataKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + data.initialize(&in_struct->data); + stride = in_struct->stride; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAccelerationStructureGeometryAabbsDataKHR::initialize(const safe_VkAccelerationStructureGeometryAabbsDataKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + data.initialize(©_src->data); + stride = copy_src->stride; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAccelerationStructureGeometryInstancesDataKHR::safe_VkAccelerationStructureGeometryInstancesDataKHR( + const VkAccelerationStructureGeometryInstancesDataKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), arrayOfPointers(in_struct->arrayOfPointers), data(&in_struct->data) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAccelerationStructureGeometryInstancesDataKHR::safe_VkAccelerationStructureGeometryInstancesDataKHR() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR), pNext(nullptr), arrayOfPointers() {} + +safe_VkAccelerationStructureGeometryInstancesDataKHR::safe_VkAccelerationStructureGeometryInstancesDataKHR( + const safe_VkAccelerationStructureGeometryInstancesDataKHR& copy_src) { + sType = copy_src.sType; + arrayOfPointers = copy_src.arrayOfPointers; + data.initialize(©_src.data); + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAccelerationStructureGeometryInstancesDataKHR& safe_VkAccelerationStructureGeometryInstancesDataKHR::operator=( + const safe_VkAccelerationStructureGeometryInstancesDataKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + arrayOfPointers = copy_src.arrayOfPointers; + data.initialize(©_src.data); + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAccelerationStructureGeometryInstancesDataKHR::~safe_VkAccelerationStructureGeometryInstancesDataKHR() { + FreePnextChain(pNext); +} + +void safe_VkAccelerationStructureGeometryInstancesDataKHR::initialize( + const VkAccelerationStructureGeometryInstancesDataKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + arrayOfPointers = in_struct->arrayOfPointers; + data.initialize(&in_struct->data); + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAccelerationStructureGeometryInstancesDataKHR::initialize( + const safe_VkAccelerationStructureGeometryInstancesDataKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + arrayOfPointers = copy_src->arrayOfPointers; + data.initialize(©_src->data); + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAccelerationStructureCreateInfoKHR::safe_VkAccelerationStructureCreateInfoKHR( + const VkAccelerationStructureCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + createFlags(in_struct->createFlags), + buffer(in_struct->buffer), + offset(in_struct->offset), + size(in_struct->size), + type(in_struct->type), + deviceAddress(in_struct->deviceAddress) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAccelerationStructureCreateInfoKHR::safe_VkAccelerationStructureCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR), + pNext(nullptr), + createFlags(), + buffer(), + offset(), + size(), + type(), + deviceAddress() {} + +safe_VkAccelerationStructureCreateInfoKHR::safe_VkAccelerationStructureCreateInfoKHR( + const safe_VkAccelerationStructureCreateInfoKHR& copy_src) { + sType = copy_src.sType; + createFlags = copy_src.createFlags; + buffer = copy_src.buffer; + offset = copy_src.offset; + size = copy_src.size; + type = copy_src.type; + deviceAddress = copy_src.deviceAddress; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAccelerationStructureCreateInfoKHR& safe_VkAccelerationStructureCreateInfoKHR::operator=( + const safe_VkAccelerationStructureCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + createFlags = copy_src.createFlags; + buffer = copy_src.buffer; + offset = copy_src.offset; + size = copy_src.size; + type = copy_src.type; + deviceAddress = copy_src.deviceAddress; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAccelerationStructureCreateInfoKHR::~safe_VkAccelerationStructureCreateInfoKHR() { FreePnextChain(pNext); } + +void safe_VkAccelerationStructureCreateInfoKHR::initialize(const VkAccelerationStructureCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + createFlags = in_struct->createFlags; + buffer = in_struct->buffer; + offset = in_struct->offset; + size = in_struct->size; + type = in_struct->type; + deviceAddress = in_struct->deviceAddress; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAccelerationStructureCreateInfoKHR::initialize(const safe_VkAccelerationStructureCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + createFlags = copy_src->createFlags; + buffer = copy_src->buffer; + offset = copy_src->offset; + size = copy_src->size; + type = copy_src->type; + deviceAddress = copy_src->deviceAddress; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkWriteDescriptorSetAccelerationStructureKHR::safe_VkWriteDescriptorSetAccelerationStructureKHR( + const VkWriteDescriptorSetAccelerationStructureKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), accelerationStructureCount(in_struct->accelerationStructureCount), pAccelerationStructures(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (accelerationStructureCount && in_struct->pAccelerationStructures) { + pAccelerationStructures = new VkAccelerationStructureKHR[accelerationStructureCount]; + for (uint32_t i = 0; i < accelerationStructureCount; ++i) { + pAccelerationStructures[i] = in_struct->pAccelerationStructures[i]; + } + } +} + +safe_VkWriteDescriptorSetAccelerationStructureKHR::safe_VkWriteDescriptorSetAccelerationStructureKHR() + : sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR), + pNext(nullptr), + accelerationStructureCount(), + pAccelerationStructures(nullptr) {} + +safe_VkWriteDescriptorSetAccelerationStructureKHR::safe_VkWriteDescriptorSetAccelerationStructureKHR( + const safe_VkWriteDescriptorSetAccelerationStructureKHR& copy_src) { + sType = copy_src.sType; + accelerationStructureCount = copy_src.accelerationStructureCount; + pAccelerationStructures = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (accelerationStructureCount && copy_src.pAccelerationStructures) { + pAccelerationStructures = new VkAccelerationStructureKHR[accelerationStructureCount]; + for (uint32_t i = 0; i < accelerationStructureCount; ++i) { + pAccelerationStructures[i] = copy_src.pAccelerationStructures[i]; + } + } +} + +safe_VkWriteDescriptorSetAccelerationStructureKHR& safe_VkWriteDescriptorSetAccelerationStructureKHR::operator=( + const safe_VkWriteDescriptorSetAccelerationStructureKHR& copy_src) { + if (©_src == this) return *this; + + if (pAccelerationStructures) delete[] pAccelerationStructures; + FreePnextChain(pNext); + + sType = copy_src.sType; + accelerationStructureCount = copy_src.accelerationStructureCount; + pAccelerationStructures = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (accelerationStructureCount && copy_src.pAccelerationStructures) { + pAccelerationStructures = new VkAccelerationStructureKHR[accelerationStructureCount]; + for (uint32_t i = 0; i < accelerationStructureCount; ++i) { + pAccelerationStructures[i] = copy_src.pAccelerationStructures[i]; + } + } + + return *this; +} + +safe_VkWriteDescriptorSetAccelerationStructureKHR::~safe_VkWriteDescriptorSetAccelerationStructureKHR() { + if (pAccelerationStructures) delete[] pAccelerationStructures; + FreePnextChain(pNext); +} + +void safe_VkWriteDescriptorSetAccelerationStructureKHR::initialize(const VkWriteDescriptorSetAccelerationStructureKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pAccelerationStructures) delete[] pAccelerationStructures; + FreePnextChain(pNext); + sType = in_struct->sType; + accelerationStructureCount = in_struct->accelerationStructureCount; + pAccelerationStructures = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (accelerationStructureCount && in_struct->pAccelerationStructures) { + pAccelerationStructures = new VkAccelerationStructureKHR[accelerationStructureCount]; + for (uint32_t i = 0; i < accelerationStructureCount; ++i) { + pAccelerationStructures[i] = in_struct->pAccelerationStructures[i]; + } + } +} + +void safe_VkWriteDescriptorSetAccelerationStructureKHR::initialize( + const safe_VkWriteDescriptorSetAccelerationStructureKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + accelerationStructureCount = copy_src->accelerationStructureCount; + pAccelerationStructures = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (accelerationStructureCount && copy_src->pAccelerationStructures) { + pAccelerationStructures = new VkAccelerationStructureKHR[accelerationStructureCount]; + for (uint32_t i = 0; i < accelerationStructureCount; ++i) { + pAccelerationStructures[i] = copy_src->pAccelerationStructures[i]; + } + } +} + +safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR( + const VkPhysicalDeviceAccelerationStructureFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + accelerationStructure(in_struct->accelerationStructure), + accelerationStructureCaptureReplay(in_struct->accelerationStructureCaptureReplay), + accelerationStructureIndirectBuild(in_struct->accelerationStructureIndirectBuild), + accelerationStructureHostCommands(in_struct->accelerationStructureHostCommands), + descriptorBindingAccelerationStructureUpdateAfterBind(in_struct->descriptorBindingAccelerationStructureUpdateAfterBind) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR), + pNext(nullptr), + accelerationStructure(), + accelerationStructureCaptureReplay(), + accelerationStructureIndirectBuild(), + accelerationStructureHostCommands(), + descriptorBindingAccelerationStructureUpdateAfterBind() {} + +safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR( + const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR& copy_src) { + sType = copy_src.sType; + accelerationStructure = copy_src.accelerationStructure; + accelerationStructureCaptureReplay = copy_src.accelerationStructureCaptureReplay; + accelerationStructureIndirectBuild = copy_src.accelerationStructureIndirectBuild; + accelerationStructureHostCommands = copy_src.accelerationStructureHostCommands; + descriptorBindingAccelerationStructureUpdateAfterBind = copy_src.descriptorBindingAccelerationStructureUpdateAfterBind; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR& safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::operator=( + const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + accelerationStructure = copy_src.accelerationStructure; + accelerationStructureCaptureReplay = copy_src.accelerationStructureCaptureReplay; + accelerationStructureIndirectBuild = copy_src.accelerationStructureIndirectBuild; + accelerationStructureHostCommands = copy_src.accelerationStructureHostCommands; + descriptorBindingAccelerationStructureUpdateAfterBind = copy_src.descriptorBindingAccelerationStructureUpdateAfterBind; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::~safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::initialize( + const VkPhysicalDeviceAccelerationStructureFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + accelerationStructure = in_struct->accelerationStructure; + accelerationStructureCaptureReplay = in_struct->accelerationStructureCaptureReplay; + accelerationStructureIndirectBuild = in_struct->accelerationStructureIndirectBuild; + accelerationStructureHostCommands = in_struct->accelerationStructureHostCommands; + descriptorBindingAccelerationStructureUpdateAfterBind = in_struct->descriptorBindingAccelerationStructureUpdateAfterBind; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::initialize( + const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + accelerationStructure = copy_src->accelerationStructure; + accelerationStructureCaptureReplay = copy_src->accelerationStructureCaptureReplay; + accelerationStructureIndirectBuild = copy_src->accelerationStructureIndirectBuild; + accelerationStructureHostCommands = copy_src->accelerationStructureHostCommands; + descriptorBindingAccelerationStructureUpdateAfterBind = copy_src->descriptorBindingAccelerationStructureUpdateAfterBind; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR( + const VkPhysicalDeviceAccelerationStructurePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + maxGeometryCount(in_struct->maxGeometryCount), + maxInstanceCount(in_struct->maxInstanceCount), + maxPrimitiveCount(in_struct->maxPrimitiveCount), + maxPerStageDescriptorAccelerationStructures(in_struct->maxPerStageDescriptorAccelerationStructures), + maxPerStageDescriptorUpdateAfterBindAccelerationStructures( + in_struct->maxPerStageDescriptorUpdateAfterBindAccelerationStructures), + maxDescriptorSetAccelerationStructures(in_struct->maxDescriptorSetAccelerationStructures), + maxDescriptorSetUpdateAfterBindAccelerationStructures(in_struct->maxDescriptorSetUpdateAfterBindAccelerationStructures), + minAccelerationStructureScratchOffsetAlignment(in_struct->minAccelerationStructureScratchOffsetAlignment) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR), + pNext(nullptr), + maxGeometryCount(), + maxInstanceCount(), + maxPrimitiveCount(), + maxPerStageDescriptorAccelerationStructures(), + maxPerStageDescriptorUpdateAfterBindAccelerationStructures(), + maxDescriptorSetAccelerationStructures(), + maxDescriptorSetUpdateAfterBindAccelerationStructures(), + minAccelerationStructureScratchOffsetAlignment() {} + +safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR( + const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR& copy_src) { + sType = copy_src.sType; + maxGeometryCount = copy_src.maxGeometryCount; + maxInstanceCount = copy_src.maxInstanceCount; + maxPrimitiveCount = copy_src.maxPrimitiveCount; + maxPerStageDescriptorAccelerationStructures = copy_src.maxPerStageDescriptorAccelerationStructures; + maxPerStageDescriptorUpdateAfterBindAccelerationStructures = + copy_src.maxPerStageDescriptorUpdateAfterBindAccelerationStructures; + maxDescriptorSetAccelerationStructures = copy_src.maxDescriptorSetAccelerationStructures; + maxDescriptorSetUpdateAfterBindAccelerationStructures = copy_src.maxDescriptorSetUpdateAfterBindAccelerationStructures; + minAccelerationStructureScratchOffsetAlignment = copy_src.minAccelerationStructureScratchOffsetAlignment; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR& safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::operator=( + const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxGeometryCount = copy_src.maxGeometryCount; + maxInstanceCount = copy_src.maxInstanceCount; + maxPrimitiveCount = copy_src.maxPrimitiveCount; + maxPerStageDescriptorAccelerationStructures = copy_src.maxPerStageDescriptorAccelerationStructures; + maxPerStageDescriptorUpdateAfterBindAccelerationStructures = + copy_src.maxPerStageDescriptorUpdateAfterBindAccelerationStructures; + maxDescriptorSetAccelerationStructures = copy_src.maxDescriptorSetAccelerationStructures; + maxDescriptorSetUpdateAfterBindAccelerationStructures = copy_src.maxDescriptorSetUpdateAfterBindAccelerationStructures; + minAccelerationStructureScratchOffsetAlignment = copy_src.minAccelerationStructureScratchOffsetAlignment; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::~safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::initialize( + const VkPhysicalDeviceAccelerationStructurePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxGeometryCount = in_struct->maxGeometryCount; + maxInstanceCount = in_struct->maxInstanceCount; + maxPrimitiveCount = in_struct->maxPrimitiveCount; + maxPerStageDescriptorAccelerationStructures = in_struct->maxPerStageDescriptorAccelerationStructures; + maxPerStageDescriptorUpdateAfterBindAccelerationStructures = + in_struct->maxPerStageDescriptorUpdateAfterBindAccelerationStructures; + maxDescriptorSetAccelerationStructures = in_struct->maxDescriptorSetAccelerationStructures; + maxDescriptorSetUpdateAfterBindAccelerationStructures = in_struct->maxDescriptorSetUpdateAfterBindAccelerationStructures; + minAccelerationStructureScratchOffsetAlignment = in_struct->minAccelerationStructureScratchOffsetAlignment; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::initialize( + const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxGeometryCount = copy_src->maxGeometryCount; + maxInstanceCount = copy_src->maxInstanceCount; + maxPrimitiveCount = copy_src->maxPrimitiveCount; + maxPerStageDescriptorAccelerationStructures = copy_src->maxPerStageDescriptorAccelerationStructures; + maxPerStageDescriptorUpdateAfterBindAccelerationStructures = + copy_src->maxPerStageDescriptorUpdateAfterBindAccelerationStructures; + maxDescriptorSetAccelerationStructures = copy_src->maxDescriptorSetAccelerationStructures; + maxDescriptorSetUpdateAfterBindAccelerationStructures = copy_src->maxDescriptorSetUpdateAfterBindAccelerationStructures; + minAccelerationStructureScratchOffsetAlignment = copy_src->minAccelerationStructureScratchOffsetAlignment; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAccelerationStructureDeviceAddressInfoKHR::safe_VkAccelerationStructureDeviceAddressInfoKHR( + const VkAccelerationStructureDeviceAddressInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), accelerationStructure(in_struct->accelerationStructure) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAccelerationStructureDeviceAddressInfoKHR::safe_VkAccelerationStructureDeviceAddressInfoKHR() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR), pNext(nullptr), accelerationStructure() {} + +safe_VkAccelerationStructureDeviceAddressInfoKHR::safe_VkAccelerationStructureDeviceAddressInfoKHR( + const safe_VkAccelerationStructureDeviceAddressInfoKHR& copy_src) { + sType = copy_src.sType; + accelerationStructure = copy_src.accelerationStructure; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAccelerationStructureDeviceAddressInfoKHR& safe_VkAccelerationStructureDeviceAddressInfoKHR::operator=( + const safe_VkAccelerationStructureDeviceAddressInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + accelerationStructure = copy_src.accelerationStructure; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAccelerationStructureDeviceAddressInfoKHR::~safe_VkAccelerationStructureDeviceAddressInfoKHR() { FreePnextChain(pNext); } + +void safe_VkAccelerationStructureDeviceAddressInfoKHR::initialize(const VkAccelerationStructureDeviceAddressInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + accelerationStructure = in_struct->accelerationStructure; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAccelerationStructureDeviceAddressInfoKHR::initialize(const safe_VkAccelerationStructureDeviceAddressInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + accelerationStructure = copy_src->accelerationStructure; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAccelerationStructureVersionInfoKHR::safe_VkAccelerationStructureVersionInfoKHR( + const VkAccelerationStructureVersionInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pVersionData(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pVersionData) { + pVersionData = new uint8_t[2 * VK_UUID_SIZE]; + memcpy((void*)pVersionData, (void*)in_struct->pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE); + } +} + +safe_VkAccelerationStructureVersionInfoKHR::safe_VkAccelerationStructureVersionInfoKHR() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR), pNext(nullptr), pVersionData(nullptr) {} + +safe_VkAccelerationStructureVersionInfoKHR::safe_VkAccelerationStructureVersionInfoKHR( + const safe_VkAccelerationStructureVersionInfoKHR& copy_src) { + sType = copy_src.sType; + pVersionData = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pVersionData) { + pVersionData = new uint8_t[2 * VK_UUID_SIZE]; + memcpy((void*)pVersionData, (void*)copy_src.pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE); + } +} + +safe_VkAccelerationStructureVersionInfoKHR& safe_VkAccelerationStructureVersionInfoKHR::operator=( + const safe_VkAccelerationStructureVersionInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pVersionData) delete[] pVersionData; + FreePnextChain(pNext); + + sType = copy_src.sType; + pVersionData = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pVersionData) { + pVersionData = new uint8_t[2 * VK_UUID_SIZE]; + memcpy((void*)pVersionData, (void*)copy_src.pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE); + } + + return *this; +} + +safe_VkAccelerationStructureVersionInfoKHR::~safe_VkAccelerationStructureVersionInfoKHR() { + if (pVersionData) delete[] pVersionData; + FreePnextChain(pNext); +} + +void safe_VkAccelerationStructureVersionInfoKHR::initialize(const VkAccelerationStructureVersionInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pVersionData) delete[] pVersionData; + FreePnextChain(pNext); + sType = in_struct->sType; + pVersionData = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pVersionData) { + pVersionData = new uint8_t[2 * VK_UUID_SIZE]; + memcpy((void*)pVersionData, (void*)in_struct->pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE); + } +} + +void safe_VkAccelerationStructureVersionInfoKHR::initialize(const safe_VkAccelerationStructureVersionInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pVersionData = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pVersionData) { + pVersionData = new uint8_t[2 * VK_UUID_SIZE]; + memcpy((void*)pVersionData, (void*)copy_src->pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE); + } +} + +safe_VkCopyAccelerationStructureToMemoryInfoKHR::safe_VkCopyAccelerationStructureToMemoryInfoKHR( + const VkCopyAccelerationStructureToMemoryInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), src(in_struct->src), dst(&in_struct->dst), mode(in_struct->mode) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCopyAccelerationStructureToMemoryInfoKHR::safe_VkCopyAccelerationStructureToMemoryInfoKHR() + : sType(VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR), pNext(nullptr), src(), mode() {} + +safe_VkCopyAccelerationStructureToMemoryInfoKHR::safe_VkCopyAccelerationStructureToMemoryInfoKHR( + const safe_VkCopyAccelerationStructureToMemoryInfoKHR& copy_src) { + sType = copy_src.sType; + src = copy_src.src; + dst.initialize(©_src.dst); + mode = copy_src.mode; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCopyAccelerationStructureToMemoryInfoKHR& safe_VkCopyAccelerationStructureToMemoryInfoKHR::operator=( + const safe_VkCopyAccelerationStructureToMemoryInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + src = copy_src.src; + dst.initialize(©_src.dst); + mode = copy_src.mode; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCopyAccelerationStructureToMemoryInfoKHR::~safe_VkCopyAccelerationStructureToMemoryInfoKHR() { FreePnextChain(pNext); } + +void safe_VkCopyAccelerationStructureToMemoryInfoKHR::initialize(const VkCopyAccelerationStructureToMemoryInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + src = in_struct->src; + dst.initialize(&in_struct->dst); + mode = in_struct->mode; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCopyAccelerationStructureToMemoryInfoKHR::initialize(const safe_VkCopyAccelerationStructureToMemoryInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + src = copy_src->src; + dst.initialize(©_src->dst); + mode = copy_src->mode; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCopyMemoryToAccelerationStructureInfoKHR::safe_VkCopyMemoryToAccelerationStructureInfoKHR( + const VkCopyMemoryToAccelerationStructureInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), src(&in_struct->src), dst(in_struct->dst), mode(in_struct->mode) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCopyMemoryToAccelerationStructureInfoKHR::safe_VkCopyMemoryToAccelerationStructureInfoKHR() + : sType(VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR), pNext(nullptr), dst(), mode() {} + +safe_VkCopyMemoryToAccelerationStructureInfoKHR::safe_VkCopyMemoryToAccelerationStructureInfoKHR( + const safe_VkCopyMemoryToAccelerationStructureInfoKHR& copy_src) { + sType = copy_src.sType; + src.initialize(©_src.src); + dst = copy_src.dst; + mode = copy_src.mode; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCopyMemoryToAccelerationStructureInfoKHR& safe_VkCopyMemoryToAccelerationStructureInfoKHR::operator=( + const safe_VkCopyMemoryToAccelerationStructureInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + src.initialize(©_src.src); + dst = copy_src.dst; + mode = copy_src.mode; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCopyMemoryToAccelerationStructureInfoKHR::~safe_VkCopyMemoryToAccelerationStructureInfoKHR() { FreePnextChain(pNext); } + +void safe_VkCopyMemoryToAccelerationStructureInfoKHR::initialize(const VkCopyMemoryToAccelerationStructureInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + src.initialize(&in_struct->src); + dst = in_struct->dst; + mode = in_struct->mode; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCopyMemoryToAccelerationStructureInfoKHR::initialize(const safe_VkCopyMemoryToAccelerationStructureInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + src.initialize(©_src->src); + dst = copy_src->dst; + mode = copy_src->mode; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCopyAccelerationStructureInfoKHR::safe_VkCopyAccelerationStructureInfoKHR( + const VkCopyAccelerationStructureInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), src(in_struct->src), dst(in_struct->dst), mode(in_struct->mode) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCopyAccelerationStructureInfoKHR::safe_VkCopyAccelerationStructureInfoKHR() + : sType(VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR), pNext(nullptr), src(), dst(), mode() {} + +safe_VkCopyAccelerationStructureInfoKHR::safe_VkCopyAccelerationStructureInfoKHR( + const safe_VkCopyAccelerationStructureInfoKHR& copy_src) { + sType = copy_src.sType; + src = copy_src.src; + dst = copy_src.dst; + mode = copy_src.mode; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCopyAccelerationStructureInfoKHR& safe_VkCopyAccelerationStructureInfoKHR::operator=( + const safe_VkCopyAccelerationStructureInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + src = copy_src.src; + dst = copy_src.dst; + mode = copy_src.mode; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCopyAccelerationStructureInfoKHR::~safe_VkCopyAccelerationStructureInfoKHR() { FreePnextChain(pNext); } + +void safe_VkCopyAccelerationStructureInfoKHR::initialize(const VkCopyAccelerationStructureInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + src = in_struct->src; + dst = in_struct->dst; + mode = in_struct->mode; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCopyAccelerationStructureInfoKHR::initialize(const safe_VkCopyAccelerationStructureInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + src = copy_src->src; + dst = copy_src->dst; + mode = copy_src->mode; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR( + const VkAccelerationStructureBuildSizesInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + accelerationStructureSize(in_struct->accelerationStructureSize), + updateScratchSize(in_struct->updateScratchSize), + buildScratchSize(in_struct->buildScratchSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR), + pNext(nullptr), + accelerationStructureSize(), + updateScratchSize(), + buildScratchSize() {} + +safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR( + const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src) { + sType = copy_src.sType; + accelerationStructureSize = copy_src.accelerationStructureSize; + updateScratchSize = copy_src.updateScratchSize; + buildScratchSize = copy_src.buildScratchSize; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAccelerationStructureBuildSizesInfoKHR& safe_VkAccelerationStructureBuildSizesInfoKHR::operator=( + const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + accelerationStructureSize = copy_src.accelerationStructureSize; + updateScratchSize = copy_src.updateScratchSize; + buildScratchSize = copy_src.buildScratchSize; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAccelerationStructureBuildSizesInfoKHR::~safe_VkAccelerationStructureBuildSizesInfoKHR() { FreePnextChain(pNext); } + +void safe_VkAccelerationStructureBuildSizesInfoKHR::initialize(const VkAccelerationStructureBuildSizesInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + accelerationStructureSize = in_struct->accelerationStructureSize; + updateScratchSize = in_struct->updateScratchSize; + buildScratchSize = in_struct->buildScratchSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAccelerationStructureBuildSizesInfoKHR::initialize(const safe_VkAccelerationStructureBuildSizesInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + accelerationStructureSize = copy_src->accelerationStructureSize; + updateScratchSize = copy_src->updateScratchSize; + buildScratchSize = copy_src->buildScratchSize; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkRayTracingShaderGroupCreateInfoKHR::safe_VkRayTracingShaderGroupCreateInfoKHR( + const VkRayTracingShaderGroupCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + type(in_struct->type), + generalShader(in_struct->generalShader), + closestHitShader(in_struct->closestHitShader), + anyHitShader(in_struct->anyHitShader), + intersectionShader(in_struct->intersectionShader), + pShaderGroupCaptureReplayHandle(in_struct->pShaderGroupCaptureReplayHandle) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkRayTracingShaderGroupCreateInfoKHR::safe_VkRayTracingShaderGroupCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR), + pNext(nullptr), + type(), + generalShader(), + closestHitShader(), + anyHitShader(), + intersectionShader(), + pShaderGroupCaptureReplayHandle(nullptr) {} + +safe_VkRayTracingShaderGroupCreateInfoKHR::safe_VkRayTracingShaderGroupCreateInfoKHR( + const safe_VkRayTracingShaderGroupCreateInfoKHR& copy_src) { + sType = copy_src.sType; + type = copy_src.type; + generalShader = copy_src.generalShader; + closestHitShader = copy_src.closestHitShader; + anyHitShader = copy_src.anyHitShader; + intersectionShader = copy_src.intersectionShader; + pShaderGroupCaptureReplayHandle = copy_src.pShaderGroupCaptureReplayHandle; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkRayTracingShaderGroupCreateInfoKHR& safe_VkRayTracingShaderGroupCreateInfoKHR::operator=( + const safe_VkRayTracingShaderGroupCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + type = copy_src.type; + generalShader = copy_src.generalShader; + closestHitShader = copy_src.closestHitShader; + anyHitShader = copy_src.anyHitShader; + intersectionShader = copy_src.intersectionShader; + pShaderGroupCaptureReplayHandle = copy_src.pShaderGroupCaptureReplayHandle; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkRayTracingShaderGroupCreateInfoKHR::~safe_VkRayTracingShaderGroupCreateInfoKHR() { FreePnextChain(pNext); } + +void safe_VkRayTracingShaderGroupCreateInfoKHR::initialize(const VkRayTracingShaderGroupCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + type = in_struct->type; + generalShader = in_struct->generalShader; + closestHitShader = in_struct->closestHitShader; + anyHitShader = in_struct->anyHitShader; + intersectionShader = in_struct->intersectionShader; + pShaderGroupCaptureReplayHandle = in_struct->pShaderGroupCaptureReplayHandle; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkRayTracingShaderGroupCreateInfoKHR::initialize(const safe_VkRayTracingShaderGroupCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + type = copy_src->type; + generalShader = copy_src->generalShader; + closestHitShader = copy_src->closestHitShader; + anyHitShader = copy_src->anyHitShader; + intersectionShader = copy_src->intersectionShader; + pShaderGroupCaptureReplayHandle = copy_src->pShaderGroupCaptureReplayHandle; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkRayTracingPipelineInterfaceCreateInfoKHR::safe_VkRayTracingPipelineInterfaceCreateInfoKHR( + const VkRayTracingPipelineInterfaceCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + maxPipelineRayPayloadSize(in_struct->maxPipelineRayPayloadSize), + maxPipelineRayHitAttributeSize(in_struct->maxPipelineRayHitAttributeSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkRayTracingPipelineInterfaceCreateInfoKHR::safe_VkRayTracingPipelineInterfaceCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR), + pNext(nullptr), + maxPipelineRayPayloadSize(), + maxPipelineRayHitAttributeSize() {} + +safe_VkRayTracingPipelineInterfaceCreateInfoKHR::safe_VkRayTracingPipelineInterfaceCreateInfoKHR( + const safe_VkRayTracingPipelineInterfaceCreateInfoKHR& copy_src) { + sType = copy_src.sType; + maxPipelineRayPayloadSize = copy_src.maxPipelineRayPayloadSize; + maxPipelineRayHitAttributeSize = copy_src.maxPipelineRayHitAttributeSize; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkRayTracingPipelineInterfaceCreateInfoKHR& safe_VkRayTracingPipelineInterfaceCreateInfoKHR::operator=( + const safe_VkRayTracingPipelineInterfaceCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxPipelineRayPayloadSize = copy_src.maxPipelineRayPayloadSize; + maxPipelineRayHitAttributeSize = copy_src.maxPipelineRayHitAttributeSize; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkRayTracingPipelineInterfaceCreateInfoKHR::~safe_VkRayTracingPipelineInterfaceCreateInfoKHR() { FreePnextChain(pNext); } + +void safe_VkRayTracingPipelineInterfaceCreateInfoKHR::initialize(const VkRayTracingPipelineInterfaceCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxPipelineRayPayloadSize = in_struct->maxPipelineRayPayloadSize; + maxPipelineRayHitAttributeSize = in_struct->maxPipelineRayHitAttributeSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkRayTracingPipelineInterfaceCreateInfoKHR::initialize(const safe_VkRayTracingPipelineInterfaceCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxPipelineRayPayloadSize = copy_src->maxPipelineRayPayloadSize; + maxPipelineRayHitAttributeSize = copy_src->maxPipelineRayHitAttributeSize; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkRayTracingPipelineCreateInfoKHR::safe_VkRayTracingPipelineCreateInfoKHR(const VkRayTracingPipelineCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + stageCount(in_struct->stageCount), + pStages(nullptr), + groupCount(in_struct->groupCount), + pGroups(nullptr), + maxPipelineRayRecursionDepth(in_struct->maxPipelineRayRecursionDepth), + pLibraryInfo(nullptr), + pLibraryInterface(nullptr), + pDynamicState(nullptr), + layout(in_struct->layout), + basePipelineHandle(in_struct->basePipelineHandle), + basePipelineIndex(in_struct->basePipelineIndex) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (stageCount && in_struct->pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(&in_struct->pStages[i]); + } + } + if (groupCount && in_struct->pGroups) { + pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount]; + for (uint32_t i = 0; i < groupCount; ++i) { + pGroups[i].initialize(&in_struct->pGroups[i]); + } + } + if (in_struct->pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(in_struct->pLibraryInfo); + if (in_struct->pLibraryInterface) + pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(in_struct->pLibraryInterface); + if (in_struct->pDynamicState) pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(in_struct->pDynamicState); +} + +safe_VkRayTracingPipelineCreateInfoKHR::safe_VkRayTracingPipelineCreateInfoKHR() + : sType(VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR), + pNext(nullptr), + flags(), + stageCount(), + pStages(nullptr), + groupCount(), + pGroups(nullptr), + maxPipelineRayRecursionDepth(), + pLibraryInfo(nullptr), + pLibraryInterface(nullptr), + pDynamicState(nullptr), + layout(), + basePipelineHandle(), + basePipelineIndex() {} + +safe_VkRayTracingPipelineCreateInfoKHR::safe_VkRayTracingPipelineCreateInfoKHR( + const safe_VkRayTracingPipelineCreateInfoKHR& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + stageCount = copy_src.stageCount; + pStages = nullptr; + groupCount = copy_src.groupCount; + pGroups = nullptr; + maxPipelineRayRecursionDepth = copy_src.maxPipelineRayRecursionDepth; + pLibraryInfo = nullptr; + pLibraryInterface = nullptr; + pDynamicState = nullptr; + layout = copy_src.layout; + basePipelineHandle = copy_src.basePipelineHandle; + basePipelineIndex = copy_src.basePipelineIndex; + pNext = SafePnextCopy(copy_src.pNext); + if (stageCount && copy_src.pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(©_src.pStages[i]); + } + } + if (groupCount && copy_src.pGroups) { + pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount]; + for (uint32_t i = 0; i < groupCount; ++i) { + pGroups[i].initialize(©_src.pGroups[i]); + } + } + if (copy_src.pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(*copy_src.pLibraryInfo); + if (copy_src.pLibraryInterface) + pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(*copy_src.pLibraryInterface); + if (copy_src.pDynamicState) pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*copy_src.pDynamicState); +} + +safe_VkRayTracingPipelineCreateInfoKHR& safe_VkRayTracingPipelineCreateInfoKHR::operator=( + const safe_VkRayTracingPipelineCreateInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pStages) delete[] pStages; + if (pGroups) delete[] pGroups; + if (pLibraryInfo) delete pLibraryInfo; + if (pLibraryInterface) delete pLibraryInterface; + if (pDynamicState) delete pDynamicState; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + stageCount = copy_src.stageCount; + pStages = nullptr; + groupCount = copy_src.groupCount; + pGroups = nullptr; + maxPipelineRayRecursionDepth = copy_src.maxPipelineRayRecursionDepth; + pLibraryInfo = nullptr; + pLibraryInterface = nullptr; + pDynamicState = nullptr; + layout = copy_src.layout; + basePipelineHandle = copy_src.basePipelineHandle; + basePipelineIndex = copy_src.basePipelineIndex; + pNext = SafePnextCopy(copy_src.pNext); + if (stageCount && copy_src.pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(©_src.pStages[i]); + } + } + if (groupCount && copy_src.pGroups) { + pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount]; + for (uint32_t i = 0; i < groupCount; ++i) { + pGroups[i].initialize(©_src.pGroups[i]); + } + } + if (copy_src.pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(*copy_src.pLibraryInfo); + if (copy_src.pLibraryInterface) + pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(*copy_src.pLibraryInterface); + if (copy_src.pDynamicState) pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*copy_src.pDynamicState); + + return *this; +} + +safe_VkRayTracingPipelineCreateInfoKHR::~safe_VkRayTracingPipelineCreateInfoKHR() { + if (pStages) delete[] pStages; + if (pGroups) delete[] pGroups; + if (pLibraryInfo) delete pLibraryInfo; + if (pLibraryInterface) delete pLibraryInterface; + if (pDynamicState) delete pDynamicState; + FreePnextChain(pNext); +} + +void safe_VkRayTracingPipelineCreateInfoKHR::initialize(const VkRayTracingPipelineCreateInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStages) delete[] pStages; + if (pGroups) delete[] pGroups; + if (pLibraryInfo) delete pLibraryInfo; + if (pLibraryInterface) delete pLibraryInterface; + if (pDynamicState) delete pDynamicState; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + stageCount = in_struct->stageCount; + pStages = nullptr; + groupCount = in_struct->groupCount; + pGroups = nullptr; + maxPipelineRayRecursionDepth = in_struct->maxPipelineRayRecursionDepth; + pLibraryInfo = nullptr; + pLibraryInterface = nullptr; + pDynamicState = nullptr; + layout = in_struct->layout; + basePipelineHandle = in_struct->basePipelineHandle; + basePipelineIndex = in_struct->basePipelineIndex; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (stageCount && in_struct->pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(&in_struct->pStages[i]); + } + } + if (groupCount && in_struct->pGroups) { + pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount]; + for (uint32_t i = 0; i < groupCount; ++i) { + pGroups[i].initialize(&in_struct->pGroups[i]); + } + } + if (in_struct->pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(in_struct->pLibraryInfo); + if (in_struct->pLibraryInterface) + pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(in_struct->pLibraryInterface); + if (in_struct->pDynamicState) pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(in_struct->pDynamicState); +} + +void safe_VkRayTracingPipelineCreateInfoKHR::initialize(const safe_VkRayTracingPipelineCreateInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + stageCount = copy_src->stageCount; + pStages = nullptr; + groupCount = copy_src->groupCount; + pGroups = nullptr; + maxPipelineRayRecursionDepth = copy_src->maxPipelineRayRecursionDepth; + pLibraryInfo = nullptr; + pLibraryInterface = nullptr; + pDynamicState = nullptr; + layout = copy_src->layout; + basePipelineHandle = copy_src->basePipelineHandle; + basePipelineIndex = copy_src->basePipelineIndex; + pNext = SafePnextCopy(copy_src->pNext); + if (stageCount && copy_src->pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(©_src->pStages[i]); + } + } + if (groupCount && copy_src->pGroups) { + pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount]; + for (uint32_t i = 0; i < groupCount; ++i) { + pGroups[i].initialize(©_src->pGroups[i]); + } + } + if (copy_src->pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(*copy_src->pLibraryInfo); + if (copy_src->pLibraryInterface) + pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(*copy_src->pLibraryInterface); + if (copy_src->pDynamicState) pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*copy_src->pDynamicState); +} + +safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR( + const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + rayTracingPipeline(in_struct->rayTracingPipeline), + rayTracingPipelineShaderGroupHandleCaptureReplay(in_struct->rayTracingPipelineShaderGroupHandleCaptureReplay), + rayTracingPipelineShaderGroupHandleCaptureReplayMixed(in_struct->rayTracingPipelineShaderGroupHandleCaptureReplayMixed), + rayTracingPipelineTraceRaysIndirect(in_struct->rayTracingPipelineTraceRaysIndirect), + rayTraversalPrimitiveCulling(in_struct->rayTraversalPrimitiveCulling) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR), + pNext(nullptr), + rayTracingPipeline(), + rayTracingPipelineShaderGroupHandleCaptureReplay(), + rayTracingPipelineShaderGroupHandleCaptureReplayMixed(), + rayTracingPipelineTraceRaysIndirect(), + rayTraversalPrimitiveCulling() {} + +safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR( + const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR& copy_src) { + sType = copy_src.sType; + rayTracingPipeline = copy_src.rayTracingPipeline; + rayTracingPipelineShaderGroupHandleCaptureReplay = copy_src.rayTracingPipelineShaderGroupHandleCaptureReplay; + rayTracingPipelineShaderGroupHandleCaptureReplayMixed = copy_src.rayTracingPipelineShaderGroupHandleCaptureReplayMixed; + rayTracingPipelineTraceRaysIndirect = copy_src.rayTracingPipelineTraceRaysIndirect; + rayTraversalPrimitiveCulling = copy_src.rayTraversalPrimitiveCulling; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR& safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::operator=( + const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + rayTracingPipeline = copy_src.rayTracingPipeline; + rayTracingPipelineShaderGroupHandleCaptureReplay = copy_src.rayTracingPipelineShaderGroupHandleCaptureReplay; + rayTracingPipelineShaderGroupHandleCaptureReplayMixed = copy_src.rayTracingPipelineShaderGroupHandleCaptureReplayMixed; + rayTracingPipelineTraceRaysIndirect = copy_src.rayTracingPipelineTraceRaysIndirect; + rayTraversalPrimitiveCulling = copy_src.rayTraversalPrimitiveCulling; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::~safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::initialize(const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + rayTracingPipeline = in_struct->rayTracingPipeline; + rayTracingPipelineShaderGroupHandleCaptureReplay = in_struct->rayTracingPipelineShaderGroupHandleCaptureReplay; + rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_struct->rayTracingPipelineShaderGroupHandleCaptureReplayMixed; + rayTracingPipelineTraceRaysIndirect = in_struct->rayTracingPipelineTraceRaysIndirect; + rayTraversalPrimitiveCulling = in_struct->rayTraversalPrimitiveCulling; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::initialize( + const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + rayTracingPipeline = copy_src->rayTracingPipeline; + rayTracingPipelineShaderGroupHandleCaptureReplay = copy_src->rayTracingPipelineShaderGroupHandleCaptureReplay; + rayTracingPipelineShaderGroupHandleCaptureReplayMixed = copy_src->rayTracingPipelineShaderGroupHandleCaptureReplayMixed; + rayTracingPipelineTraceRaysIndirect = copy_src->rayTracingPipelineTraceRaysIndirect; + rayTraversalPrimitiveCulling = copy_src->rayTraversalPrimitiveCulling; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR( + const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shaderGroupHandleSize(in_struct->shaderGroupHandleSize), + maxRayRecursionDepth(in_struct->maxRayRecursionDepth), + maxShaderGroupStride(in_struct->maxShaderGroupStride), + shaderGroupBaseAlignment(in_struct->shaderGroupBaseAlignment), + shaderGroupHandleCaptureReplaySize(in_struct->shaderGroupHandleCaptureReplaySize), + maxRayDispatchInvocationCount(in_struct->maxRayDispatchInvocationCount), + shaderGroupHandleAlignment(in_struct->shaderGroupHandleAlignment), + maxRayHitAttributeSize(in_struct->maxRayHitAttributeSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR), + pNext(nullptr), + shaderGroupHandleSize(), + maxRayRecursionDepth(), + maxShaderGroupStride(), + shaderGroupBaseAlignment(), + shaderGroupHandleCaptureReplaySize(), + maxRayDispatchInvocationCount(), + shaderGroupHandleAlignment(), + maxRayHitAttributeSize() {} + +safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR( + const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR& copy_src) { + sType = copy_src.sType; + shaderGroupHandleSize = copy_src.shaderGroupHandleSize; + maxRayRecursionDepth = copy_src.maxRayRecursionDepth; + maxShaderGroupStride = copy_src.maxShaderGroupStride; + shaderGroupBaseAlignment = copy_src.shaderGroupBaseAlignment; + shaderGroupHandleCaptureReplaySize = copy_src.shaderGroupHandleCaptureReplaySize; + maxRayDispatchInvocationCount = copy_src.maxRayDispatchInvocationCount; + shaderGroupHandleAlignment = copy_src.shaderGroupHandleAlignment; + maxRayHitAttributeSize = copy_src.maxRayHitAttributeSize; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR& safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::operator=( + const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderGroupHandleSize = copy_src.shaderGroupHandleSize; + maxRayRecursionDepth = copy_src.maxRayRecursionDepth; + maxShaderGroupStride = copy_src.maxShaderGroupStride; + shaderGroupBaseAlignment = copy_src.shaderGroupBaseAlignment; + shaderGroupHandleCaptureReplaySize = copy_src.shaderGroupHandleCaptureReplaySize; + maxRayDispatchInvocationCount = copy_src.maxRayDispatchInvocationCount; + shaderGroupHandleAlignment = copy_src.shaderGroupHandleAlignment; + maxRayHitAttributeSize = copy_src.maxRayHitAttributeSize; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::~safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::initialize( + const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderGroupHandleSize = in_struct->shaderGroupHandleSize; + maxRayRecursionDepth = in_struct->maxRayRecursionDepth; + maxShaderGroupStride = in_struct->maxShaderGroupStride; + shaderGroupBaseAlignment = in_struct->shaderGroupBaseAlignment; + shaderGroupHandleCaptureReplaySize = in_struct->shaderGroupHandleCaptureReplaySize; + maxRayDispatchInvocationCount = in_struct->maxRayDispatchInvocationCount; + shaderGroupHandleAlignment = in_struct->shaderGroupHandleAlignment; + maxRayHitAttributeSize = in_struct->maxRayHitAttributeSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::initialize( + const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderGroupHandleSize = copy_src->shaderGroupHandleSize; + maxRayRecursionDepth = copy_src->maxRayRecursionDepth; + maxShaderGroupStride = copy_src->maxShaderGroupStride; + shaderGroupBaseAlignment = copy_src->shaderGroupBaseAlignment; + shaderGroupHandleCaptureReplaySize = copy_src->shaderGroupHandleCaptureReplaySize; + maxRayDispatchInvocationCount = copy_src->maxRayDispatchInvocationCount; + shaderGroupHandleAlignment = copy_src->shaderGroupHandleAlignment; + maxRayHitAttributeSize = copy_src->maxRayHitAttributeSize; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceRayQueryFeaturesKHR::safe_VkPhysicalDeviceRayQueryFeaturesKHR( + const VkPhysicalDeviceRayQueryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), rayQuery(in_struct->rayQuery) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceRayQueryFeaturesKHR::safe_VkPhysicalDeviceRayQueryFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR), pNext(nullptr), rayQuery() {} + +safe_VkPhysicalDeviceRayQueryFeaturesKHR::safe_VkPhysicalDeviceRayQueryFeaturesKHR( + const safe_VkPhysicalDeviceRayQueryFeaturesKHR& copy_src) { + sType = copy_src.sType; + rayQuery = copy_src.rayQuery; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceRayQueryFeaturesKHR& safe_VkPhysicalDeviceRayQueryFeaturesKHR::operator=( + const safe_VkPhysicalDeviceRayQueryFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + rayQuery = copy_src.rayQuery; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceRayQueryFeaturesKHR::~safe_VkPhysicalDeviceRayQueryFeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceRayQueryFeaturesKHR::initialize(const VkPhysicalDeviceRayQueryFeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + rayQuery = in_struct->rayQuery; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceRayQueryFeaturesKHR::initialize(const safe_VkPhysicalDeviceRayQueryFeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + rayQuery = copy_src->rayQuery; + pNext = SafePnextCopy(copy_src->pNext); +} + +} // namespace vku + +// NOLINTEND diff --git a/src/vulkan/vk_safe_struct_manual.cpp b/src/vulkan/vk_safe_struct_manual.cpp new file mode 100644 index 0000000..4e50f8a --- /dev/null +++ b/src/vulkan/vk_safe_struct_manual.cpp @@ -0,0 +1,2209 @@ +/*************************************************************************** + * + * Copyright (c) 2015-2024 The Khronos Group Inc. + * Copyright (c) 2015-2024 Valve Corporation + * Copyright (c) 2015-2024 LunarG, Inc. + * Copyright (c) 2015-2024 Google Inc. + * + * SPDX-License-Identifier: Apache-2.0 + * + ****************************************************************************/ + +#include +#include +#include + +#include +#include + +namespace vku { + +std::vector> custom_stype_info{}; + +struct ASGeomKHRExtraData { + ASGeomKHRExtraData(uint8_t* alloc, uint32_t primOffset, uint32_t primCount) + : ptr(alloc), primitiveOffset(primOffset), primitiveCount(primCount) {} + ~ASGeomKHRExtraData() { + if (ptr) delete[] ptr; + } + uint8_t* ptr; + uint32_t primitiveOffset; + uint32_t primitiveCount; +}; + +vku::concurrent::unordered_map as_geom_khr_host_alloc; + +safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR( + const VkAccelerationStructureGeometryKHR* in_struct, const bool is_host, + const VkAccelerationStructureBuildRangeInfoKHR* build_range_info, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), geometryType(in_struct->geometryType), geometry(in_struct->geometry), flags(in_struct->flags) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (is_host && geometryType == VK_GEOMETRY_TYPE_INSTANCES_KHR) { + if (geometry.instances.arrayOfPointers) { + size_t pp_array_size = build_range_info->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*); + size_t p_array_size = build_range_info->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); + size_t array_size = build_range_info->primitiveOffset + pp_array_size + p_array_size; + uint8_t* allocation = new uint8_t[array_size]; + VkAccelerationStructureInstanceKHR** ppInstances = + reinterpret_cast(allocation + build_range_info->primitiveOffset); + VkAccelerationStructureInstanceKHR* pInstances = reinterpret_cast( + allocation + build_range_info->primitiveOffset + pp_array_size); + for (uint32_t i = 0; i < build_range_info->primitiveCount; ++i) { + const uint8_t* byte_ptr = reinterpret_cast(in_struct->geometry.instances.data.hostAddress); + pInstances[i] = *( + reinterpret_cast(byte_ptr + build_range_info->primitiveOffset)[i]); + ppInstances[i] = &pInstances[i]; + } + geometry.instances.data.hostAddress = allocation; + as_geom_khr_host_alloc.insert( + this, new ASGeomKHRExtraData(allocation, build_range_info->primitiveOffset, build_range_info->primitiveCount)); + } else { + const auto primitive_offset = build_range_info->primitiveOffset; + const auto primitive_count = build_range_info->primitiveCount; + size_t array_size = primitive_offset + primitive_count * sizeof(VkAccelerationStructureInstanceKHR); + uint8_t* allocation = new uint8_t[array_size]; + auto host_address = static_cast(in_struct->geometry.instances.data.hostAddress); + memcpy(allocation + primitive_offset, host_address + primitive_offset, + primitive_count * sizeof(VkAccelerationStructureInstanceKHR)); + geometry.instances.data.hostAddress = allocation; + as_geom_khr_host_alloc.insert( + this, new ASGeomKHRExtraData(allocation, build_range_info->primitiveOffset, build_range_info->primitiveCount)); + } + } +} + +safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR), pNext(nullptr), geometryType(), geometry(), flags() {} + +safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR( + const safe_VkAccelerationStructureGeometryKHR& copy_src) { + sType = copy_src.sType; + geometryType = copy_src.geometryType; + geometry = copy_src.geometry; + flags = copy_src.flags; + + pNext = SafePnextCopy(copy_src.pNext); + auto src_iter = as_geom_khr_host_alloc.find(©_src); + if (src_iter != as_geom_khr_host_alloc.end()) { + auto& src_alloc = src_iter->second; + if (geometry.instances.arrayOfPointers) { + size_t pp_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*); + size_t p_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); + size_t array_size = src_alloc->primitiveOffset + pp_array_size + p_array_size; + uint8_t* allocation = new uint8_t[array_size]; + VkAccelerationStructureInstanceKHR** ppInstances = + reinterpret_cast(allocation + src_alloc->primitiveOffset); + VkAccelerationStructureInstanceKHR* pInstances = + reinterpret_cast(allocation + src_alloc->primitiveOffset + pp_array_size); + for (uint32_t i = 0; i < src_alloc->primitiveCount; ++i) { + pInstances[i] = + *(reinterpret_cast(src_alloc->ptr + src_alloc->primitiveOffset)[i]); + ppInstances[i] = &pInstances[i]; + } + geometry.instances.data.hostAddress = allocation; + as_geom_khr_host_alloc.insert( + this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount)); + } else { + size_t array_size = src_alloc->primitiveOffset + src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); + uint8_t* allocation = new uint8_t[array_size]; + memcpy(allocation, src_alloc->ptr, array_size); + geometry.instances.data.hostAddress = allocation; + as_geom_khr_host_alloc.insert( + this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount)); + } + } +} + +safe_VkAccelerationStructureGeometryKHR& safe_VkAccelerationStructureGeometryKHR::operator=( + const safe_VkAccelerationStructureGeometryKHR& copy_src) { + if (©_src == this) return *this; + + auto iter = as_geom_khr_host_alloc.pop(this); + if (iter != as_geom_khr_host_alloc.end()) { + delete iter->second; + } + FreePnextChain(pNext); + + sType = copy_src.sType; + geometryType = copy_src.geometryType; + geometry = copy_src.geometry; + flags = copy_src.flags; + + pNext = SafePnextCopy(copy_src.pNext); + auto src_iter = as_geom_khr_host_alloc.find(©_src); + if (src_iter != as_geom_khr_host_alloc.end()) { + auto& src_alloc = src_iter->second; + if (geometry.instances.arrayOfPointers) { + size_t pp_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*); + size_t p_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); + size_t array_size = src_alloc->primitiveOffset + pp_array_size + p_array_size; + uint8_t* allocation = new uint8_t[array_size]; + VkAccelerationStructureInstanceKHR** ppInstances = + reinterpret_cast(allocation + src_alloc->primitiveOffset); + VkAccelerationStructureInstanceKHR* pInstances = + reinterpret_cast(allocation + src_alloc->primitiveOffset + pp_array_size); + for (uint32_t i = 0; i < src_alloc->primitiveCount; ++i) { + pInstances[i] = + *(reinterpret_cast(src_alloc->ptr + src_alloc->primitiveOffset)[i]); + ppInstances[i] = &pInstances[i]; + } + geometry.instances.data.hostAddress = allocation; + as_geom_khr_host_alloc.insert( + this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount)); + } else { + size_t array_size = src_alloc->primitiveOffset + src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); + uint8_t* allocation = new uint8_t[array_size]; + memcpy(allocation, src_alloc->ptr, array_size); + geometry.instances.data.hostAddress = allocation; + as_geom_khr_host_alloc.insert( + this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount)); + } + } + + return *this; +} + +safe_VkAccelerationStructureGeometryKHR::~safe_VkAccelerationStructureGeometryKHR() { + auto iter = as_geom_khr_host_alloc.pop(this); + if (iter != as_geom_khr_host_alloc.end()) { + delete iter->second; + } + FreePnextChain(pNext); +} + +void safe_VkAccelerationStructureGeometryKHR::initialize(const VkAccelerationStructureGeometryKHR* in_struct, const bool is_host, + const VkAccelerationStructureBuildRangeInfoKHR* build_range_info, + [[maybe_unused]] PNextCopyState* copy_state) { + auto iter = as_geom_khr_host_alloc.pop(this); + if (iter != as_geom_khr_host_alloc.end()) { + delete iter->second; + } + FreePnextChain(pNext); + sType = in_struct->sType; + geometryType = in_struct->geometryType; + geometry = in_struct->geometry; + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (is_host && geometryType == VK_GEOMETRY_TYPE_INSTANCES_KHR) { + if (geometry.instances.arrayOfPointers) { + size_t pp_array_size = build_range_info->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*); + size_t p_array_size = build_range_info->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); + size_t array_size = build_range_info->primitiveOffset + pp_array_size + p_array_size; + uint8_t* allocation = new uint8_t[array_size]; + VkAccelerationStructureInstanceKHR** ppInstances = + reinterpret_cast(allocation + build_range_info->primitiveOffset); + VkAccelerationStructureInstanceKHR* pInstances = reinterpret_cast( + allocation + build_range_info->primitiveOffset + pp_array_size); + for (uint32_t i = 0; i < build_range_info->primitiveCount; ++i) { + const uint8_t* byte_ptr = reinterpret_cast(in_struct->geometry.instances.data.hostAddress); + pInstances[i] = *( + reinterpret_cast(byte_ptr + build_range_info->primitiveOffset)[i]); + ppInstances[i] = &pInstances[i]; + } + geometry.instances.data.hostAddress = allocation; + as_geom_khr_host_alloc.insert( + this, new ASGeomKHRExtraData(allocation, build_range_info->primitiveOffset, build_range_info->primitiveCount)); + } else { + const auto primitive_offset = build_range_info->primitiveOffset; + const auto primitive_count = build_range_info->primitiveCount; + size_t array_size = primitive_offset + primitive_count * sizeof(VkAccelerationStructureInstanceKHR); + uint8_t* allocation = new uint8_t[array_size]; + auto host_address = static_cast(in_struct->geometry.instances.data.hostAddress); + memcpy(allocation + primitive_offset, host_address + primitive_offset, + primitive_count * sizeof(VkAccelerationStructureInstanceKHR)); + geometry.instances.data.hostAddress = allocation; + as_geom_khr_host_alloc.insert( + this, new ASGeomKHRExtraData(allocation, build_range_info->primitiveOffset, build_range_info->primitiveCount)); + } + } +} + +void safe_VkAccelerationStructureGeometryKHR::initialize(const safe_VkAccelerationStructureGeometryKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + geometryType = copy_src->geometryType; + geometry = copy_src->geometry; + flags = copy_src->flags; + + pNext = SafePnextCopy(copy_src->pNext); + auto src_iter = as_geom_khr_host_alloc.find(copy_src); + if (src_iter != as_geom_khr_host_alloc.end()) { + auto& src_alloc = src_iter->second; + if (geometry.instances.arrayOfPointers) { + size_t pp_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*); + size_t p_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); + size_t array_size = src_alloc->primitiveOffset + pp_array_size + p_array_size; + uint8_t* allocation = new uint8_t[array_size]; + VkAccelerationStructureInstanceKHR** ppInstances = + reinterpret_cast(allocation + src_alloc->primitiveOffset); + VkAccelerationStructureInstanceKHR* pInstances = + reinterpret_cast(allocation + src_alloc->primitiveOffset + pp_array_size); + for (uint32_t i = 0; i < src_alloc->primitiveCount; ++i) { + pInstances[i] = + *(reinterpret_cast(src_alloc->ptr + src_alloc->primitiveOffset)[i]); + ppInstances[i] = &pInstances[i]; + } + geometry.instances.data.hostAddress = allocation; + as_geom_khr_host_alloc.insert( + this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount)); + } else { + size_t array_size = src_alloc->primitiveOffset + src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR); + uint8_t* allocation = new uint8_t[array_size]; + memcpy(allocation, src_alloc->ptr, array_size); + geometry.instances.data.hostAddress = allocation; + as_geom_khr_host_alloc.insert( + this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount)); + } + } +} + +void safe_VkRayTracingPipelineCreateInfoCommon::initialize(const VkRayTracingPipelineCreateInfoNV* pCreateInfo) { + safe_VkRayTracingPipelineCreateInfoNV nvStruct; + nvStruct.initialize(pCreateInfo); + + sType = nvStruct.sType; + + // Take ownership of the pointer and null it out in nvStruct + pNext = nvStruct.pNext; + nvStruct.pNext = nullptr; + + flags = nvStruct.flags; + stageCount = nvStruct.stageCount; + + pStages = nvStruct.pStages; + nvStruct.pStages = nullptr; + + groupCount = nvStruct.groupCount; + maxRecursionDepth = nvStruct.maxRecursionDepth; + layout = nvStruct.layout; + basePipelineHandle = nvStruct.basePipelineHandle; + basePipelineIndex = nvStruct.basePipelineIndex; + + assert(pGroups == nullptr); + if (nvStruct.groupCount && nvStruct.pGroups) { + pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount]; + for (uint32_t i = 0; i < groupCount; ++i) { + pGroups[i].sType = nvStruct.pGroups[i].sType; + pGroups[i].pNext = nvStruct.pGroups[i].pNext; + pGroups[i].type = nvStruct.pGroups[i].type; + pGroups[i].generalShader = nvStruct.pGroups[i].generalShader; + pGroups[i].closestHitShader = nvStruct.pGroups[i].closestHitShader; + pGroups[i].anyHitShader = nvStruct.pGroups[i].anyHitShader; + pGroups[i].intersectionShader = nvStruct.pGroups[i].intersectionShader; + pGroups[i].intersectionShader = nvStruct.pGroups[i].intersectionShader; + pGroups[i].pShaderGroupCaptureReplayHandle = nullptr; + } + } +} + +void safe_VkRayTracingPipelineCreateInfoCommon::initialize(const VkRayTracingPipelineCreateInfoKHR* pCreateInfo) { + safe_VkRayTracingPipelineCreateInfoKHR::initialize(pCreateInfo); +} + +safe_VkDescriptorDataEXT::safe_VkDescriptorDataEXT(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type, + [[maybe_unused]] PNextCopyState* copy_state) { + VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)]; + + switch (type) { + case VK_DESCRIPTOR_TYPE_MAX_ENUM: + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + break; + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + break; + case VK_DESCRIPTOR_TYPE_SAMPLER: + pSampler = new VkSampler(*in_struct->pSampler); + break; + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + pCombinedImageSampler = new VkDescriptorImageInfo(*in_struct->pCombinedImageSampler); + break; + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + pSampledImage = in_struct->pSampledImage ? new VkDescriptorImageInfo(*in_struct->pSampledImage) : nullptr; + break; + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + pStorageImage = in_struct->pStorageImage ? new VkDescriptorImageInfo(*in_struct->pStorageImage) : nullptr; + break; + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + pInputAttachmentImage = new VkDescriptorImageInfo(*in_struct->pInputAttachmentImage); + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + pUniformTexelBuffer = + in_struct->pUniformTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformTexelBuffer) : nullptr; + break; + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + pStorageTexelBuffer = + in_struct->pStorageTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageTexelBuffer) : nullptr; + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + pUniformBuffer = in_struct->pUniformBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformBuffer) : nullptr; + break; + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + pStorageBuffer = in_struct->pStorageBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageBuffer) : nullptr; + break; + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: + accelerationStructure = in_struct->accelerationStructure; + break; + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV: + accelerationStructure = in_struct->accelerationStructure; + break; + default: + break; + } + + *pType = type; +} + +safe_VkDescriptorDataEXT::safe_VkDescriptorDataEXT() : type_at_end{0} { + VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)]; + *pType = VK_DESCRIPTOR_TYPE_MAX_ENUM; +} + +safe_VkDescriptorDataEXT::safe_VkDescriptorDataEXT(const safe_VkDescriptorDataEXT& copy_src) { + pSampler = nullptr; + pCombinedImageSampler = nullptr; + pInputAttachmentImage = nullptr; + pSampledImage = nullptr; + pStorageImage = nullptr; + pUniformTexelBuffer = nullptr; + pStorageTexelBuffer = nullptr; + pUniformBuffer = nullptr; + pStorageBuffer = nullptr; + accelerationStructure = copy_src.accelerationStructure; + + VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)]; + VkDescriptorType type = *(VkDescriptorType*)©_src.type_at_end[sizeof(VkDescriptorDataEXT)]; + + switch (type) { + case VK_DESCRIPTOR_TYPE_MAX_ENUM: + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + break; + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + break; + case VK_DESCRIPTOR_TYPE_SAMPLER: + pSampler = new VkSampler(*copy_src.pSampler); + break; + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + pCombinedImageSampler = new VkDescriptorImageInfo(*copy_src.pCombinedImageSampler); + break; + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + pSampledImage = new VkDescriptorImageInfo(*copy_src.pSampledImage); + break; + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + pStorageImage = new VkDescriptorImageInfo(*copy_src.pStorageImage); + break; + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + pInputAttachmentImage = new VkDescriptorImageInfo(*copy_src.pInputAttachmentImage); + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + pUniformTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformTexelBuffer); + break; + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + pStorageTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageTexelBuffer); + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + pUniformBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformBuffer); + break; + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + pStorageBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageBuffer); + break; + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: + accelerationStructure = copy_src.accelerationStructure; + break; + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV: + accelerationStructure = copy_src.accelerationStructure; + break; + default: + break; + } + + *pType = type; +} + +safe_VkDescriptorDataEXT& safe_VkDescriptorDataEXT::operator=(const safe_VkDescriptorDataEXT& copy_src) { + if (©_src == this) return *this; + + VkDescriptorType& thisType = *(VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)]; + + switch (thisType) { + case VK_DESCRIPTOR_TYPE_MAX_ENUM: + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + break; + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + break; + case VK_DESCRIPTOR_TYPE_SAMPLER: + delete pSampler; + pSampler = nullptr; + break; + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + delete pCombinedImageSampler; + pCombinedImageSampler = nullptr; + break; + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + delete pSampledImage; + pSampledImage = nullptr; + break; + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + delete pStorageImage; + pStorageImage = nullptr; + break; + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + delete pInputAttachmentImage; + pInputAttachmentImage = nullptr; + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + delete pUniformTexelBuffer; + pUniformTexelBuffer = nullptr; + break; + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + delete pStorageTexelBuffer; + pStorageTexelBuffer = nullptr; + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + delete pUniformBuffer; + pUniformBuffer = nullptr; + break; + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + delete pStorageBuffer; + pStorageBuffer = nullptr; + break; + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: + accelerationStructure = 0ull; + break; + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV: + accelerationStructure = 0ull; + break; + default: + break; + } + + thisType = VK_DESCRIPTOR_TYPE_MAX_ENUM; + + pSampler = nullptr; + pCombinedImageSampler = nullptr; + pInputAttachmentImage = nullptr; + pSampledImage = nullptr; + pStorageImage = nullptr; + pUniformTexelBuffer = nullptr; + pStorageTexelBuffer = nullptr; + pUniformBuffer = nullptr; + pStorageBuffer = nullptr; + accelerationStructure = copy_src.accelerationStructure; + + VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)]; + VkDescriptorType type = *(VkDescriptorType*)©_src.type_at_end[sizeof(VkDescriptorDataEXT)]; + + switch (type) { + case VK_DESCRIPTOR_TYPE_MAX_ENUM: + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + break; + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + break; + case VK_DESCRIPTOR_TYPE_SAMPLER: + pSampler = new VkSampler(*copy_src.pSampler); + break; + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + pCombinedImageSampler = new VkDescriptorImageInfo(*copy_src.pCombinedImageSampler); + break; + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + pSampledImage = new VkDescriptorImageInfo(*copy_src.pSampledImage); + break; + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + pStorageImage = new VkDescriptorImageInfo(*copy_src.pStorageImage); + break; + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + pInputAttachmentImage = new VkDescriptorImageInfo(*copy_src.pInputAttachmentImage); + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + pUniformTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformTexelBuffer); + break; + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + pStorageTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageTexelBuffer); + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + pUniformBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformBuffer); + break; + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + pStorageBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageBuffer); + break; + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: + accelerationStructure = copy_src.accelerationStructure; + break; + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV: + accelerationStructure = copy_src.accelerationStructure; + break; + default: + break; + } + + *pType = type; + + return *this; +} + +safe_VkDescriptorDataEXT::~safe_VkDescriptorDataEXT() { + VkDescriptorType& thisType = *(VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)]; + + switch (thisType) { + case VK_DESCRIPTOR_TYPE_MAX_ENUM: + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + break; + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + break; + case VK_DESCRIPTOR_TYPE_SAMPLER: + delete pSampler; + pSampler = nullptr; + break; + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + delete pCombinedImageSampler; + pCombinedImageSampler = nullptr; + break; + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + delete pSampledImage; + pSampledImage = nullptr; + break; + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + delete pStorageImage; + pStorageImage = nullptr; + break; + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + delete pInputAttachmentImage; + pInputAttachmentImage = nullptr; + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + delete pUniformTexelBuffer; + pUniformTexelBuffer = nullptr; + break; + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + delete pStorageTexelBuffer; + pStorageTexelBuffer = nullptr; + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + delete pUniformBuffer; + pUniformBuffer = nullptr; + break; + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + delete pStorageBuffer; + pStorageBuffer = nullptr; + break; + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: + accelerationStructure = 0ull; + break; + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV: + accelerationStructure = 0ull; + break; + default: + break; + } + + thisType = VK_DESCRIPTOR_TYPE_MAX_ENUM; +} + +void safe_VkDescriptorDataEXT::initialize(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type, + [[maybe_unused]] PNextCopyState* copy_state) { + VkDescriptorType& thisType = *(VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)]; + + switch (thisType) { + case VK_DESCRIPTOR_TYPE_MAX_ENUM: + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + break; + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + break; + case VK_DESCRIPTOR_TYPE_SAMPLER: + delete pSampler; + pSampler = nullptr; + break; + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + delete pCombinedImageSampler; + pCombinedImageSampler = nullptr; + break; + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + delete pSampledImage; + pSampledImage = nullptr; + break; + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + delete pStorageImage; + pStorageImage = nullptr; + break; + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + delete pInputAttachmentImage; + pInputAttachmentImage = nullptr; + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + delete pUniformTexelBuffer; + pUniformTexelBuffer = nullptr; + break; + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + delete pStorageTexelBuffer; + pStorageTexelBuffer = nullptr; + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + delete pUniformBuffer; + pUniformBuffer = nullptr; + break; + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + delete pStorageBuffer; + pStorageBuffer = nullptr; + break; + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: + accelerationStructure = 0ull; + break; + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV: + accelerationStructure = 0ull; + break; + default: + break; + } + + thisType = VK_DESCRIPTOR_TYPE_MAX_ENUM; + pSampler = nullptr; + pCombinedImageSampler = nullptr; + pInputAttachmentImage = nullptr; + pSampledImage = nullptr; + pStorageImage = nullptr; + pUniformTexelBuffer = nullptr; + pStorageTexelBuffer = nullptr; + pUniformBuffer = nullptr; + pStorageBuffer = nullptr; + accelerationStructure = in_struct->accelerationStructure; + + VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)]; + + switch (type) { + case VK_DESCRIPTOR_TYPE_MAX_ENUM: + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + break; + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + break; + case VK_DESCRIPTOR_TYPE_SAMPLER: + pSampler = new VkSampler(*in_struct->pSampler); + break; + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + pCombinedImageSampler = new VkDescriptorImageInfo(*in_struct->pCombinedImageSampler); + break; + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + pSampledImage = in_struct->pSampledImage ? new VkDescriptorImageInfo(*in_struct->pSampledImage) : nullptr; + break; + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + pStorageImage = in_struct->pStorageImage ? new VkDescriptorImageInfo(*in_struct->pStorageImage) : nullptr; + break; + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + pInputAttachmentImage = new VkDescriptorImageInfo(*in_struct->pInputAttachmentImage); + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + pUniformTexelBuffer = + in_struct->pUniformTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformTexelBuffer) : nullptr; + break; + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + pStorageTexelBuffer = + in_struct->pStorageTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageTexelBuffer) : nullptr; + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + pUniformBuffer = in_struct->pUniformBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformBuffer) : nullptr; + break; + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + pStorageBuffer = in_struct->pStorageBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageBuffer) : nullptr; + break; + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: + accelerationStructure = in_struct->accelerationStructure; + break; + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV: + accelerationStructure = in_struct->accelerationStructure; + break; + default: + break; + } + + *pType = type; +} + +void safe_VkDescriptorDataEXT::initialize(const safe_VkDescriptorDataEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + pSampler = nullptr; + pCombinedImageSampler = nullptr; + pInputAttachmentImage = nullptr; + pSampledImage = nullptr; + pStorageImage = nullptr; + pUniformTexelBuffer = nullptr; + pStorageTexelBuffer = nullptr; + pUniformBuffer = nullptr; + pStorageBuffer = nullptr; + accelerationStructure = copy_src->accelerationStructure; + + VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)]; + VkDescriptorType type = *(VkDescriptorType*)©_src->type_at_end[sizeof(VkDescriptorDataEXT)]; + + switch (type) { + case VK_DESCRIPTOR_TYPE_MAX_ENUM: + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + break; + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + break; + case VK_DESCRIPTOR_TYPE_SAMPLER: + pSampler = new VkSampler(*copy_src->pSampler); + break; + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + pCombinedImageSampler = new VkDescriptorImageInfo(*copy_src->pCombinedImageSampler); + break; + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + pSampledImage = new VkDescriptorImageInfo(*copy_src->pSampledImage); + break; + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + pStorageImage = new VkDescriptorImageInfo(*copy_src->pStorageImage); + break; + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + pInputAttachmentImage = new VkDescriptorImageInfo(*copy_src->pInputAttachmentImage); + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + pUniformTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pUniformTexelBuffer); + break; + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + pStorageTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pStorageTexelBuffer); + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + pUniformBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pUniformBuffer); + break; + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + pStorageBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pStorageBuffer); + break; + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: + accelerationStructure = copy_src->accelerationStructure; + break; + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV: + accelerationStructure = copy_src->accelerationStructure; + break; + default: + break; + } + + *pType = type; +} + +safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo* in_struct, + const bool uses_color_attachment, + const bool uses_depthstencil_attachment, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + stageCount(in_struct->stageCount), + pStages(nullptr), + pVertexInputState(nullptr), + pInputAssemblyState(nullptr), + pTessellationState(nullptr), + pViewportState(nullptr), + pRasterizationState(nullptr), + pMultisampleState(nullptr), + pDepthStencilState(nullptr), + pColorBlendState(nullptr), + pDynamicState(nullptr), + layout(in_struct->layout), + renderPass(in_struct->renderPass), + subpass(in_struct->subpass), + basePipelineHandle(in_struct->basePipelineHandle), + basePipelineIndex(in_struct->basePipelineIndex) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + const bool is_graphics_library = + vku::FindStructInPNextChain(in_struct->pNext) != nullptr; + if (stageCount && in_struct->pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(&in_struct->pStages[i]); + } + } + if (in_struct->pVertexInputState) + pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(in_struct->pVertexInputState); + else + pVertexInputState = nullptr; + if (in_struct->pInputAssemblyState) + pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(in_struct->pInputAssemblyState); + else + pInputAssemblyState = nullptr; + bool has_tessellation_stage = false; + if (stageCount && pStages) + for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i) + if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || + pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) + has_tessellation_stage = true; + if (in_struct->pTessellationState && has_tessellation_stage) + pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState); + else + pTessellationState = nullptr; // original pTessellationState pointer ignored + bool is_dynamic_has_rasterization = false; + if (in_struct->pDynamicState && in_struct->pDynamicState->pDynamicStates) { + for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_has_rasterization; ++i) + if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT) + is_dynamic_has_rasterization = true; + } + const bool has_rasterization = in_struct->pRasterizationState + ? (is_dynamic_has_rasterization || !in_struct->pRasterizationState->rasterizerDiscardEnable) + : false; + if (in_struct->pViewportState && (has_rasterization || is_graphics_library)) { + bool is_dynamic_viewports = false; + bool is_dynamic_scissors = false; + if (in_struct->pDynamicState && in_struct->pDynamicState->pDynamicStates) { + for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_viewports; ++i) + if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_VIEWPORT) is_dynamic_viewports = true; + for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_scissors; ++i) + if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_SCISSOR) is_dynamic_scissors = true; + } + pViewportState = + new safe_VkPipelineViewportStateCreateInfo(in_struct->pViewportState, is_dynamic_viewports, is_dynamic_scissors); + } else + pViewportState = nullptr; // original pViewportState pointer ignored + if (in_struct->pRasterizationState) + pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(in_struct->pRasterizationState); + else + pRasterizationState = nullptr; + if (in_struct->pMultisampleState && (renderPass != VK_NULL_HANDLE || has_rasterization || is_graphics_library)) + pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(in_struct->pMultisampleState); + else + pMultisampleState = nullptr; // original pMultisampleState pointer ignored + // needs a tracked subpass state uses_depthstencil_attachment + if (in_struct->pDepthStencilState && ((has_rasterization && uses_depthstencil_attachment) || is_graphics_library)) + pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(in_struct->pDepthStencilState); + else + pDepthStencilState = nullptr; // original pDepthStencilState pointer ignored + // needs a tracked subpass state usesColorAttachment + if (in_struct->pColorBlendState && ((has_rasterization && uses_color_attachment) || is_graphics_library)) + pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(in_struct->pColorBlendState); + else + pColorBlendState = nullptr; // original pColorBlendState pointer ignored + if (in_struct->pDynamicState) + pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(in_struct->pDynamicState); + else + pDynamicState = nullptr; +} + +safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo() + : sType(VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO), + pNext(nullptr), + flags(), + stageCount(), + pStages(nullptr), + pVertexInputState(nullptr), + pInputAssemblyState(nullptr), + pTessellationState(nullptr), + pViewportState(nullptr), + pRasterizationState(nullptr), + pMultisampleState(nullptr), + pDepthStencilState(nullptr), + pColorBlendState(nullptr), + pDynamicState(nullptr), + layout(), + renderPass(), + subpass(), + basePipelineHandle(), + basePipelineIndex() {} + +safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const safe_VkGraphicsPipelineCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + stageCount = copy_src.stageCount; + pStages = nullptr; + pVertexInputState = nullptr; + pInputAssemblyState = nullptr; + pTessellationState = nullptr; + pViewportState = nullptr; + pRasterizationState = nullptr; + pMultisampleState = nullptr; + pDepthStencilState = nullptr; + pColorBlendState = nullptr; + pDynamicState = nullptr; + layout = copy_src.layout; + renderPass = copy_src.renderPass; + subpass = copy_src.subpass; + basePipelineHandle = copy_src.basePipelineHandle; + basePipelineIndex = copy_src.basePipelineIndex; + + pNext = SafePnextCopy(copy_src.pNext); + const bool is_graphics_library = vku::FindStructInPNextChain(copy_src.pNext); + if (stageCount && copy_src.pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(©_src.pStages[i]); + } + } + if (copy_src.pVertexInputState) + pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*copy_src.pVertexInputState); + else + pVertexInputState = nullptr; + if (copy_src.pInputAssemblyState) + pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(*copy_src.pInputAssemblyState); + else + pInputAssemblyState = nullptr; + bool has_tessellation_stage = false; + if (stageCount && pStages) + for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i) + if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || + pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) + has_tessellation_stage = true; + if (copy_src.pTessellationState && has_tessellation_stage) + pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*copy_src.pTessellationState); + else + pTessellationState = nullptr; // original pTessellationState pointer ignored + bool is_dynamic_has_rasterization = false; + if (copy_src.pDynamicState && copy_src.pDynamicState->pDynamicStates) { + for (uint32_t i = 0; i < copy_src.pDynamicState->dynamicStateCount && !is_dynamic_has_rasterization; ++i) + if (copy_src.pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT) + is_dynamic_has_rasterization = true; + } + const bool has_rasterization = copy_src.pRasterizationState + ? (is_dynamic_has_rasterization || !copy_src.pRasterizationState->rasterizerDiscardEnable) + : false; + if (copy_src.pViewportState && (has_rasterization || is_graphics_library)) { + pViewportState = new safe_VkPipelineViewportStateCreateInfo(*copy_src.pViewportState); + } else + pViewportState = nullptr; // original pViewportState pointer ignored + if (copy_src.pRasterizationState) + pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(*copy_src.pRasterizationState); + else + pRasterizationState = nullptr; + if (copy_src.pMultisampleState && (has_rasterization || is_graphics_library)) + pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(*copy_src.pMultisampleState); + else + pMultisampleState = nullptr; // original pMultisampleState pointer ignored + if (copy_src.pDepthStencilState && (has_rasterization || is_graphics_library)) + pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(*copy_src.pDepthStencilState); + else + pDepthStencilState = nullptr; // original pDepthStencilState pointer ignored + if (copy_src.pColorBlendState && (has_rasterization || is_graphics_library)) + pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(*copy_src.pColorBlendState); + else + pColorBlendState = nullptr; // original pColorBlendState pointer ignored + if (copy_src.pDynamicState) + pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*copy_src.pDynamicState); + else + pDynamicState = nullptr; +} + +safe_VkGraphicsPipelineCreateInfo& safe_VkGraphicsPipelineCreateInfo::operator=(const safe_VkGraphicsPipelineCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pStages) delete[] pStages; + if (pVertexInputState) delete pVertexInputState; + if (pInputAssemblyState) delete pInputAssemblyState; + if (pTessellationState) delete pTessellationState; + if (pViewportState) delete pViewportState; + if (pRasterizationState) delete pRasterizationState; + if (pMultisampleState) delete pMultisampleState; + if (pDepthStencilState) delete pDepthStencilState; + if (pColorBlendState) delete pColorBlendState; + if (pDynamicState) delete pDynamicState; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + stageCount = copy_src.stageCount; + pStages = nullptr; + pVertexInputState = nullptr; + pInputAssemblyState = nullptr; + pTessellationState = nullptr; + pViewportState = nullptr; + pRasterizationState = nullptr; + pMultisampleState = nullptr; + pDepthStencilState = nullptr; + pColorBlendState = nullptr; + pDynamicState = nullptr; + layout = copy_src.layout; + renderPass = copy_src.renderPass; + subpass = copy_src.subpass; + basePipelineHandle = copy_src.basePipelineHandle; + basePipelineIndex = copy_src.basePipelineIndex; + + pNext = SafePnextCopy(copy_src.pNext); + const bool is_graphics_library = vku::FindStructInPNextChain(copy_src.pNext); + if (stageCount && copy_src.pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(©_src.pStages[i]); + } + } + if (copy_src.pVertexInputState) + pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*copy_src.pVertexInputState); + else + pVertexInputState = nullptr; + if (copy_src.pInputAssemblyState) + pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(*copy_src.pInputAssemblyState); + else + pInputAssemblyState = nullptr; + bool has_tessellation_stage = false; + if (stageCount && pStages) + for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i) + if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || + pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) + has_tessellation_stage = true; + if (copy_src.pTessellationState && has_tessellation_stage) + pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*copy_src.pTessellationState); + else + pTessellationState = nullptr; // original pTessellationState pointer ignored + bool is_dynamic_has_rasterization = false; + if (copy_src.pDynamicState && copy_src.pDynamicState->pDynamicStates) { + for (uint32_t i = 0; i < copy_src.pDynamicState->dynamicStateCount && !is_dynamic_has_rasterization; ++i) + if (copy_src.pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT) + is_dynamic_has_rasterization = true; + } + const bool has_rasterization = copy_src.pRasterizationState + ? (is_dynamic_has_rasterization || !copy_src.pRasterizationState->rasterizerDiscardEnable) + : false; + if (copy_src.pViewportState && (has_rasterization || is_graphics_library)) { + pViewportState = new safe_VkPipelineViewportStateCreateInfo(*copy_src.pViewportState); + } else + pViewportState = nullptr; // original pViewportState pointer ignored + if (copy_src.pRasterizationState) + pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(*copy_src.pRasterizationState); + else + pRasterizationState = nullptr; + if (copy_src.pMultisampleState && (has_rasterization || is_graphics_library)) + pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(*copy_src.pMultisampleState); + else + pMultisampleState = nullptr; // original pMultisampleState pointer ignored + if (copy_src.pDepthStencilState && (has_rasterization || is_graphics_library)) + pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(*copy_src.pDepthStencilState); + else + pDepthStencilState = nullptr; // original pDepthStencilState pointer ignored + if (copy_src.pColorBlendState && (has_rasterization || is_graphics_library)) + pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(*copy_src.pColorBlendState); + else + pColorBlendState = nullptr; // original pColorBlendState pointer ignored + if (copy_src.pDynamicState) + pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*copy_src.pDynamicState); + else + pDynamicState = nullptr; + + return *this; +} + +safe_VkGraphicsPipelineCreateInfo::~safe_VkGraphicsPipelineCreateInfo() { + if (pStages) delete[] pStages; + if (pVertexInputState) delete pVertexInputState; + if (pInputAssemblyState) delete pInputAssemblyState; + if (pTessellationState) delete pTessellationState; + if (pViewportState) delete pViewportState; + if (pRasterizationState) delete pRasterizationState; + if (pMultisampleState) delete pMultisampleState; + if (pDepthStencilState) delete pDepthStencilState; + if (pColorBlendState) delete pColorBlendState; + if (pDynamicState) delete pDynamicState; + FreePnextChain(pNext); +} + +void safe_VkGraphicsPipelineCreateInfo::initialize(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment, + const bool uses_depthstencil_attachment, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStages) delete[] pStages; + if (pVertexInputState) delete pVertexInputState; + if (pInputAssemblyState) delete pInputAssemblyState; + if (pTessellationState) delete pTessellationState; + if (pViewportState) delete pViewportState; + if (pRasterizationState) delete pRasterizationState; + if (pMultisampleState) delete pMultisampleState; + if (pDepthStencilState) delete pDepthStencilState; + if (pColorBlendState) delete pColorBlendState; + if (pDynamicState) delete pDynamicState; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + stageCount = in_struct->stageCount; + pStages = nullptr; + pVertexInputState = nullptr; + pInputAssemblyState = nullptr; + pTessellationState = nullptr; + pViewportState = nullptr; + pRasterizationState = nullptr; + pMultisampleState = nullptr; + pDepthStencilState = nullptr; + pColorBlendState = nullptr; + pDynamicState = nullptr; + layout = in_struct->layout; + renderPass = in_struct->renderPass; + subpass = in_struct->subpass; + basePipelineHandle = in_struct->basePipelineHandle; + basePipelineIndex = in_struct->basePipelineIndex; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + const bool is_graphics_library = + vku::FindStructInPNextChain(in_struct->pNext) != nullptr; + if (stageCount && in_struct->pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(&in_struct->pStages[i]); + } + } + if (in_struct->pVertexInputState) + pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(in_struct->pVertexInputState); + else + pVertexInputState = nullptr; + if (in_struct->pInputAssemblyState) + pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(in_struct->pInputAssemblyState); + else + pInputAssemblyState = nullptr; + bool has_tessellation_stage = false; + if (stageCount && pStages) + for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i) + if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || + pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) + has_tessellation_stage = true; + if (in_struct->pTessellationState && has_tessellation_stage) + pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState); + else + pTessellationState = nullptr; // original pTessellationState pointer ignored + bool is_dynamic_has_rasterization = false; + if (in_struct->pDynamicState && in_struct->pDynamicState->pDynamicStates) { + for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_has_rasterization; ++i) + if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT) + is_dynamic_has_rasterization = true; + } + const bool has_rasterization = in_struct->pRasterizationState + ? (is_dynamic_has_rasterization || !in_struct->pRasterizationState->rasterizerDiscardEnable) + : false; + if (in_struct->pViewportState && (has_rasterization || is_graphics_library)) { + bool is_dynamic_viewports = false; + bool is_dynamic_scissors = false; + if (in_struct->pDynamicState && in_struct->pDynamicState->pDynamicStates) { + for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_viewports; ++i) + if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_VIEWPORT) is_dynamic_viewports = true; + for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_scissors; ++i) + if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_SCISSOR) is_dynamic_scissors = true; + } + pViewportState = + new safe_VkPipelineViewportStateCreateInfo(in_struct->pViewportState, is_dynamic_viewports, is_dynamic_scissors); + } else + pViewportState = nullptr; // original pViewportState pointer ignored + if (in_struct->pRasterizationState) + pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(in_struct->pRasterizationState); + else + pRasterizationState = nullptr; + if (in_struct->pMultisampleState && (renderPass != VK_NULL_HANDLE || has_rasterization || is_graphics_library)) + pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(in_struct->pMultisampleState); + else + pMultisampleState = nullptr; // original pMultisampleState pointer ignored + // needs a tracked subpass state uses_depthstencil_attachment + if (in_struct->pDepthStencilState && ((has_rasterization && uses_depthstencil_attachment) || is_graphics_library)) + pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(in_struct->pDepthStencilState); + else + pDepthStencilState = nullptr; // original pDepthStencilState pointer ignored + // needs a tracked subpass state usesColorAttachment + if (in_struct->pColorBlendState && ((has_rasterization && uses_color_attachment) || is_graphics_library)) + pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(in_struct->pColorBlendState); + else + pColorBlendState = nullptr; // original pColorBlendState pointer ignored + if (in_struct->pDynamicState) + pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(in_struct->pDynamicState); + else + pDynamicState = nullptr; +} + +void safe_VkGraphicsPipelineCreateInfo::initialize(const safe_VkGraphicsPipelineCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + stageCount = copy_src->stageCount; + pStages = nullptr; + pVertexInputState = nullptr; + pInputAssemblyState = nullptr; + pTessellationState = nullptr; + pViewportState = nullptr; + pRasterizationState = nullptr; + pMultisampleState = nullptr; + pDepthStencilState = nullptr; + pColorBlendState = nullptr; + pDynamicState = nullptr; + layout = copy_src->layout; + renderPass = copy_src->renderPass; + subpass = copy_src->subpass; + basePipelineHandle = copy_src->basePipelineHandle; + basePipelineIndex = copy_src->basePipelineIndex; + + pNext = SafePnextCopy(copy_src->pNext); + const bool is_graphics_library = vku::FindStructInPNextChain(copy_src->pNext); + if (stageCount && copy_src->pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(©_src->pStages[i]); + } + } + if (copy_src->pVertexInputState) + pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*copy_src->pVertexInputState); + else + pVertexInputState = nullptr; + if (copy_src->pInputAssemblyState) + pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(*copy_src->pInputAssemblyState); + else + pInputAssemblyState = nullptr; + bool has_tessellation_stage = false; + if (stageCount && pStages) + for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i) + if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || + pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) + has_tessellation_stage = true; + if (copy_src->pTessellationState && has_tessellation_stage) + pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*copy_src->pTessellationState); + else + pTessellationState = nullptr; // original pTessellationState pointer ignored + bool is_dynamic_has_rasterization = false; + if (copy_src->pDynamicState && copy_src->pDynamicState->pDynamicStates) { + for (uint32_t i = 0; i < copy_src->pDynamicState->dynamicStateCount && !is_dynamic_has_rasterization; ++i) + if (copy_src->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT) + is_dynamic_has_rasterization = true; + } + const bool has_rasterization = copy_src->pRasterizationState + ? (is_dynamic_has_rasterization || !copy_src->pRasterizationState->rasterizerDiscardEnable) + : false; + if (copy_src->pViewportState && (has_rasterization || is_graphics_library)) { + pViewportState = new safe_VkPipelineViewportStateCreateInfo(*copy_src->pViewportState); + } else + pViewportState = nullptr; // original pViewportState pointer ignored + if (copy_src->pRasterizationState) + pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(*copy_src->pRasterizationState); + else + pRasterizationState = nullptr; + if (copy_src->pMultisampleState && (has_rasterization || is_graphics_library)) + pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(*copy_src->pMultisampleState); + else + pMultisampleState = nullptr; // original pMultisampleState pointer ignored + if (copy_src->pDepthStencilState && (has_rasterization || is_graphics_library)) + pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(*copy_src->pDepthStencilState); + else + pDepthStencilState = nullptr; // original pDepthStencilState pointer ignored + if (copy_src->pColorBlendState && (has_rasterization || is_graphics_library)) + pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(*copy_src->pColorBlendState); + else + pColorBlendState = nullptr; // original pColorBlendState pointer ignored + if (copy_src->pDynamicState) + pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*copy_src->pDynamicState); + else + pDynamicState = nullptr; +} + +safe_VkPipelineViewportStateCreateInfo::safe_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo* in_struct, + const bool is_dynamic_viewports, + const bool is_dynamic_scissors, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + viewportCount(in_struct->viewportCount), + pViewports(nullptr), + scissorCount(in_struct->scissorCount), + pScissors(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pViewports && !is_dynamic_viewports) { + pViewports = new VkViewport[in_struct->viewportCount]; + memcpy((void*)pViewports, (void*)in_struct->pViewports, sizeof(VkViewport) * in_struct->viewportCount); + } else + pViewports = nullptr; + if (in_struct->pScissors && !is_dynamic_scissors) { + pScissors = new VkRect2D[in_struct->scissorCount]; + memcpy((void*)pScissors, (void*)in_struct->pScissors, sizeof(VkRect2D) * in_struct->scissorCount); + } else + pScissors = nullptr; +} + +safe_VkPipelineViewportStateCreateInfo::safe_VkPipelineViewportStateCreateInfo() + : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO), + pNext(nullptr), + flags(), + viewportCount(), + pViewports(nullptr), + scissorCount(), + pScissors(nullptr) {} + +safe_VkPipelineViewportStateCreateInfo::safe_VkPipelineViewportStateCreateInfo( + const safe_VkPipelineViewportStateCreateInfo& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + viewportCount = copy_src.viewportCount; + pViewports = nullptr; + scissorCount = copy_src.scissorCount; + pScissors = nullptr; + + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pViewports) { + pViewports = new VkViewport[copy_src.viewportCount]; + memcpy((void*)pViewports, (void*)copy_src.pViewports, sizeof(VkViewport) * copy_src.viewportCount); + } else + pViewports = nullptr; + if (copy_src.pScissors) { + pScissors = new VkRect2D[copy_src.scissorCount]; + memcpy((void*)pScissors, (void*)copy_src.pScissors, sizeof(VkRect2D) * copy_src.scissorCount); + } else + pScissors = nullptr; +} + +safe_VkPipelineViewportStateCreateInfo& safe_VkPipelineViewportStateCreateInfo::operator=( + const safe_VkPipelineViewportStateCreateInfo& copy_src) { + if (©_src == this) return *this; + + if (pViewports) delete[] pViewports; + if (pScissors) delete[] pScissors; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + viewportCount = copy_src.viewportCount; + pViewports = nullptr; + scissorCount = copy_src.scissorCount; + pScissors = nullptr; + + pNext = SafePnextCopy(copy_src.pNext); + if (copy_src.pViewports) { + pViewports = new VkViewport[copy_src.viewportCount]; + memcpy((void*)pViewports, (void*)copy_src.pViewports, sizeof(VkViewport) * copy_src.viewportCount); + } else + pViewports = nullptr; + if (copy_src.pScissors) { + pScissors = new VkRect2D[copy_src.scissorCount]; + memcpy((void*)pScissors, (void*)copy_src.pScissors, sizeof(VkRect2D) * copy_src.scissorCount); + } else + pScissors = nullptr; + + return *this; +} + +safe_VkPipelineViewportStateCreateInfo::~safe_VkPipelineViewportStateCreateInfo() { + if (pViewports) delete[] pViewports; + if (pScissors) delete[] pScissors; + FreePnextChain(pNext); +} + +void safe_VkPipelineViewportStateCreateInfo::initialize(const VkPipelineViewportStateCreateInfo* in_struct, + const bool is_dynamic_viewports, const bool is_dynamic_scissors, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pViewports) delete[] pViewports; + if (pScissors) delete[] pScissors; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + viewportCount = in_struct->viewportCount; + pViewports = nullptr; + scissorCount = in_struct->scissorCount; + pScissors = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pViewports && !is_dynamic_viewports) { + pViewports = new VkViewport[in_struct->viewportCount]; + memcpy((void*)pViewports, (void*)in_struct->pViewports, sizeof(VkViewport) * in_struct->viewportCount); + } else + pViewports = nullptr; + if (in_struct->pScissors && !is_dynamic_scissors) { + pScissors = new VkRect2D[in_struct->scissorCount]; + memcpy((void*)pScissors, (void*)in_struct->pScissors, sizeof(VkRect2D) * in_struct->scissorCount); + } else + pScissors = nullptr; +} + +void safe_VkPipelineViewportStateCreateInfo::initialize(const safe_VkPipelineViewportStateCreateInfo* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + viewportCount = copy_src->viewportCount; + pViewports = nullptr; + scissorCount = copy_src->scissorCount; + pScissors = nullptr; + + pNext = SafePnextCopy(copy_src->pNext); + if (copy_src->pViewports) { + pViewports = new VkViewport[copy_src->viewportCount]; + memcpy((void*)pViewports, (void*)copy_src->pViewports, sizeof(VkViewport) * copy_src->viewportCount); + } else + pViewports = nullptr; + if (copy_src->pScissors) { + pScissors = new VkRect2D[copy_src->scissorCount]; + memcpy((void*)pScissors, (void*)copy_src->pScissors, sizeof(VkRect2D) * copy_src->scissorCount); + } else + pScissors = nullptr; +} + +safe_VkAccelerationStructureBuildGeometryInfoKHR::safe_VkAccelerationStructureBuildGeometryInfoKHR( + const VkAccelerationStructureBuildGeometryInfoKHR* in_struct, const bool is_host, + const VkAccelerationStructureBuildRangeInfoKHR* build_range_infos, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + type(in_struct->type), + flags(in_struct->flags), + mode(in_struct->mode), + srcAccelerationStructure(in_struct->srcAccelerationStructure), + dstAccelerationStructure(in_struct->dstAccelerationStructure), + geometryCount(in_struct->geometryCount), + pGeometries(nullptr), + ppGeometries(nullptr), + scratchData(&in_struct->scratchData) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (geometryCount) { + if (in_struct->ppGeometries) { + ppGeometries = new safe_VkAccelerationStructureGeometryKHR*[geometryCount]; + for (uint32_t i = 0; i < geometryCount; ++i) { + ppGeometries[i] = + new safe_VkAccelerationStructureGeometryKHR(in_struct->ppGeometries[i], is_host, &build_range_infos[i]); + } + } else { + pGeometries = new safe_VkAccelerationStructureGeometryKHR[geometryCount]; + for (uint32_t i = 0; i < geometryCount; ++i) { + (pGeometries)[i] = + safe_VkAccelerationStructureGeometryKHR(&(in_struct->pGeometries)[i], is_host, &build_range_infos[i]); + } + } + } +} + +safe_VkAccelerationStructureBuildGeometryInfoKHR::safe_VkAccelerationStructureBuildGeometryInfoKHR() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR), + pNext(nullptr), + type(), + flags(), + mode(), + srcAccelerationStructure(), + dstAccelerationStructure(), + geometryCount(), + pGeometries(nullptr), + ppGeometries(nullptr) {} + +safe_VkAccelerationStructureBuildGeometryInfoKHR::safe_VkAccelerationStructureBuildGeometryInfoKHR( + const safe_VkAccelerationStructureBuildGeometryInfoKHR& copy_src) { + sType = copy_src.sType; + type = copy_src.type; + flags = copy_src.flags; + mode = copy_src.mode; + srcAccelerationStructure = copy_src.srcAccelerationStructure; + dstAccelerationStructure = copy_src.dstAccelerationStructure; + geometryCount = copy_src.geometryCount; + pGeometries = nullptr; + ppGeometries = nullptr; + scratchData.initialize(©_src.scratchData); + + if (geometryCount) { + if (copy_src.ppGeometries) { + ppGeometries = new safe_VkAccelerationStructureGeometryKHR*[geometryCount]; + for (uint32_t i = 0; i < geometryCount; ++i) { + ppGeometries[i] = new safe_VkAccelerationStructureGeometryKHR(*copy_src.ppGeometries[i]); + } + } else { + pGeometries = new safe_VkAccelerationStructureGeometryKHR[geometryCount]; + for (uint32_t i = 0; i < geometryCount; ++i) { + pGeometries[i] = safe_VkAccelerationStructureGeometryKHR(copy_src.pGeometries[i]); + } + } + } +} + +safe_VkAccelerationStructureBuildGeometryInfoKHR& safe_VkAccelerationStructureBuildGeometryInfoKHR::operator=( + const safe_VkAccelerationStructureBuildGeometryInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (ppGeometries) { + for (uint32_t i = 0; i < geometryCount; ++i) { + delete ppGeometries[i]; + } + delete[] ppGeometries; + } else if (pGeometries) { + delete[] pGeometries; + } + FreePnextChain(pNext); + + sType = copy_src.sType; + type = copy_src.type; + flags = copy_src.flags; + mode = copy_src.mode; + srcAccelerationStructure = copy_src.srcAccelerationStructure; + dstAccelerationStructure = copy_src.dstAccelerationStructure; + geometryCount = copy_src.geometryCount; + pGeometries = nullptr; + ppGeometries = nullptr; + scratchData.initialize(©_src.scratchData); + + if (geometryCount) { + if (copy_src.ppGeometries) { + ppGeometries = new safe_VkAccelerationStructureGeometryKHR*[geometryCount]; + for (uint32_t i = 0; i < geometryCount; ++i) { + ppGeometries[i] = new safe_VkAccelerationStructureGeometryKHR(*copy_src.ppGeometries[i]); + } + } else { + pGeometries = new safe_VkAccelerationStructureGeometryKHR[geometryCount]; + for (uint32_t i = 0; i < geometryCount; ++i) { + pGeometries[i] = safe_VkAccelerationStructureGeometryKHR(copy_src.pGeometries[i]); + } + } + } + + return *this; +} + +safe_VkAccelerationStructureBuildGeometryInfoKHR::~safe_VkAccelerationStructureBuildGeometryInfoKHR() { + if (ppGeometries) { + for (uint32_t i = 0; i < geometryCount; ++i) { + delete ppGeometries[i]; + } + delete[] ppGeometries; + } else if (pGeometries) { + delete[] pGeometries; + } + FreePnextChain(pNext); +} + +void safe_VkAccelerationStructureBuildGeometryInfoKHR::initialize(const VkAccelerationStructureBuildGeometryInfoKHR* in_struct, + const bool is_host, + const VkAccelerationStructureBuildRangeInfoKHR* build_range_infos, + [[maybe_unused]] PNextCopyState* copy_state) { + if (ppGeometries) { + for (uint32_t i = 0; i < geometryCount; ++i) { + delete ppGeometries[i]; + } + delete[] ppGeometries; + } else if (pGeometries) { + delete[] pGeometries; + } + FreePnextChain(pNext); + sType = in_struct->sType; + type = in_struct->type; + flags = in_struct->flags; + mode = in_struct->mode; + srcAccelerationStructure = in_struct->srcAccelerationStructure; + dstAccelerationStructure = in_struct->dstAccelerationStructure; + geometryCount = in_struct->geometryCount; + pGeometries = nullptr; + ppGeometries = nullptr; + scratchData.initialize(&in_struct->scratchData); + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (geometryCount) { + if (in_struct->ppGeometries) { + ppGeometries = new safe_VkAccelerationStructureGeometryKHR*[geometryCount]; + for (uint32_t i = 0; i < geometryCount; ++i) { + ppGeometries[i] = + new safe_VkAccelerationStructureGeometryKHR(in_struct->ppGeometries[i], is_host, &build_range_infos[i]); + } + } else { + pGeometries = new safe_VkAccelerationStructureGeometryKHR[geometryCount]; + for (uint32_t i = 0; i < geometryCount; ++i) { + (pGeometries)[i] = + safe_VkAccelerationStructureGeometryKHR(&(in_struct->pGeometries)[i], is_host, &build_range_infos[i]); + } + } + } +} + +void safe_VkAccelerationStructureBuildGeometryInfoKHR::initialize(const safe_VkAccelerationStructureBuildGeometryInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + type = copy_src->type; + flags = copy_src->flags; + mode = copy_src->mode; + srcAccelerationStructure = copy_src->srcAccelerationStructure; + dstAccelerationStructure = copy_src->dstAccelerationStructure; + geometryCount = copy_src->geometryCount; + pGeometries = nullptr; + ppGeometries = nullptr; + scratchData.initialize(©_src->scratchData); + + if (geometryCount) { + if (copy_src->ppGeometries) { + ppGeometries = new safe_VkAccelerationStructureGeometryKHR*[geometryCount]; + for (uint32_t i = 0; i < geometryCount; ++i) { + ppGeometries[i] = new safe_VkAccelerationStructureGeometryKHR(*copy_src->ppGeometries[i]); + } + } else { + pGeometries = new safe_VkAccelerationStructureGeometryKHR[geometryCount]; + for (uint32_t i = 0; i < geometryCount; ++i) { + pGeometries[i] = safe_VkAccelerationStructureGeometryKHR(copy_src->pGeometries[i]); + } + } + } +} + +safe_VkMicromapBuildInfoEXT::safe_VkMicromapBuildInfoEXT(const VkMicromapBuildInfoEXT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + type(in_struct->type), + flags(in_struct->flags), + mode(in_struct->mode), + dstMicromap(in_struct->dstMicromap), + usageCountsCount(in_struct->usageCountsCount), + pUsageCounts(nullptr), + ppUsageCounts(nullptr), + data(&in_struct->data), + scratchData(&in_struct->scratchData), + triangleArray(&in_struct->triangleArray), + triangleArrayStride(in_struct->triangleArrayStride) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pUsageCounts) { + pUsageCounts = new VkMicromapUsageEXT[in_struct->usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)in_struct->pUsageCounts, sizeof(VkMicromapUsageEXT) * in_struct->usageCountsCount); + } + if (in_struct->ppUsageCounts) { + VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[in_struct->usageCountsCount]; + for (uint32_t i = 0; i < in_struct->usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageEXT(*in_struct->ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } +} + +safe_VkMicromapBuildInfoEXT::safe_VkMicromapBuildInfoEXT() + : sType(VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT), + pNext(nullptr), + type(), + flags(), + mode(), + dstMicromap(), + usageCountsCount(), + pUsageCounts(nullptr), + ppUsageCounts(nullptr), + triangleArrayStride() {} + +safe_VkMicromapBuildInfoEXT::safe_VkMicromapBuildInfoEXT(const safe_VkMicromapBuildInfoEXT& copy_src) { + sType = copy_src.sType; + type = copy_src.type; + flags = copy_src.flags; + mode = copy_src.mode; + dstMicromap = copy_src.dstMicromap; + usageCountsCount = copy_src.usageCountsCount; + pUsageCounts = nullptr; + ppUsageCounts = nullptr; + data.initialize(©_src.data); + scratchData.initialize(©_src.scratchData); + triangleArray.initialize(©_src.triangleArray); + triangleArrayStride = copy_src.triangleArrayStride; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pUsageCounts) { + pUsageCounts = new VkMicromapUsageEXT[copy_src.usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)copy_src.pUsageCounts, sizeof(VkMicromapUsageEXT) * copy_src.usageCountsCount); + } + if (copy_src.ppUsageCounts) { + VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[copy_src.usageCountsCount]; + for (uint32_t i = 0; i < copy_src.usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageEXT(*copy_src.ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } +} + +safe_VkMicromapBuildInfoEXT& safe_VkMicromapBuildInfoEXT::operator=(const safe_VkMicromapBuildInfoEXT& copy_src) { + if (©_src == this) return *this; + + if (pUsageCounts) delete[] pUsageCounts; + if (ppUsageCounts) { + for (uint32_t i = 0; i < usageCountsCount; ++i) { + delete ppUsageCounts[i]; + } + delete[] ppUsageCounts; + } + FreePnextChain(pNext); + + sType = copy_src.sType; + type = copy_src.type; + flags = copy_src.flags; + mode = copy_src.mode; + dstMicromap = copy_src.dstMicromap; + usageCountsCount = copy_src.usageCountsCount; + pUsageCounts = nullptr; + ppUsageCounts = nullptr; + data.initialize(©_src.data); + scratchData.initialize(©_src.scratchData); + triangleArray.initialize(©_src.triangleArray); + triangleArrayStride = copy_src.triangleArrayStride; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pUsageCounts) { + pUsageCounts = new VkMicromapUsageEXT[copy_src.usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)copy_src.pUsageCounts, sizeof(VkMicromapUsageEXT) * copy_src.usageCountsCount); + } + if (copy_src.ppUsageCounts) { + VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[copy_src.usageCountsCount]; + for (uint32_t i = 0; i < copy_src.usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageEXT(*copy_src.ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } + + return *this; +} + +safe_VkMicromapBuildInfoEXT::~safe_VkMicromapBuildInfoEXT() { + if (pUsageCounts) delete[] pUsageCounts; + if (ppUsageCounts) { + for (uint32_t i = 0; i < usageCountsCount; ++i) { + delete ppUsageCounts[i]; + } + delete[] ppUsageCounts; + } + FreePnextChain(pNext); +} + +void safe_VkMicromapBuildInfoEXT::initialize(const VkMicromapBuildInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pUsageCounts) delete[] pUsageCounts; + if (ppUsageCounts) { + for (uint32_t i = 0; i < usageCountsCount; ++i) { + delete ppUsageCounts[i]; + } + delete[] ppUsageCounts; + } + FreePnextChain(pNext); + sType = in_struct->sType; + type = in_struct->type; + flags = in_struct->flags; + mode = in_struct->mode; + dstMicromap = in_struct->dstMicromap; + usageCountsCount = in_struct->usageCountsCount; + pUsageCounts = nullptr; + ppUsageCounts = nullptr; + data.initialize(&in_struct->data); + scratchData.initialize(&in_struct->scratchData); + triangleArray.initialize(&in_struct->triangleArray); + triangleArrayStride = in_struct->triangleArrayStride; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pUsageCounts) { + pUsageCounts = new VkMicromapUsageEXT[in_struct->usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)in_struct->pUsageCounts, sizeof(VkMicromapUsageEXT) * in_struct->usageCountsCount); + } + if (in_struct->ppUsageCounts) { + VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[in_struct->usageCountsCount]; + for (uint32_t i = 0; i < in_struct->usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageEXT(*in_struct->ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } +} + +void safe_VkMicromapBuildInfoEXT::initialize(const safe_VkMicromapBuildInfoEXT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + type = copy_src->type; + flags = copy_src->flags; + mode = copy_src->mode; + dstMicromap = copy_src->dstMicromap; + usageCountsCount = copy_src->usageCountsCount; + pUsageCounts = nullptr; + ppUsageCounts = nullptr; + data.initialize(©_src->data); + scratchData.initialize(©_src->scratchData); + triangleArray.initialize(©_src->triangleArray); + triangleArrayStride = copy_src->triangleArrayStride; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pUsageCounts) { + pUsageCounts = new VkMicromapUsageEXT[copy_src->usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)copy_src->pUsageCounts, sizeof(VkMicromapUsageEXT) * copy_src->usageCountsCount); + } + if (copy_src->ppUsageCounts) { + VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[copy_src->usageCountsCount]; + for (uint32_t i = 0; i < copy_src->usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageEXT(*copy_src->ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } +} + +safe_VkAccelerationStructureTrianglesOpacityMicromapEXT::safe_VkAccelerationStructureTrianglesOpacityMicromapEXT( + const VkAccelerationStructureTrianglesOpacityMicromapEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + indexType(in_struct->indexType), + indexBuffer(&in_struct->indexBuffer), + indexStride(in_struct->indexStride), + baseTriangle(in_struct->baseTriangle), + usageCountsCount(in_struct->usageCountsCount), + pUsageCounts(nullptr), + ppUsageCounts(nullptr), + micromap(in_struct->micromap) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pUsageCounts) { + pUsageCounts = new VkMicromapUsageEXT[in_struct->usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)in_struct->pUsageCounts, sizeof(VkMicromapUsageEXT) * in_struct->usageCountsCount); + } + if (in_struct->ppUsageCounts) { + VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[in_struct->usageCountsCount]; + for (uint32_t i = 0; i < in_struct->usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageEXT(*in_struct->ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } +} + +safe_VkAccelerationStructureTrianglesOpacityMicromapEXT::safe_VkAccelerationStructureTrianglesOpacityMicromapEXT() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT), + pNext(nullptr), + indexType(), + indexStride(), + baseTriangle(), + usageCountsCount(), + pUsageCounts(nullptr), + ppUsageCounts(nullptr), + micromap() {} + +safe_VkAccelerationStructureTrianglesOpacityMicromapEXT::safe_VkAccelerationStructureTrianglesOpacityMicromapEXT( + const safe_VkAccelerationStructureTrianglesOpacityMicromapEXT& copy_src) { + sType = copy_src.sType; + indexType = copy_src.indexType; + indexBuffer.initialize(©_src.indexBuffer); + indexStride = copy_src.indexStride; + baseTriangle = copy_src.baseTriangle; + usageCountsCount = copy_src.usageCountsCount; + pUsageCounts = nullptr; + ppUsageCounts = nullptr; + micromap = copy_src.micromap; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pUsageCounts) { + pUsageCounts = new VkMicromapUsageEXT[copy_src.usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)copy_src.pUsageCounts, sizeof(VkMicromapUsageEXT) * copy_src.usageCountsCount); + } + if (copy_src.ppUsageCounts) { + VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[copy_src.usageCountsCount]; + for (uint32_t i = 0; i < copy_src.usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageEXT(*copy_src.ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } +} + +safe_VkAccelerationStructureTrianglesOpacityMicromapEXT& safe_VkAccelerationStructureTrianglesOpacityMicromapEXT::operator=( + const safe_VkAccelerationStructureTrianglesOpacityMicromapEXT& copy_src) { + if (©_src == this) return *this; + + if (pUsageCounts) delete[] pUsageCounts; + if (ppUsageCounts) { + for (uint32_t i = 0; i < usageCountsCount; ++i) { + delete ppUsageCounts[i]; + } + delete[] ppUsageCounts; + } + FreePnextChain(pNext); + + sType = copy_src.sType; + indexType = copy_src.indexType; + indexBuffer.initialize(©_src.indexBuffer); + indexStride = copy_src.indexStride; + baseTriangle = copy_src.baseTriangle; + usageCountsCount = copy_src.usageCountsCount; + pUsageCounts = nullptr; + ppUsageCounts = nullptr; + micromap = copy_src.micromap; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pUsageCounts) { + pUsageCounts = new VkMicromapUsageEXT[copy_src.usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)copy_src.pUsageCounts, sizeof(VkMicromapUsageEXT) * copy_src.usageCountsCount); + } + if (copy_src.ppUsageCounts) { + VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[copy_src.usageCountsCount]; + for (uint32_t i = 0; i < copy_src.usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageEXT(*copy_src.ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } + + return *this; +} + +safe_VkAccelerationStructureTrianglesOpacityMicromapEXT::~safe_VkAccelerationStructureTrianglesOpacityMicromapEXT() { + if (pUsageCounts) delete[] pUsageCounts; + if (ppUsageCounts) { + for (uint32_t i = 0; i < usageCountsCount; ++i) { + delete ppUsageCounts[i]; + } + delete[] ppUsageCounts; + } + FreePnextChain(pNext); +} + +void safe_VkAccelerationStructureTrianglesOpacityMicromapEXT::initialize( + const VkAccelerationStructureTrianglesOpacityMicromapEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pUsageCounts) delete[] pUsageCounts; + if (ppUsageCounts) { + for (uint32_t i = 0; i < usageCountsCount; ++i) { + delete ppUsageCounts[i]; + } + delete[] ppUsageCounts; + } + FreePnextChain(pNext); + sType = in_struct->sType; + indexType = in_struct->indexType; + indexBuffer.initialize(&in_struct->indexBuffer); + indexStride = in_struct->indexStride; + baseTriangle = in_struct->baseTriangle; + usageCountsCount = in_struct->usageCountsCount; + pUsageCounts = nullptr; + ppUsageCounts = nullptr; + micromap = in_struct->micromap; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pUsageCounts) { + pUsageCounts = new VkMicromapUsageEXT[in_struct->usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)in_struct->pUsageCounts, sizeof(VkMicromapUsageEXT) * in_struct->usageCountsCount); + } + if (in_struct->ppUsageCounts) { + VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[in_struct->usageCountsCount]; + for (uint32_t i = 0; i < in_struct->usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageEXT(*in_struct->ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } +} + +void safe_VkAccelerationStructureTrianglesOpacityMicromapEXT::initialize( + const safe_VkAccelerationStructureTrianglesOpacityMicromapEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + indexType = copy_src->indexType; + indexBuffer.initialize(©_src->indexBuffer); + indexStride = copy_src->indexStride; + baseTriangle = copy_src->baseTriangle; + usageCountsCount = copy_src->usageCountsCount; + pUsageCounts = nullptr; + ppUsageCounts = nullptr; + micromap = copy_src->micromap; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pUsageCounts) { + pUsageCounts = new VkMicromapUsageEXT[copy_src->usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)copy_src->pUsageCounts, sizeof(VkMicromapUsageEXT) * copy_src->usageCountsCount); + } + if (copy_src->ppUsageCounts) { + VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[copy_src->usageCountsCount]; + for (uint32_t i = 0; i < copy_src->usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageEXT(*copy_src->ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } +} + +#ifdef VK_ENABLE_BETA_EXTENSIONS +safe_VkAccelerationStructureTrianglesDisplacementMicromapNV::safe_VkAccelerationStructureTrianglesDisplacementMicromapNV( + const VkAccelerationStructureTrianglesDisplacementMicromapNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + displacementBiasAndScaleFormat(in_struct->displacementBiasAndScaleFormat), + displacementVectorFormat(in_struct->displacementVectorFormat), + displacementBiasAndScaleBuffer(&in_struct->displacementBiasAndScaleBuffer), + displacementBiasAndScaleStride(in_struct->displacementBiasAndScaleStride), + displacementVectorBuffer(&in_struct->displacementVectorBuffer), + displacementVectorStride(in_struct->displacementVectorStride), + displacedMicromapPrimitiveFlags(&in_struct->displacedMicromapPrimitiveFlags), + displacedMicromapPrimitiveFlagsStride(in_struct->displacedMicromapPrimitiveFlagsStride), + indexType(in_struct->indexType), + indexBuffer(&in_struct->indexBuffer), + indexStride(in_struct->indexStride), + baseTriangle(in_struct->baseTriangle), + usageCountsCount(in_struct->usageCountsCount), + pUsageCounts(nullptr), + ppUsageCounts(nullptr), + micromap(in_struct->micromap) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pUsageCounts) { + pUsageCounts = new VkMicromapUsageEXT[in_struct->usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)in_struct->pUsageCounts, sizeof(VkMicromapUsageEXT) * in_struct->usageCountsCount); + } + if (in_struct->ppUsageCounts) { + VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[in_struct->usageCountsCount]; + for (uint32_t i = 0; i < in_struct->usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageEXT(*in_struct->ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } +} + +safe_VkAccelerationStructureTrianglesDisplacementMicromapNV::safe_VkAccelerationStructureTrianglesDisplacementMicromapNV() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV), + pNext(nullptr), + displacementBiasAndScaleFormat(), + displacementVectorFormat(), + displacementBiasAndScaleStride(), + displacementVectorStride(), + displacedMicromapPrimitiveFlagsStride(), + indexType(), + indexStride(), + baseTriangle(), + usageCountsCount(), + pUsageCounts(nullptr), + ppUsageCounts(nullptr), + micromap() {} + +safe_VkAccelerationStructureTrianglesDisplacementMicromapNV::safe_VkAccelerationStructureTrianglesDisplacementMicromapNV( + const safe_VkAccelerationStructureTrianglesDisplacementMicromapNV& copy_src) { + sType = copy_src.sType; + displacementBiasAndScaleFormat = copy_src.displacementBiasAndScaleFormat; + displacementVectorFormat = copy_src.displacementVectorFormat; + displacementBiasAndScaleBuffer.initialize(©_src.displacementBiasAndScaleBuffer); + displacementBiasAndScaleStride = copy_src.displacementBiasAndScaleStride; + displacementVectorBuffer.initialize(©_src.displacementVectorBuffer); + displacementVectorStride = copy_src.displacementVectorStride; + displacedMicromapPrimitiveFlags.initialize(©_src.displacedMicromapPrimitiveFlags); + displacedMicromapPrimitiveFlagsStride = copy_src.displacedMicromapPrimitiveFlagsStride; + indexType = copy_src.indexType; + indexBuffer.initialize(©_src.indexBuffer); + indexStride = copy_src.indexStride; + baseTriangle = copy_src.baseTriangle; + usageCountsCount = copy_src.usageCountsCount; + pUsageCounts = nullptr; + ppUsageCounts = nullptr; + micromap = copy_src.micromap; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pUsageCounts) { + pUsageCounts = new VkMicromapUsageEXT[copy_src.usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)copy_src.pUsageCounts, sizeof(VkMicromapUsageEXT) * copy_src.usageCountsCount); + } + if (copy_src.ppUsageCounts) { + VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[copy_src.usageCountsCount]; + for (uint32_t i = 0; i < copy_src.usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageEXT(*copy_src.ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } +} + +safe_VkAccelerationStructureTrianglesDisplacementMicromapNV& safe_VkAccelerationStructureTrianglesDisplacementMicromapNV::operator=( + const safe_VkAccelerationStructureTrianglesDisplacementMicromapNV& copy_src) { + if (©_src == this) return *this; + + if (pUsageCounts) delete[] pUsageCounts; + if (ppUsageCounts) { + for (uint32_t i = 0; i < usageCountsCount; ++i) { + delete ppUsageCounts[i]; + } + delete[] ppUsageCounts; + } + FreePnextChain(pNext); + + sType = copy_src.sType; + displacementBiasAndScaleFormat = copy_src.displacementBiasAndScaleFormat; + displacementVectorFormat = copy_src.displacementVectorFormat; + displacementBiasAndScaleBuffer.initialize(©_src.displacementBiasAndScaleBuffer); + displacementBiasAndScaleStride = copy_src.displacementBiasAndScaleStride; + displacementVectorBuffer.initialize(©_src.displacementVectorBuffer); + displacementVectorStride = copy_src.displacementVectorStride; + displacedMicromapPrimitiveFlags.initialize(©_src.displacedMicromapPrimitiveFlags); + displacedMicromapPrimitiveFlagsStride = copy_src.displacedMicromapPrimitiveFlagsStride; + indexType = copy_src.indexType; + indexBuffer.initialize(©_src.indexBuffer); + indexStride = copy_src.indexStride; + baseTriangle = copy_src.baseTriangle; + usageCountsCount = copy_src.usageCountsCount; + pUsageCounts = nullptr; + ppUsageCounts = nullptr; + micromap = copy_src.micromap; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pUsageCounts) { + pUsageCounts = new VkMicromapUsageEXT[copy_src.usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)copy_src.pUsageCounts, sizeof(VkMicromapUsageEXT) * copy_src.usageCountsCount); + } + if (copy_src.ppUsageCounts) { + VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[copy_src.usageCountsCount]; + for (uint32_t i = 0; i < copy_src.usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageEXT(*copy_src.ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } + + return *this; +} + +safe_VkAccelerationStructureTrianglesDisplacementMicromapNV::~safe_VkAccelerationStructureTrianglesDisplacementMicromapNV() { + if (pUsageCounts) delete[] pUsageCounts; + if (ppUsageCounts) { + for (uint32_t i = 0; i < usageCountsCount; ++i) { + delete ppUsageCounts[i]; + } + delete[] ppUsageCounts; + } + FreePnextChain(pNext); +} + +void safe_VkAccelerationStructureTrianglesDisplacementMicromapNV::initialize( + const VkAccelerationStructureTrianglesDisplacementMicromapNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pUsageCounts) delete[] pUsageCounts; + if (ppUsageCounts) { + for (uint32_t i = 0; i < usageCountsCount; ++i) { + delete ppUsageCounts[i]; + } + delete[] ppUsageCounts; + } + FreePnextChain(pNext); + sType = in_struct->sType; + displacementBiasAndScaleFormat = in_struct->displacementBiasAndScaleFormat; + displacementVectorFormat = in_struct->displacementVectorFormat; + displacementBiasAndScaleBuffer.initialize(&in_struct->displacementBiasAndScaleBuffer); + displacementBiasAndScaleStride = in_struct->displacementBiasAndScaleStride; + displacementVectorBuffer.initialize(&in_struct->displacementVectorBuffer); + displacementVectorStride = in_struct->displacementVectorStride; + displacedMicromapPrimitiveFlags.initialize(&in_struct->displacedMicromapPrimitiveFlags); + displacedMicromapPrimitiveFlagsStride = in_struct->displacedMicromapPrimitiveFlagsStride; + indexType = in_struct->indexType; + indexBuffer.initialize(&in_struct->indexBuffer); + indexStride = in_struct->indexStride; + baseTriangle = in_struct->baseTriangle; + usageCountsCount = in_struct->usageCountsCount; + pUsageCounts = nullptr; + ppUsageCounts = nullptr; + micromap = in_struct->micromap; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pUsageCounts) { + pUsageCounts = new VkMicromapUsageEXT[in_struct->usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)in_struct->pUsageCounts, sizeof(VkMicromapUsageEXT) * in_struct->usageCountsCount); + } + if (in_struct->ppUsageCounts) { + VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[in_struct->usageCountsCount]; + for (uint32_t i = 0; i < in_struct->usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageEXT(*in_struct->ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } +} + +void safe_VkAccelerationStructureTrianglesDisplacementMicromapNV::initialize( + const safe_VkAccelerationStructureTrianglesDisplacementMicromapNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + displacementBiasAndScaleFormat = copy_src->displacementBiasAndScaleFormat; + displacementVectorFormat = copy_src->displacementVectorFormat; + displacementBiasAndScaleBuffer.initialize(©_src->displacementBiasAndScaleBuffer); + displacementBiasAndScaleStride = copy_src->displacementBiasAndScaleStride; + displacementVectorBuffer.initialize(©_src->displacementVectorBuffer); + displacementVectorStride = copy_src->displacementVectorStride; + displacedMicromapPrimitiveFlags.initialize(©_src->displacedMicromapPrimitiveFlags); + displacedMicromapPrimitiveFlagsStride = copy_src->displacedMicromapPrimitiveFlagsStride; + indexType = copy_src->indexType; + indexBuffer.initialize(©_src->indexBuffer); + indexStride = copy_src->indexStride; + baseTriangle = copy_src->baseTriangle; + usageCountsCount = copy_src->usageCountsCount; + pUsageCounts = nullptr; + ppUsageCounts = nullptr; + micromap = copy_src->micromap; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pUsageCounts) { + pUsageCounts = new VkMicromapUsageEXT[copy_src->usageCountsCount]; + memcpy((void*)pUsageCounts, (void*)copy_src->pUsageCounts, sizeof(VkMicromapUsageEXT) * copy_src->usageCountsCount); + } + if (copy_src->ppUsageCounts) { + VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[copy_src->usageCountsCount]; + for (uint32_t i = 0; i < copy_src->usageCountsCount; ++i) { + pointer_array[i] = new VkMicromapUsageEXT(*copy_src->ppUsageCounts[i]); + } + ppUsageCounts = pointer_array; + } +} +#endif // VK_ENABLE_BETA_EXTENSIONS +} // namespace vku diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp new file mode 100644 index 0000000..063c311 --- /dev/null +++ b/src/vulkan/vk_safe_struct_utils.cpp @@ -0,0 +1,3633 @@ +// *** THIS FILE IS GENERATED - DO NOT EDIT *** +// See safe_struct_generator.py for modifications + +/*************************************************************************** + * + * Copyright (c) 2015-2024 The Khronos Group Inc. + * Copyright (c) 2015-2024 Valve Corporation + * Copyright (c) 2015-2024 LunarG, Inc. + * Copyright (c) 2015-2024 Google Inc. + * + * SPDX-License-Identifier: Apache-2.0 + * + ****************************************************************************/ + +// NOLINTBEGIN + +#include +#include + +#include +#include + +extern std::vector> custom_stype_info; + +namespace vku { +char *SafeStringCopy(const char *in_string) { + if (nullptr == in_string) return nullptr; + size_t len = std::strlen(in_string); + char *dest = new char[len + 1]; + dest[len] = '\0'; + std::memcpy(dest, in_string, len); + return dest; +} + +// clang-format off +void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) { + void *first_pNext{}; + VkBaseOutStructure *prev_pNext{}; + void *safe_pNext{}; + + while (pNext) { + const VkBaseOutStructure *header = reinterpret_cast(pNext); + + switch (header->sType) { + // Add special-case code to copy beloved secret loader structs + // Special-case Loader Instance Struct passed to/from layer in pNext chain + case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: { + VkLayerInstanceCreateInfo *struct_copy = new VkLayerInstanceCreateInfo; + // TODO: Uses original VkLayerInstanceLink* chain, which should be okay for our uses + memcpy(struct_copy, pNext, sizeof(VkLayerInstanceCreateInfo)); + safe_pNext = struct_copy; + break; + } + // Special-case Loader Device Struct passed to/from layer in pNext chain + case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: { + VkLayerDeviceCreateInfo *struct_copy = new VkLayerDeviceCreateInfo; + // TODO: Uses original VkLayerDeviceLink*, which should be okay for our uses + memcpy(struct_copy, pNext, sizeof(VkLayerDeviceCreateInfo)); + safe_pNext = struct_copy; + break; + } + 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; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + safe_pNext = new safe_VkPhysicalDevice16BitStorageFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: + safe_pNext = new safe_VkMemoryDedicatedRequirements(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: + safe_pNext = new safe_VkMemoryDedicatedAllocateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: + safe_pNext = new safe_VkMemoryAllocateFlagsInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: + safe_pNext = new safe_VkDeviceGroupRenderPassBeginInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: + safe_pNext = new safe_VkDeviceGroupCommandBufferBeginInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: + safe_pNext = new safe_VkDeviceGroupSubmitInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: + safe_pNext = new safe_VkDeviceGroupBindSparseInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: + safe_pNext = new safe_VkBindBufferMemoryDeviceGroupInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: + safe_pNext = new safe_VkBindImageMemoryDeviceGroupInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: + safe_pNext = new safe_VkDeviceGroupDeviceCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: + safe_pNext = new safe_VkPhysicalDeviceFeatures2(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: + safe_pNext = new safe_VkPhysicalDevicePointClippingProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: + safe_pNext = new safe_VkRenderPassInputAttachmentAspectCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: + safe_pNext = new safe_VkImageViewUsageCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: + safe_pNext = new safe_VkPipelineTessellationDomainOriginStateCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: + safe_pNext = new safe_VkRenderPassMultiviewCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceMultiviewFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceMultiviewProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceVariablePointersFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceProtectedMemoryFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceProtectedMemoryProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: + safe_pNext = new safe_VkProtectedSubmitInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: + safe_pNext = new safe_VkSamplerYcbcrConversionInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: + safe_pNext = new safe_VkBindImagePlaneMemoryInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: + safe_pNext = new safe_VkImagePlaneMemoryRequirementsInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: + safe_pNext = new safe_VkSamplerYcbcrConversionImageFormatProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: + safe_pNext = new safe_VkPhysicalDeviceExternalImageFormatInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: + safe_pNext = new safe_VkExternalImageFormatProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceIDProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: + safe_pNext = new safe_VkExternalMemoryImageCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: + safe_pNext = new safe_VkExternalMemoryBufferCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: + safe_pNext = new safe_VkExportMemoryAllocateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: + safe_pNext = new safe_VkExportFenceCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: + safe_pNext = new safe_VkExportSemaphoreCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceMaintenance3Properties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceShaderDrawParametersFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceVulkan11Features(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceVulkan11Properties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceVulkan12Features(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceVulkan12Properties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: + safe_pNext = new safe_VkImageFormatListCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + safe_pNext = new safe_VkPhysicalDevice8BitStorageFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceDriverProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceShaderAtomicInt64Features(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceShaderFloat16Int8Features(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceFloatControlsProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: + safe_pNext = new safe_VkDescriptorSetLayoutBindingFlagsCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceDescriptorIndexingFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceDescriptorIndexingProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: + safe_pNext = new safe_VkDescriptorSetVariableDescriptorCountAllocateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: + safe_pNext = new safe_VkDescriptorSetVariableDescriptorCountLayoutSupport(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: + safe_pNext = new safe_VkSubpassDescriptionDepthStencilResolve(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceDepthStencilResolveProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceScalarBlockLayoutFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: + safe_pNext = new safe_VkImageStencilUsageCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: + safe_pNext = new safe_VkSamplerReductionModeCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceSamplerFilterMinmaxProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceVulkanMemoryModelFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceImagelessFramebufferFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: + safe_pNext = new safe_VkFramebufferAttachmentsCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: + safe_pNext = new safe_VkRenderPassAttachmentBeginInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: + safe_pNext = new safe_VkAttachmentReferenceStencilLayout(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: + safe_pNext = new safe_VkAttachmentDescriptionStencilLayout(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceHostQueryResetFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceTimelineSemaphoreFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceTimelineSemaphoreProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: + safe_pNext = new safe_VkSemaphoreTypeCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: + safe_pNext = new safe_VkTimelineSemaphoreSubmitInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceBufferDeviceAddressFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: + safe_pNext = new safe_VkBufferOpaqueCaptureAddressCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: + safe_pNext = new safe_VkMemoryOpaqueCaptureAddressAllocateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceVulkan13Features(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceVulkan13Properties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: + safe_pNext = new safe_VkPipelineCreationFeedbackCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceShaderTerminateInvocationFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + safe_pNext = new safe_VkPhysicalDevicePrivateDataFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: + safe_pNext = new safe_VkDevicePrivateDataCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + safe_pNext = new safe_VkPhysicalDevicePipelineCreationCacheControlFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: + safe_pNext = new safe_VkMemoryBarrier2(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceSynchronization2Features(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceImageRobustnessFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceSubgroupSizeControlFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceSubgroupSizeControlProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: + safe_pNext = new safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceInlineUniformBlockFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceInlineUniformBlockProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: + safe_pNext = new safe_VkWriteDescriptorSetInlineUniformBlock(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: + safe_pNext = new safe_VkDescriptorPoolInlineUniformBlockCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: + safe_pNext = new safe_VkPipelineRenderingCreateInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceDynamicRenderingFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: + safe_pNext = new safe_VkCommandBufferInheritanceRenderingInfo(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceShaderIntegerDotProductFeatures(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceShaderIntegerDotProductProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceTexelBufferAlignmentProperties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: + safe_pNext = new safe_VkFormatProperties3(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + safe_pNext = new safe_VkPhysicalDeviceMaintenance4Features(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: + safe_pNext = new safe_VkPhysicalDeviceMaintenance4Properties(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: + safe_pNext = new safe_VkImageSwapchainCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: + safe_pNext = new safe_VkBindImageMemorySwapchainInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: + safe_pNext = new safe_VkDeviceGroupPresentInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: + safe_pNext = new safe_VkDeviceGroupSwapchainCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: + safe_pNext = new safe_VkDisplayPresentInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: + safe_pNext = new safe_VkQueueFamilyQueryResultStatusPropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: + safe_pNext = new safe_VkQueueFamilyVideoPropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: + safe_pNext = new safe_VkVideoProfileInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: + safe_pNext = new safe_VkVideoProfileListInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: + safe_pNext = new safe_VkVideoDecodeCapabilitiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + 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; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: + safe_pNext = new safe_VkVideoDecodeH264CapabilitiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: + safe_pNext = new safe_VkVideoDecodeH264SessionParametersAddInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: + safe_pNext = new safe_VkVideoDecodeH264SessionParametersCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: + safe_pNext = new safe_VkVideoDecodeH264PictureInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: + safe_pNext = new safe_VkVideoDecodeH264DpbSlotInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: + safe_pNext = new safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: + safe_pNext = new safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: + safe_pNext = new safe_VkAttachmentSampleCountInfoAMD(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: + safe_pNext = new safe_VkMultiviewPerViewAttributesInfoNVX(reinterpret_cast(pNext), copy_state, false); + break; +#ifdef VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + safe_pNext = new safe_VkImportMemoryWin32HandleInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + safe_pNext = new safe_VkExportMemoryWin32HandleInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: + safe_pNext = new safe_VkImportMemoryFdInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; +#ifdef VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: + safe_pNext = new safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: + safe_pNext = new safe_VkExportSemaphoreWin32HandleInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: + safe_pNext = new safe_VkD3D12FenceSubmitInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: + safe_pNext = new safe_VkPhysicalDevicePushDescriptorPropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: + safe_pNext = new safe_VkPresentRegionsKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: + safe_pNext = new safe_VkSharedPresentSurfaceCapabilitiesKHR(reinterpret_cast(pNext), copy_state, false); + break; +#ifdef VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: + safe_pNext = new safe_VkExportFenceWin32HandleInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: + safe_pNext = new safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: + safe_pNext = new safe_VkQueryPoolPerformanceCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: + safe_pNext = new safe_VkPerformanceQuerySubmitInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; +#ifdef VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: + safe_pNext = new safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceShaderClockFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: + safe_pNext = new safe_VkVideoDecodeH265ProfileInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: + safe_pNext = new safe_VkVideoDecodeH265CapabilitiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: + safe_pNext = new safe_VkVideoDecodeH265SessionParametersAddInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: + safe_pNext = new safe_VkVideoDecodeH265SessionParametersCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: + safe_pNext = new safe_VkVideoDecodeH265PictureInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: + safe_pNext = new safe_VkVideoDecodeH265DpbSlotInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: + safe_pNext = new safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: + safe_pNext = new safe_VkQueueFamilyGlobalPriorityPropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: + safe_pNext = new safe_VkFragmentShadingRateAttachmentInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: + safe_pNext = new safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: + safe_pNext = new safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR: + safe_pNext = new safe_VkRenderingAttachmentLocationInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR: + safe_pNext = new safe_VkRenderingInputAttachmentIndexInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: + safe_pNext = new safe_VkSurfaceProtectedCapabilitiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDevicePresentWaitFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: + safe_pNext = new safe_VkPipelineLibraryCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: + safe_pNext = new safe_VkPresentIdKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDevicePresentIdFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: + safe_pNext = new safe_VkVideoEncodeCapabilitiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: + safe_pNext = new safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeUsageInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeRateControlInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: + safe_pNext = new safe_VkVideoEncodeQualityLevelInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: + safe_pNext = new safe_VkQueueFamilyCheckpointProperties2NV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: + safe_pNext = new safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceMaintenance5FeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: + safe_pNext = new safe_VkPhysicalDeviceMaintenance5PropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: + safe_pNext = new safe_VkPipelineCreateFlags2CreateInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: + safe_pNext = new safe_VkBufferUsageFlags2CreateInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + 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_VIDEO_DECODE_AV1_PROFILE_INFO_KHR: + safe_pNext = new safe_VkVideoDecodeAV1ProfileInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR: + safe_pNext = new safe_VkVideoDecodeAV1CapabilitiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: + safe_pNext = new safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR: + safe_pNext = new safe_VkVideoDecodeAV1PictureInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR: + safe_pNext = new safe_VkVideoDecodeAV1DpbSlotInfoKHR(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; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: + safe_pNext = new safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: + safe_pNext = new safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: + safe_pNext = new safe_VkPipelineRasterizationLineStateCreateInfoKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceMaintenance6FeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: + safe_pNext = new safe_VkPhysicalDeviceMaintenance6PropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: + safe_pNext = new safe_VkBindMemoryStatusKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: + safe_pNext = new safe_VkDebugReportCallbackCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: + safe_pNext = new safe_VkPipelineRasterizationStateRasterizationOrderAMD(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: + safe_pNext = new safe_VkDedicatedAllocationImageCreateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: + safe_pNext = new safe_VkDedicatedAllocationBufferCreateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: + safe_pNext = new safe_VkDedicatedAllocationMemoryAllocateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: + safe_pNext = new safe_VkPipelineRasterizationStateStreamCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: + safe_pNext = new safe_VkTextureLODGatherFormatPropertiesAMD(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: + safe_pNext = new safe_VkExternalMemoryImageCreateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: + safe_pNext = new safe_VkExportMemoryAllocateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; +#ifdef VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: + safe_pNext = new safe_VkImportMemoryWin32HandleInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: + safe_pNext = new safe_VkExportMemoryWin32HandleInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: + safe_pNext = new safe_VkWin32KeyedMutexAcquireReleaseInfoNV(reinterpret_cast(pNext), copy_state, false); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: + safe_pNext = new safe_VkValidationFlagsEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: + safe_pNext = new safe_VkImageViewASTCDecodeModeEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: + safe_pNext = new safe_VkPipelineRobustnessCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: + safe_pNext = new safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: + safe_pNext = new safe_VkPipelineViewportWScalingStateCreateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: + safe_pNext = new safe_VkSwapchainCounterCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: + safe_pNext = new safe_VkPresentTimesInfoGOOGLE(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: + safe_pNext = new safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: + safe_pNext = new safe_VkPipelineViewportSwizzleStateCreateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: + safe_pNext = new safe_VkPipelineDiscardRectangleStateCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: + safe_pNext = new safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: + safe_pNext = new safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + safe_pNext = new safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: + safe_pNext = new safe_VkDebugUtilsObjectNameInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: + safe_pNext = new safe_VkDebugUtilsMessengerCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; +#ifdef VK_USE_PLATFORM_ANDROID_KHR + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: + safe_pNext = new safe_VkAndroidHardwareBufferUsageANDROID(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: + safe_pNext = new safe_VkAndroidHardwareBufferFormatPropertiesANDROID(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: + safe_pNext = new safe_VkImportAndroidHardwareBufferInfoANDROID(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: + safe_pNext = new safe_VkExternalFormatANDROID(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: + safe_pNext = new safe_VkAndroidHardwareBufferFormatProperties2ANDROID(reinterpret_cast(pNext), copy_state, false); + break; +#endif // VK_USE_PLATFORM_ANDROID_KHR +#ifdef VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: + safe_pNext = new safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX: + safe_pNext = new safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX: + safe_pNext = new safe_VkPipelineShaderStageNodeCreateInfoAMDX(reinterpret_cast(pNext), copy_state, false); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: + safe_pNext = new safe_VkSampleLocationsInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: + safe_pNext = new safe_VkRenderPassSampleLocationsBeginInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: + safe_pNext = new safe_VkPipelineSampleLocationsStateCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: + safe_pNext = new safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: + safe_pNext = new safe_VkPipelineCoverageToColorStateCreateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: + safe_pNext = new safe_VkPipelineCoverageModulationStateCreateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: + safe_pNext = new safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: + safe_pNext = new safe_VkDrmFormatModifierPropertiesListEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: + safe_pNext = new safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: + safe_pNext = new safe_VkImageDrmFormatModifierListCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: + safe_pNext = new safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: + safe_pNext = new safe_VkDrmFormatModifierPropertiesList2EXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: + safe_pNext = new safe_VkShaderModuleValidationCacheCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: + safe_pNext = new safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceShadingRateImageFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: + safe_pNext = new safe_VkPhysicalDeviceShadingRateImagePropertiesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: + safe_pNext = new safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: + safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: + safe_pNext = new safe_VkPhysicalDeviceRayTracingPropertiesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: + safe_pNext = new safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: + safe_pNext = new safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: + safe_pNext = new safe_VkFilterCubicImageViewImageFormatPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: + safe_pNext = new safe_VkImportMemoryHostPointerInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: + safe_pNext = new safe_VkPipelineCompilerControlCreateInfoAMD(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: + safe_pNext = new safe_VkPhysicalDeviceShaderCorePropertiesAMD(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: + safe_pNext = new safe_VkDeviceMemoryOverallocationCreateInfoAMD(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; +#ifdef VK_USE_PLATFORM_GGP + case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: + safe_pNext = new safe_VkPresentFrameTokenGGP(reinterpret_cast(pNext), copy_state, false); + break; +#endif // VK_USE_PLATFORM_GGP + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceMeshShaderFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: + safe_pNext = new safe_VkPhysicalDeviceMeshShaderPropertiesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: + safe_pNext = new safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: + safe_pNext = new safe_VkQueueFamilyCheckpointPropertiesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: + safe_pNext = new safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: + safe_pNext = new safe_VkQueryPoolPerformanceQueryCreateInfoINTEL(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: + safe_pNext = new safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: + safe_pNext = new safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: + safe_pNext = new safe_VkRenderPassFragmentDensityMapCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: + safe_pNext = new safe_VkPhysicalDeviceShaderCoreProperties2AMD(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: + safe_pNext = new safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: + safe_pNext = new safe_VkMemoryPriorityAllocateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: + safe_pNext = new safe_VkBufferDeviceAddressCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: + safe_pNext = new safe_VkValidationFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: + safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: + safe_pNext = new safe_VkPipelineCoverageReductionStateCreateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceProvokingVertexFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceProvokingVertexPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: + safe_pNext = new safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; +#ifdef VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: + safe_pNext = new safe_VkSurfaceFullScreenExclusiveInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: + safe_pNext = new safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: + safe_pNext = new safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(reinterpret_cast(pNext), copy_state, false); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: + safe_pNext = new safe_VkSubresourceHostMemcpySizeEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: + safe_pNext = new safe_VkHostImageCopyDevicePerformanceQueryEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT: + safe_pNext = new safe_VkMemoryMapPlacedInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: + safe_pNext = new safe_VkSurfacePresentModeEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: + safe_pNext = new safe_VkSurfacePresentScalingCapabilitiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: + safe_pNext = new safe_VkSurfacePresentModeCompatibilityEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: + safe_pNext = new safe_VkSwapchainPresentFenceInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: + safe_pNext = new safe_VkSwapchainPresentModesCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: + safe_pNext = new safe_VkSwapchainPresentModeInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: + safe_pNext = new safe_VkSwapchainPresentScalingCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: + safe_pNext = new safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: + safe_pNext = new safe_VkGraphicsPipelineShaderGroupsCreateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: + safe_pNext = new safe_VkCommandBufferInheritanceViewportScissorInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: + safe_pNext = new safe_VkRenderPassTransformBeginInfoQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: + safe_pNext = new safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT: + safe_pNext = new safe_VkDepthBiasRepresentationInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: + safe_pNext = new safe_VkDeviceDeviceMemoryReportCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceRobustness2FeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceRobustness2PropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: + safe_pNext = new safe_VkSamplerCustomBorderColorCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDevicePresentBarrierFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: + safe_pNext = new safe_VkSurfaceCapabilitiesPresentBarrierNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: + safe_pNext = new safe_VkSwapchainPresentBarrierCreateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: + safe_pNext = new safe_VkDeviceDiagnosticsConfigCreateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV: + safe_pNext = new safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: + safe_pNext = new safe_VkQueryLowLatencySupportNV(reinterpret_cast(pNext), copy_state, false); + break; +#ifdef VK_USE_PLATFORM_METAL_EXT + case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: + safe_pNext = new safe_VkExportMetalObjectCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: + safe_pNext = new safe_VkExportMetalDeviceInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: + safe_pNext = new safe_VkExportMetalCommandQueueInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: + safe_pNext = new safe_VkExportMetalBufferInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: + safe_pNext = new safe_VkImportMetalBufferInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: + safe_pNext = new safe_VkExportMetalTextureInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: + safe_pNext = new safe_VkImportMetalTextureInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: + safe_pNext = new safe_VkExportMetalIOSurfaceInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: + safe_pNext = new safe_VkImportMetalIOSurfaceInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: + safe_pNext = new safe_VkExportMetalSharedEventInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: + safe_pNext = new safe_VkImportMetalSharedEventInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; +#endif // VK_USE_PLATFORM_METAL_EXT + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: + safe_pNext = new safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: + safe_pNext = new safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: + safe_pNext = new safe_VkGraphicsPipelineLibraryCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: + safe_pNext = new safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: + safe_pNext = new safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: + safe_pNext = new safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: + safe_pNext = new safe_VkAccelerationStructureGeometryMotionTrianglesDataNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: + safe_pNext = new safe_VkAccelerationStructureMotionInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: + safe_pNext = new safe_VkCopyCommandTransformInfoQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: + safe_pNext = new safe_VkImageCompressionControlEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: + safe_pNext = new safe_VkImageCompressionPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDevice4444FormatsFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceFaultFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: + safe_pNext = new safe_VkMutableDescriptorTypeCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceDrmPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: + safe_pNext = new safe_VkDeviceAddressBindingCallbackDataEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceDepthClipControlFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: + safe_pNext = new safe_VkPipelineViewportDepthClipControlCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; +#ifdef VK_USE_PLATFORM_FUCHSIA + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: + safe_pNext = new safe_VkImportMemoryZirconHandleInfoFUCHSIA(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: + safe_pNext = new safe_VkImportMemoryBufferCollectionFUCHSIA(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: + safe_pNext = new safe_VkBufferCollectionImageCreateInfoFUCHSIA(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: + safe_pNext = new safe_VkBufferCollectionBufferCreateInfoFUCHSIA(reinterpret_cast(pNext), copy_state, false); + break; +#endif // VK_USE_PLATFORM_FUCHSIA + case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: + safe_pNext = new safe_VkSubpassShadingPipelineCreateInfoHUAWEI(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: + safe_pNext = new safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: + safe_pNext = new safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: + safe_pNext = new safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: + safe_pNext = new safe_VkFrameBoundaryEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: + safe_pNext = new safe_VkSubpassResolvePerformanceQueryEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: + safe_pNext = new safe_VkMultisampledRenderToSingleSampledInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: + safe_pNext = new safe_VkPipelineColorWriteCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: + safe_pNext = new safe_VkImageViewMinLodCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceMultiDrawFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceMultiDrawPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceShaderTileImageFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceShaderTileImagePropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: + safe_pNext = new safe_VkAccelerationStructureTrianglesOpacityMicromapEXT(reinterpret_cast(pNext), copy_state, false); + break; +#ifdef VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: + safe_pNext = new safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: + safe_pNext = new safe_VkAccelerationStructureTrianglesDisplacementMicromapNV(reinterpret_cast(pNext), copy_state, false); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: + safe_pNext = new safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: + safe_pNext = new safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: + safe_pNext = new safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: + safe_pNext = new safe_VkSamplerBorderColorComponentMappingCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: + safe_pNext = new safe_VkPhysicalDeviceShaderCorePropertiesARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: + safe_pNext = new safe_VkDeviceQueueShaderCoreControlCreateInfoARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + safe_pNext = new safe_VkPhysicalDeviceSchedulingControlsFeaturesARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: + safe_pNext = new safe_VkPhysicalDeviceSchedulingControlsPropertiesARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: + safe_pNext = new safe_VkImageViewSlicedCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: + safe_pNext = new safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + safe_pNext = new safe_VkPhysicalDeviceRenderPassStripedFeaturesARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: + safe_pNext = new safe_VkPhysicalDeviceRenderPassStripedPropertiesARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: + safe_pNext = new safe_VkRenderPassStripeBeginInfoARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: + safe_pNext = new safe_VkRenderPassStripeSubmitInfoARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: + safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: + safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: + safe_pNext = new safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: + safe_pNext = new safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: + safe_pNext = new safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV: + safe_pNext = new safe_VkComputePipelineIndirectBufferInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: + safe_pNext = new safe_VkImageViewSampleWeightCreateInfoQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: + safe_pNext = new safe_VkPhysicalDeviceImageProcessingFeaturesQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: + safe_pNext = new safe_VkPhysicalDeviceImageProcessingPropertiesQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: + safe_pNext = new safe_VkExternalMemoryAcquireUnmodifiedEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: + safe_pNext = new safe_VkRenderPassCreationControlEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: + safe_pNext = new safe_VkRenderPassCreationFeedbackCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: + safe_pNext = new safe_VkRenderPassSubpassFeedbackCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: + safe_pNext = new safe_VkDirectDriverLoadingListLUNARG(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: + safe_pNext = new safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceOpticalFlowFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: + safe_pNext = new safe_VkPhysicalDeviceOpticalFlowPropertiesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: + safe_pNext = new safe_VkOpticalFlowImageFormatInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: + safe_pNext = new safe_VkOpticalFlowSessionCreatePrivateDataInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; +#ifdef VK_USE_PLATFORM_ANDROID_KHR + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID: + safe_pNext = new safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID: + safe_pNext = new safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID: + safe_pNext = new safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID(reinterpret_cast(pNext), copy_state, false); + break; +#endif // VK_USE_PLATFORM_ANDROID_KHR + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceShaderObjectFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceShaderObjectPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: + safe_pNext = new safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: + safe_pNext = new safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: + safe_pNext = new safe_VkAmigoProfilingSubmitInfoSEC(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: + safe_pNext = new safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: + safe_pNext = new safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: + safe_pNext = new safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: + safe_pNext = new safe_VkLayerSettingsCreateInfoEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: + safe_pNext = new safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: + safe_pNext = new safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV: + safe_pNext = new safe_VkLatencySubmissionPresentIdNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV: + safe_pNext = new safe_VkSwapchainLatencyCreateInfoNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV: + safe_pNext = new safe_VkLatencySurfaceCapabilitiesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: + safe_pNext = new safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(reinterpret_cast(pNext), copy_state, false); + break; + 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; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM: + safe_pNext = new safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM: + safe_pNext = new safe_VkSamplerBlockMatchWindowCreateInfoQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: + safe_pNext = new safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM: + safe_pNext = new safe_VkSamplerCubicWeightsCreateInfoQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM: + safe_pNext = new safe_VkBlitImageCubicWeightsInfoQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: + safe_pNext = new safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM: + safe_pNext = new safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: + safe_pNext = new safe_VkPhysicalDeviceCubicClampFeaturesQCOM(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; +#ifdef VK_USE_PLATFORM_SCREEN_QNX + case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX: + safe_pNext = new safe_VkScreenBufferFormatPropertiesQNX(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX: + safe_pNext = new safe_VkImportScreenBufferInfoQNX(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX: + safe_pNext = new safe_VkExternalFormatQNX(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: + safe_pNext = new safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX(reinterpret_cast(pNext), copy_state, false); + break; +#endif // VK_USE_PLATFORM_SCREEN_QNX + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: + safe_pNext = new safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceRawAccessChainsFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: + safe_pNext = new safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: + safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: + safe_pNext = new safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: + safe_pNext = new safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceRayQueryFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: + safe_pNext = new safe_VkPhysicalDeviceMeshShaderFeaturesEXT(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: + safe_pNext = new safe_VkPhysicalDeviceMeshShaderPropertiesEXT(reinterpret_cast(pNext), copy_state, false); + break; + + default: // Encountered an unknown sType -- skip (do not copy) this entry in the chain + // If sType is in custom list, construct blind copy + for (auto item : custom_stype_info) { + if (item.first == static_cast(header->sType)) { + safe_pNext = malloc(item.second); + memcpy(safe_pNext, header, item.second); + } + } + break; + } + if (!first_pNext) { + first_pNext = safe_pNext; + } + pNext = header->pNext; + if (prev_pNext && safe_pNext) { + prev_pNext->pNext = (VkBaseOutStructure*)safe_pNext; + } + if (safe_pNext) { + prev_pNext = (VkBaseOutStructure*)safe_pNext; + } + safe_pNext = nullptr; + } + + return first_pNext; +} + +void FreePnextChain(const void *pNext) { + if (!pNext) return; + + auto header = reinterpret_cast(pNext); + + switch (header->sType) { + // Special-case Loader Instance Struct passed to/from layer in pNext chain + case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: + FreePnextChain(header->pNext); + delete reinterpret_cast(pNext); + break; + // Special-case Loader Device Struct passed to/from layer in pNext chain + case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: + FreePnextChain(header->pNext); + delete reinterpret_cast(pNext); + break; + 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; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: + delete reinterpret_cast(header); + break; + 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; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: + delete reinterpret_cast(header); + break; +#ifdef VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + delete reinterpret_cast(header); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: + delete reinterpret_cast(header); + break; +#ifdef VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: + delete reinterpret_cast(header); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: + delete reinterpret_cast(header); + break; +#ifdef VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: + delete reinterpret_cast(header); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: + delete reinterpret_cast(header); + break; +#ifdef VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: + delete reinterpret_cast(header); + break; +#ifdef VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: + delete reinterpret_cast(header); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; +#ifdef VK_USE_PLATFORM_ANDROID_KHR + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: + delete reinterpret_cast(header); + break; +#endif // VK_USE_PLATFORM_ANDROID_KHR +#ifdef VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX: + delete reinterpret_cast(header); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; +#ifdef VK_USE_PLATFORM_GGP + case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: + delete reinterpret_cast(header); + break; +#endif // VK_USE_PLATFORM_GGP + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; +#ifdef VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: + delete reinterpret_cast(header); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: + delete reinterpret_cast(header); + break; +#ifdef VK_USE_PLATFORM_METAL_EXT + case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: + delete reinterpret_cast(header); + break; +#endif // VK_USE_PLATFORM_METAL_EXT + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: + delete reinterpret_cast(header); + break; +#ifdef VK_USE_PLATFORM_FUCHSIA + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: + delete reinterpret_cast(header); + break; +#endif // VK_USE_PLATFORM_FUCHSIA + case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: + delete reinterpret_cast(header); + break; +#ifdef VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: + delete reinterpret_cast(header); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: + delete reinterpret_cast(header); + break; +#ifdef VK_USE_PLATFORM_ANDROID_KHR + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID: + delete reinterpret_cast(header); + break; +#endif // VK_USE_PLATFORM_ANDROID_KHR + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: + delete reinterpret_cast(header); + break; + 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; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: + delete reinterpret_cast(header); + break; +#ifdef VK_USE_PLATFORM_SCREEN_QNX + case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: + delete reinterpret_cast(header); + break; +#endif // VK_USE_PLATFORM_SCREEN_QNX + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: + delete reinterpret_cast(header); + break; + + default: // Encountered an unknown sType + // If sType is in custom list, free custom struct memory and clean up + for (auto item : custom_stype_info) { + if (item.first == static_cast(header->sType)) { + if (header->pNext) { + FreePnextChain(header->pNext); + } + free(const_cast(pNext)); + pNext = nullptr; + break; + } + } + if (pNext) { + FreePnextChain(header->pNext); + } + break; + } +} // clang-format on + +} // namespace vku + +// NOLINTEND diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp new file mode 100644 index 0000000..6054229 --- /dev/null +++ b/src/vulkan/vk_safe_struct_vendor.cpp @@ -0,0 +1,15191 @@ +// *** THIS FILE IS GENERATED - DO NOT EDIT *** +// See safe_struct_generator.py for modifications + +/*************************************************************************** + * + * Copyright (c) 2015-2024 The Khronos Group Inc. + * Copyright (c) 2015-2024 Valve Corporation + * Copyright (c) 2015-2024 LunarG, Inc. + * Copyright (c) 2015-2024 Google Inc. + * + * SPDX-License-Identifier: Apache-2.0 + * + ****************************************************************************/ + +// NOLINTBEGIN + +#include +#include + +#include + +namespace vku { + +safe_VkAttachmentSampleCountInfoAMD::safe_VkAttachmentSampleCountInfoAMD(const VkAttachmentSampleCountInfoAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + colorAttachmentCount(in_struct->colorAttachmentCount), + pColorAttachmentSamples(nullptr), + depthStencilAttachmentSamples(in_struct->depthStencilAttachmentSamples) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pColorAttachmentSamples) { + pColorAttachmentSamples = new VkSampleCountFlagBits[in_struct->colorAttachmentCount]; + memcpy((void*)pColorAttachmentSamples, (void*)in_struct->pColorAttachmentSamples, + sizeof(VkSampleCountFlagBits) * in_struct->colorAttachmentCount); + } +} + +safe_VkAttachmentSampleCountInfoAMD::safe_VkAttachmentSampleCountInfoAMD() + : sType(VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD), + pNext(nullptr), + colorAttachmentCount(), + pColorAttachmentSamples(nullptr), + depthStencilAttachmentSamples() {} + +safe_VkAttachmentSampleCountInfoAMD::safe_VkAttachmentSampleCountInfoAMD(const safe_VkAttachmentSampleCountInfoAMD& copy_src) { + sType = copy_src.sType; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachmentSamples = nullptr; + depthStencilAttachmentSamples = copy_src.depthStencilAttachmentSamples; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pColorAttachmentSamples) { + pColorAttachmentSamples = new VkSampleCountFlagBits[copy_src.colorAttachmentCount]; + memcpy((void*)pColorAttachmentSamples, (void*)copy_src.pColorAttachmentSamples, + sizeof(VkSampleCountFlagBits) * copy_src.colorAttachmentCount); + } +} + +safe_VkAttachmentSampleCountInfoAMD& safe_VkAttachmentSampleCountInfoAMD::operator=( + const safe_VkAttachmentSampleCountInfoAMD& copy_src) { + if (©_src == this) return *this; + + if (pColorAttachmentSamples) delete[] pColorAttachmentSamples; + FreePnextChain(pNext); + + sType = copy_src.sType; + colorAttachmentCount = copy_src.colorAttachmentCount; + pColorAttachmentSamples = nullptr; + depthStencilAttachmentSamples = copy_src.depthStencilAttachmentSamples; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pColorAttachmentSamples) { + pColorAttachmentSamples = new VkSampleCountFlagBits[copy_src.colorAttachmentCount]; + memcpy((void*)pColorAttachmentSamples, (void*)copy_src.pColorAttachmentSamples, + sizeof(VkSampleCountFlagBits) * copy_src.colorAttachmentCount); + } + + return *this; +} + +safe_VkAttachmentSampleCountInfoAMD::~safe_VkAttachmentSampleCountInfoAMD() { + if (pColorAttachmentSamples) delete[] pColorAttachmentSamples; + FreePnextChain(pNext); +} + +void safe_VkAttachmentSampleCountInfoAMD::initialize(const VkAttachmentSampleCountInfoAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pColorAttachmentSamples) delete[] pColorAttachmentSamples; + FreePnextChain(pNext); + sType = in_struct->sType; + colorAttachmentCount = in_struct->colorAttachmentCount; + pColorAttachmentSamples = nullptr; + depthStencilAttachmentSamples = in_struct->depthStencilAttachmentSamples; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pColorAttachmentSamples) { + pColorAttachmentSamples = new VkSampleCountFlagBits[in_struct->colorAttachmentCount]; + memcpy((void*)pColorAttachmentSamples, (void*)in_struct->pColorAttachmentSamples, + sizeof(VkSampleCountFlagBits) * in_struct->colorAttachmentCount); + } +} + +void safe_VkAttachmentSampleCountInfoAMD::initialize(const safe_VkAttachmentSampleCountInfoAMD* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + colorAttachmentCount = copy_src->colorAttachmentCount; + pColorAttachmentSamples = nullptr; + depthStencilAttachmentSamples = copy_src->depthStencilAttachmentSamples; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pColorAttachmentSamples) { + pColorAttachmentSamples = new VkSampleCountFlagBits[copy_src->colorAttachmentCount]; + memcpy((void*)pColorAttachmentSamples, (void*)copy_src->pColorAttachmentSamples, + sizeof(VkSampleCountFlagBits) * copy_src->colorAttachmentCount); + } +} + +safe_VkMultiviewPerViewAttributesInfoNVX::safe_VkMultiviewPerViewAttributesInfoNVX( + const VkMultiviewPerViewAttributesInfoNVX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + perViewAttributes(in_struct->perViewAttributes), + perViewAttributesPositionXOnly(in_struct->perViewAttributesPositionXOnly) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMultiviewPerViewAttributesInfoNVX::safe_VkMultiviewPerViewAttributesInfoNVX() + : sType(VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX), + pNext(nullptr), + perViewAttributes(), + perViewAttributesPositionXOnly() {} + +safe_VkMultiviewPerViewAttributesInfoNVX::safe_VkMultiviewPerViewAttributesInfoNVX( + const safe_VkMultiviewPerViewAttributesInfoNVX& copy_src) { + sType = copy_src.sType; + perViewAttributes = copy_src.perViewAttributes; + perViewAttributesPositionXOnly = copy_src.perViewAttributesPositionXOnly; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMultiviewPerViewAttributesInfoNVX& safe_VkMultiviewPerViewAttributesInfoNVX::operator=( + const safe_VkMultiviewPerViewAttributesInfoNVX& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + perViewAttributes = copy_src.perViewAttributes; + perViewAttributesPositionXOnly = copy_src.perViewAttributesPositionXOnly; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMultiviewPerViewAttributesInfoNVX::~safe_VkMultiviewPerViewAttributesInfoNVX() { FreePnextChain(pNext); } + +void safe_VkMultiviewPerViewAttributesInfoNVX::initialize(const VkMultiviewPerViewAttributesInfoNVX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + perViewAttributes = in_struct->perViewAttributes; + perViewAttributesPositionXOnly = in_struct->perViewAttributesPositionXOnly; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMultiviewPerViewAttributesInfoNVX::initialize(const safe_VkMultiviewPerViewAttributesInfoNVX* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + perViewAttributes = copy_src->perViewAttributes; + perViewAttributesPositionXOnly = copy_src->perViewAttributesPositionXOnly; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkQueueFamilyCheckpointProperties2NV::safe_VkQueueFamilyCheckpointProperties2NV( + const VkQueueFamilyCheckpointProperties2NV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), checkpointExecutionStageMask(in_struct->checkpointExecutionStageMask) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkQueueFamilyCheckpointProperties2NV::safe_VkQueueFamilyCheckpointProperties2NV() + : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV), pNext(nullptr), checkpointExecutionStageMask() {} + +safe_VkQueueFamilyCheckpointProperties2NV::safe_VkQueueFamilyCheckpointProperties2NV( + const safe_VkQueueFamilyCheckpointProperties2NV& copy_src) { + sType = copy_src.sType; + checkpointExecutionStageMask = copy_src.checkpointExecutionStageMask; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkQueueFamilyCheckpointProperties2NV& safe_VkQueueFamilyCheckpointProperties2NV::operator=( + const safe_VkQueueFamilyCheckpointProperties2NV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + checkpointExecutionStageMask = copy_src.checkpointExecutionStageMask; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkQueueFamilyCheckpointProperties2NV::~safe_VkQueueFamilyCheckpointProperties2NV() { FreePnextChain(pNext); } + +void safe_VkQueueFamilyCheckpointProperties2NV::initialize(const VkQueueFamilyCheckpointProperties2NV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + checkpointExecutionStageMask = in_struct->checkpointExecutionStageMask; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkQueueFamilyCheckpointProperties2NV::initialize(const safe_VkQueueFamilyCheckpointProperties2NV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + checkpointExecutionStageMask = copy_src->checkpointExecutionStageMask; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCheckpointData2NV::safe_VkCheckpointData2NV(const VkCheckpointData2NV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), stage(in_struct->stage), pCheckpointMarker(in_struct->pCheckpointMarker) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCheckpointData2NV::safe_VkCheckpointData2NV() + : sType(VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV), pNext(nullptr), stage(), pCheckpointMarker(nullptr) {} + +safe_VkCheckpointData2NV::safe_VkCheckpointData2NV(const safe_VkCheckpointData2NV& copy_src) { + sType = copy_src.sType; + stage = copy_src.stage; + pCheckpointMarker = copy_src.pCheckpointMarker; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCheckpointData2NV& safe_VkCheckpointData2NV::operator=(const safe_VkCheckpointData2NV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + stage = copy_src.stage; + pCheckpointMarker = copy_src.pCheckpointMarker; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCheckpointData2NV::~safe_VkCheckpointData2NV() { FreePnextChain(pNext); } + +void safe_VkCheckpointData2NV::initialize(const VkCheckpointData2NV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + stage = in_struct->stage; + pCheckpointMarker = in_struct->pCheckpointMarker; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCheckpointData2NV::initialize(const safe_VkCheckpointData2NV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stage = copy_src->stage; + pCheckpointMarker = copy_src->pCheckpointMarker; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineRasterizationStateRasterizationOrderAMD::safe_VkPipelineRasterizationStateRasterizationOrderAMD( + const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), rasterizationOrder(in_struct->rasterizationOrder) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineRasterizationStateRasterizationOrderAMD::safe_VkPipelineRasterizationStateRasterizationOrderAMD() + : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD), pNext(nullptr), rasterizationOrder() {} + +safe_VkPipelineRasterizationStateRasterizationOrderAMD::safe_VkPipelineRasterizationStateRasterizationOrderAMD( + const safe_VkPipelineRasterizationStateRasterizationOrderAMD& copy_src) { + sType = copy_src.sType; + rasterizationOrder = copy_src.rasterizationOrder; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineRasterizationStateRasterizationOrderAMD& safe_VkPipelineRasterizationStateRasterizationOrderAMD::operator=( + const safe_VkPipelineRasterizationStateRasterizationOrderAMD& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + rasterizationOrder = copy_src.rasterizationOrder; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineRasterizationStateRasterizationOrderAMD::~safe_VkPipelineRasterizationStateRasterizationOrderAMD() { + FreePnextChain(pNext); +} + +void safe_VkPipelineRasterizationStateRasterizationOrderAMD::initialize( + const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + rasterizationOrder = in_struct->rasterizationOrder; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineRasterizationStateRasterizationOrderAMD::initialize( + const safe_VkPipelineRasterizationStateRasterizationOrderAMD* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + rasterizationOrder = copy_src->rasterizationOrder; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDedicatedAllocationImageCreateInfoNV::safe_VkDedicatedAllocationImageCreateInfoNV( + const VkDedicatedAllocationImageCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), dedicatedAllocation(in_struct->dedicatedAllocation) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDedicatedAllocationImageCreateInfoNV::safe_VkDedicatedAllocationImageCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV), pNext(nullptr), dedicatedAllocation() {} + +safe_VkDedicatedAllocationImageCreateInfoNV::safe_VkDedicatedAllocationImageCreateInfoNV( + const safe_VkDedicatedAllocationImageCreateInfoNV& copy_src) { + sType = copy_src.sType; + dedicatedAllocation = copy_src.dedicatedAllocation; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDedicatedAllocationImageCreateInfoNV& safe_VkDedicatedAllocationImageCreateInfoNV::operator=( + const safe_VkDedicatedAllocationImageCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + dedicatedAllocation = copy_src.dedicatedAllocation; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDedicatedAllocationImageCreateInfoNV::~safe_VkDedicatedAllocationImageCreateInfoNV() { FreePnextChain(pNext); } + +void safe_VkDedicatedAllocationImageCreateInfoNV::initialize(const VkDedicatedAllocationImageCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + dedicatedAllocation = in_struct->dedicatedAllocation; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDedicatedAllocationImageCreateInfoNV::initialize(const safe_VkDedicatedAllocationImageCreateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + dedicatedAllocation = copy_src->dedicatedAllocation; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDedicatedAllocationBufferCreateInfoNV::safe_VkDedicatedAllocationBufferCreateInfoNV( + const VkDedicatedAllocationBufferCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), dedicatedAllocation(in_struct->dedicatedAllocation) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDedicatedAllocationBufferCreateInfoNV::safe_VkDedicatedAllocationBufferCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV), pNext(nullptr), dedicatedAllocation() {} + +safe_VkDedicatedAllocationBufferCreateInfoNV::safe_VkDedicatedAllocationBufferCreateInfoNV( + const safe_VkDedicatedAllocationBufferCreateInfoNV& copy_src) { + sType = copy_src.sType; + dedicatedAllocation = copy_src.dedicatedAllocation; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDedicatedAllocationBufferCreateInfoNV& safe_VkDedicatedAllocationBufferCreateInfoNV::operator=( + const safe_VkDedicatedAllocationBufferCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + dedicatedAllocation = copy_src.dedicatedAllocation; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDedicatedAllocationBufferCreateInfoNV::~safe_VkDedicatedAllocationBufferCreateInfoNV() { FreePnextChain(pNext); } + +void safe_VkDedicatedAllocationBufferCreateInfoNV::initialize(const VkDedicatedAllocationBufferCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + dedicatedAllocation = in_struct->dedicatedAllocation; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDedicatedAllocationBufferCreateInfoNV::initialize(const safe_VkDedicatedAllocationBufferCreateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + dedicatedAllocation = copy_src->dedicatedAllocation; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDedicatedAllocationMemoryAllocateInfoNV::safe_VkDedicatedAllocationMemoryAllocateInfoNV( + const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), image(in_struct->image), buffer(in_struct->buffer) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDedicatedAllocationMemoryAllocateInfoNV::safe_VkDedicatedAllocationMemoryAllocateInfoNV() + : sType(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV), pNext(nullptr), image(), buffer() {} + +safe_VkDedicatedAllocationMemoryAllocateInfoNV::safe_VkDedicatedAllocationMemoryAllocateInfoNV( + const safe_VkDedicatedAllocationMemoryAllocateInfoNV& copy_src) { + sType = copy_src.sType; + image = copy_src.image; + buffer = copy_src.buffer; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDedicatedAllocationMemoryAllocateInfoNV& safe_VkDedicatedAllocationMemoryAllocateInfoNV::operator=( + const safe_VkDedicatedAllocationMemoryAllocateInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + image = copy_src.image; + buffer = copy_src.buffer; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDedicatedAllocationMemoryAllocateInfoNV::~safe_VkDedicatedAllocationMemoryAllocateInfoNV() { FreePnextChain(pNext); } + +void safe_VkDedicatedAllocationMemoryAllocateInfoNV::initialize(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + image = in_struct->image; + buffer = in_struct->buffer; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDedicatedAllocationMemoryAllocateInfoNV::initialize(const safe_VkDedicatedAllocationMemoryAllocateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + image = copy_src->image; + buffer = copy_src->buffer; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCuModuleCreateInfoNVX::safe_VkCuModuleCreateInfoNVX(const VkCuModuleCreateInfoNVX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), dataSize(in_struct->dataSize), pData(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + 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_VkCuModuleCreateInfoNVX::safe_VkCuModuleCreateInfoNVX() + : sType(VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX), pNext(nullptr), dataSize(), pData(nullptr) {} + +safe_VkCuModuleCreateInfoNVX::safe_VkCuModuleCreateInfoNVX(const safe_VkCuModuleCreateInfoNVX& copy_src) { + sType = copy_src.sType; + dataSize = copy_src.dataSize; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pData != nullptr) { + auto temp = new std::byte[copy_src.dataSize]; + std::memcpy(temp, copy_src.pData, copy_src.dataSize); + pData = temp; + } +} + +safe_VkCuModuleCreateInfoNVX& safe_VkCuModuleCreateInfoNVX::operator=(const safe_VkCuModuleCreateInfoNVX& copy_src) { + if (©_src == this) return *this; + + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + FreePnextChain(pNext); + + sType = copy_src.sType; + dataSize = copy_src.dataSize; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pData != nullptr) { + auto temp = new std::byte[copy_src.dataSize]; + std::memcpy(temp, copy_src.pData, copy_src.dataSize); + pData = temp; + } + + return *this; +} + +safe_VkCuModuleCreateInfoNVX::~safe_VkCuModuleCreateInfoNVX() { + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + FreePnextChain(pNext); +} + +void safe_VkCuModuleCreateInfoNVX::initialize(const VkCuModuleCreateInfoNVX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + FreePnextChain(pNext); + sType = in_struct->sType; + dataSize = in_struct->dataSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + 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_VkCuModuleCreateInfoNVX::initialize(const safe_VkCuModuleCreateInfoNVX* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + dataSize = copy_src->dataSize; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pData != nullptr) { + auto temp = new std::byte[copy_src->dataSize]; + std::memcpy(temp, copy_src->pData, copy_src->dataSize); + pData = temp; + } +} + +safe_VkCuFunctionCreateInfoNVX::safe_VkCuFunctionCreateInfoNVX(const VkCuFunctionCreateInfoNVX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), module(in_struct->module) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + pName = SafeStringCopy(in_struct->pName); +} + +safe_VkCuFunctionCreateInfoNVX::safe_VkCuFunctionCreateInfoNVX() + : sType(VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX), pNext(nullptr), module(), pName(nullptr) {} + +safe_VkCuFunctionCreateInfoNVX::safe_VkCuFunctionCreateInfoNVX(const safe_VkCuFunctionCreateInfoNVX& copy_src) { + sType = copy_src.sType; + module = copy_src.module; + pNext = SafePnextCopy(copy_src.pNext); + pName = SafeStringCopy(copy_src.pName); +} + +safe_VkCuFunctionCreateInfoNVX& safe_VkCuFunctionCreateInfoNVX::operator=(const safe_VkCuFunctionCreateInfoNVX& copy_src) { + if (©_src == this) return *this; + + if (pName) delete[] pName; + FreePnextChain(pNext); + + sType = copy_src.sType; + module = copy_src.module; + pNext = SafePnextCopy(copy_src.pNext); + pName = SafeStringCopy(copy_src.pName); + + return *this; +} + +safe_VkCuFunctionCreateInfoNVX::~safe_VkCuFunctionCreateInfoNVX() { + if (pName) delete[] pName; + FreePnextChain(pNext); +} + +void safe_VkCuFunctionCreateInfoNVX::initialize(const VkCuFunctionCreateInfoNVX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pName) delete[] pName; + FreePnextChain(pNext); + sType = in_struct->sType; + module = in_struct->module; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + pName = SafeStringCopy(in_struct->pName); +} + +void safe_VkCuFunctionCreateInfoNVX::initialize(const safe_VkCuFunctionCreateInfoNVX* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + module = copy_src->module; + pNext = SafePnextCopy(copy_src->pNext); + pName = SafeStringCopy(copy_src->pName); +} + +safe_VkCuLaunchInfoNVX::safe_VkCuLaunchInfoNVX(const VkCuLaunchInfoNVX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + function(in_struct->function), + gridDimX(in_struct->gridDimX), + gridDimY(in_struct->gridDimY), + gridDimZ(in_struct->gridDimZ), + blockDimX(in_struct->blockDimX), + blockDimY(in_struct->blockDimY), + blockDimZ(in_struct->blockDimZ), + sharedMemBytes(in_struct->sharedMemBytes), + paramCount(in_struct->paramCount), + pParams(in_struct->pParams), + extraCount(in_struct->extraCount), + pExtras(in_struct->pExtras) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCuLaunchInfoNVX::safe_VkCuLaunchInfoNVX() + : sType(VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX), + pNext(nullptr), + function(), + gridDimX(), + gridDimY(), + gridDimZ(), + blockDimX(), + blockDimY(), + blockDimZ(), + sharedMemBytes(), + paramCount(), + pParams(nullptr), + extraCount(), + pExtras(nullptr) {} + +safe_VkCuLaunchInfoNVX::safe_VkCuLaunchInfoNVX(const safe_VkCuLaunchInfoNVX& copy_src) { + sType = copy_src.sType; + function = copy_src.function; + gridDimX = copy_src.gridDimX; + gridDimY = copy_src.gridDimY; + gridDimZ = copy_src.gridDimZ; + blockDimX = copy_src.blockDimX; + blockDimY = copy_src.blockDimY; + blockDimZ = copy_src.blockDimZ; + sharedMemBytes = copy_src.sharedMemBytes; + paramCount = copy_src.paramCount; + pParams = copy_src.pParams; + extraCount = copy_src.extraCount; + pExtras = copy_src.pExtras; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCuLaunchInfoNVX& safe_VkCuLaunchInfoNVX::operator=(const safe_VkCuLaunchInfoNVX& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + function = copy_src.function; + gridDimX = copy_src.gridDimX; + gridDimY = copy_src.gridDimY; + gridDimZ = copy_src.gridDimZ; + blockDimX = copy_src.blockDimX; + blockDimY = copy_src.blockDimY; + blockDimZ = copy_src.blockDimZ; + sharedMemBytes = copy_src.sharedMemBytes; + paramCount = copy_src.paramCount; + pParams = copy_src.pParams; + extraCount = copy_src.extraCount; + pExtras = copy_src.pExtras; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCuLaunchInfoNVX::~safe_VkCuLaunchInfoNVX() { FreePnextChain(pNext); } + +void safe_VkCuLaunchInfoNVX::initialize(const VkCuLaunchInfoNVX* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + function = in_struct->function; + gridDimX = in_struct->gridDimX; + gridDimY = in_struct->gridDimY; + gridDimZ = in_struct->gridDimZ; + blockDimX = in_struct->blockDimX; + blockDimY = in_struct->blockDimY; + blockDimZ = in_struct->blockDimZ; + sharedMemBytes = in_struct->sharedMemBytes; + paramCount = in_struct->paramCount; + pParams = in_struct->pParams; + extraCount = in_struct->extraCount; + pExtras = in_struct->pExtras; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCuLaunchInfoNVX::initialize(const safe_VkCuLaunchInfoNVX* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + function = copy_src->function; + gridDimX = copy_src->gridDimX; + gridDimY = copy_src->gridDimY; + gridDimZ = copy_src->gridDimZ; + blockDimX = copy_src->blockDimX; + blockDimY = copy_src->blockDimY; + blockDimZ = copy_src->blockDimZ; + sharedMemBytes = copy_src->sharedMemBytes; + paramCount = copy_src->paramCount; + pParams = copy_src->pParams; + extraCount = copy_src->extraCount; + pExtras = copy_src->pExtras; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImageViewHandleInfoNVX::safe_VkImageViewHandleInfoNVX(const VkImageViewHandleInfoNVX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + imageView(in_struct->imageView), + descriptorType(in_struct->descriptorType), + sampler(in_struct->sampler) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageViewHandleInfoNVX::safe_VkImageViewHandleInfoNVX() + : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX), pNext(nullptr), imageView(), descriptorType(), sampler() {} + +safe_VkImageViewHandleInfoNVX::safe_VkImageViewHandleInfoNVX(const safe_VkImageViewHandleInfoNVX& copy_src) { + sType = copy_src.sType; + imageView = copy_src.imageView; + descriptorType = copy_src.descriptorType; + sampler = copy_src.sampler; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageViewHandleInfoNVX& safe_VkImageViewHandleInfoNVX::operator=(const safe_VkImageViewHandleInfoNVX& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + imageView = copy_src.imageView; + descriptorType = copy_src.descriptorType; + sampler = copy_src.sampler; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageViewHandleInfoNVX::~safe_VkImageViewHandleInfoNVX() { FreePnextChain(pNext); } + +void safe_VkImageViewHandleInfoNVX::initialize(const VkImageViewHandleInfoNVX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + imageView = in_struct->imageView; + descriptorType = in_struct->descriptorType; + sampler = in_struct->sampler; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageViewHandleInfoNVX::initialize(const safe_VkImageViewHandleInfoNVX* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + imageView = copy_src->imageView; + descriptorType = copy_src->descriptorType; + sampler = copy_src->sampler; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImageViewAddressPropertiesNVX::safe_VkImageViewAddressPropertiesNVX(const VkImageViewAddressPropertiesNVX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), deviceAddress(in_struct->deviceAddress), size(in_struct->size) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageViewAddressPropertiesNVX::safe_VkImageViewAddressPropertiesNVX() + : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX), pNext(nullptr), deviceAddress(), size() {} + +safe_VkImageViewAddressPropertiesNVX::safe_VkImageViewAddressPropertiesNVX(const safe_VkImageViewAddressPropertiesNVX& copy_src) { + sType = copy_src.sType; + deviceAddress = copy_src.deviceAddress; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageViewAddressPropertiesNVX& safe_VkImageViewAddressPropertiesNVX::operator=( + const safe_VkImageViewAddressPropertiesNVX& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + deviceAddress = copy_src.deviceAddress; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageViewAddressPropertiesNVX::~safe_VkImageViewAddressPropertiesNVX() { FreePnextChain(pNext); } + +void safe_VkImageViewAddressPropertiesNVX::initialize(const VkImageViewAddressPropertiesNVX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + deviceAddress = in_struct->deviceAddress; + size = in_struct->size; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageViewAddressPropertiesNVX::initialize(const safe_VkImageViewAddressPropertiesNVX* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + deviceAddress = copy_src->deviceAddress; + size = copy_src->size; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkTextureLODGatherFormatPropertiesAMD::safe_VkTextureLODGatherFormatPropertiesAMD( + const VkTextureLODGatherFormatPropertiesAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), supportsTextureGatherLODBiasAMD(in_struct->supportsTextureGatherLODBiasAMD) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkTextureLODGatherFormatPropertiesAMD::safe_VkTextureLODGatherFormatPropertiesAMD() + : sType(VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD), pNext(nullptr), supportsTextureGatherLODBiasAMD() {} + +safe_VkTextureLODGatherFormatPropertiesAMD::safe_VkTextureLODGatherFormatPropertiesAMD( + const safe_VkTextureLODGatherFormatPropertiesAMD& copy_src) { + sType = copy_src.sType; + supportsTextureGatherLODBiasAMD = copy_src.supportsTextureGatherLODBiasAMD; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkTextureLODGatherFormatPropertiesAMD& safe_VkTextureLODGatherFormatPropertiesAMD::operator=( + const safe_VkTextureLODGatherFormatPropertiesAMD& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + supportsTextureGatherLODBiasAMD = copy_src.supportsTextureGatherLODBiasAMD; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkTextureLODGatherFormatPropertiesAMD::~safe_VkTextureLODGatherFormatPropertiesAMD() { FreePnextChain(pNext); } + +void safe_VkTextureLODGatherFormatPropertiesAMD::initialize(const VkTextureLODGatherFormatPropertiesAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + supportsTextureGatherLODBiasAMD = in_struct->supportsTextureGatherLODBiasAMD; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkTextureLODGatherFormatPropertiesAMD::initialize(const safe_VkTextureLODGatherFormatPropertiesAMD* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + supportsTextureGatherLODBiasAMD = copy_src->supportsTextureGatherLODBiasAMD; + pNext = SafePnextCopy(copy_src->pNext); +} +#ifdef VK_USE_PLATFORM_GGP + +safe_VkStreamDescriptorSurfaceCreateInfoGGP::safe_VkStreamDescriptorSurfaceCreateInfoGGP( + const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), streamDescriptor(in_struct->streamDescriptor) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkStreamDescriptorSurfaceCreateInfoGGP::safe_VkStreamDescriptorSurfaceCreateInfoGGP() + : sType(VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP), pNext(nullptr), flags(), streamDescriptor() {} + +safe_VkStreamDescriptorSurfaceCreateInfoGGP::safe_VkStreamDescriptorSurfaceCreateInfoGGP( + const safe_VkStreamDescriptorSurfaceCreateInfoGGP& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + streamDescriptor = copy_src.streamDescriptor; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkStreamDescriptorSurfaceCreateInfoGGP& safe_VkStreamDescriptorSurfaceCreateInfoGGP::operator=( + const safe_VkStreamDescriptorSurfaceCreateInfoGGP& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + streamDescriptor = copy_src.streamDescriptor; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkStreamDescriptorSurfaceCreateInfoGGP::~safe_VkStreamDescriptorSurfaceCreateInfoGGP() { FreePnextChain(pNext); } + +void safe_VkStreamDescriptorSurfaceCreateInfoGGP::initialize(const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + streamDescriptor = in_struct->streamDescriptor; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkStreamDescriptorSurfaceCreateInfoGGP::initialize(const safe_VkStreamDescriptorSurfaceCreateInfoGGP* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + streamDescriptor = copy_src->streamDescriptor; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_GGP + +safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::safe_VkPhysicalDeviceCornerSampledImageFeaturesNV( + const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), cornerSampledImage(in_struct->cornerSampledImage) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::safe_VkPhysicalDeviceCornerSampledImageFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV), pNext(nullptr), cornerSampledImage() {} + +safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::safe_VkPhysicalDeviceCornerSampledImageFeaturesNV( + const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& copy_src) { + sType = copy_src.sType; + cornerSampledImage = copy_src.cornerSampledImage; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::operator=( + const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + cornerSampledImage = copy_src.cornerSampledImage; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::~safe_VkPhysicalDeviceCornerSampledImageFeaturesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::initialize(const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + cornerSampledImage = in_struct->cornerSampledImage; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::initialize( + const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + cornerSampledImage = copy_src->cornerSampledImage; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExternalMemoryImageCreateInfoNV::safe_VkExternalMemoryImageCreateInfoNV(const VkExternalMemoryImageCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), handleTypes(in_struct->handleTypes) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExternalMemoryImageCreateInfoNV::safe_VkExternalMemoryImageCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV), pNext(nullptr), handleTypes() {} + +safe_VkExternalMemoryImageCreateInfoNV::safe_VkExternalMemoryImageCreateInfoNV( + const safe_VkExternalMemoryImageCreateInfoNV& copy_src) { + sType = copy_src.sType; + handleTypes = copy_src.handleTypes; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExternalMemoryImageCreateInfoNV& safe_VkExternalMemoryImageCreateInfoNV::operator=( + const safe_VkExternalMemoryImageCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + handleTypes = copy_src.handleTypes; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExternalMemoryImageCreateInfoNV::~safe_VkExternalMemoryImageCreateInfoNV() { FreePnextChain(pNext); } + +void safe_VkExternalMemoryImageCreateInfoNV::initialize(const VkExternalMemoryImageCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + handleTypes = in_struct->handleTypes; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExternalMemoryImageCreateInfoNV::initialize(const safe_VkExternalMemoryImageCreateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + handleTypes = copy_src->handleTypes; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExportMemoryAllocateInfoNV::safe_VkExportMemoryAllocateInfoNV(const VkExportMemoryAllocateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), handleTypes(in_struct->handleTypes) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExportMemoryAllocateInfoNV::safe_VkExportMemoryAllocateInfoNV() + : sType(VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV), pNext(nullptr), handleTypes() {} + +safe_VkExportMemoryAllocateInfoNV::safe_VkExportMemoryAllocateInfoNV(const safe_VkExportMemoryAllocateInfoNV& copy_src) { + sType = copy_src.sType; + handleTypes = copy_src.handleTypes; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExportMemoryAllocateInfoNV& safe_VkExportMemoryAllocateInfoNV::operator=(const safe_VkExportMemoryAllocateInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + handleTypes = copy_src.handleTypes; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExportMemoryAllocateInfoNV::~safe_VkExportMemoryAllocateInfoNV() { FreePnextChain(pNext); } + +void safe_VkExportMemoryAllocateInfoNV::initialize(const VkExportMemoryAllocateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + handleTypes = in_struct->handleTypes; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExportMemoryAllocateInfoNV::initialize(const safe_VkExportMemoryAllocateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + handleTypes = copy_src->handleTypes; + pNext = SafePnextCopy(copy_src->pNext); +} +#ifdef VK_USE_PLATFORM_WIN32_KHR + +safe_VkImportMemoryWin32HandleInfoNV::safe_VkImportMemoryWin32HandleInfoNV(const VkImportMemoryWin32HandleInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), handleType(in_struct->handleType), handle(in_struct->handle) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImportMemoryWin32HandleInfoNV::safe_VkImportMemoryWin32HandleInfoNV() + : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV), pNext(nullptr), handleType(), handle() {} + +safe_VkImportMemoryWin32HandleInfoNV::safe_VkImportMemoryWin32HandleInfoNV(const safe_VkImportMemoryWin32HandleInfoNV& copy_src) { + sType = copy_src.sType; + handleType = copy_src.handleType; + handle = copy_src.handle; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImportMemoryWin32HandleInfoNV& safe_VkImportMemoryWin32HandleInfoNV::operator=( + const safe_VkImportMemoryWin32HandleInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + handleType = copy_src.handleType; + handle = copy_src.handle; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImportMemoryWin32HandleInfoNV::~safe_VkImportMemoryWin32HandleInfoNV() { FreePnextChain(pNext); } + +void safe_VkImportMemoryWin32HandleInfoNV::initialize(const VkImportMemoryWin32HandleInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + handleType = in_struct->handleType; + handle = in_struct->handle; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImportMemoryWin32HandleInfoNV::initialize(const safe_VkImportMemoryWin32HandleInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + handleType = copy_src->handleType; + handle = copy_src->handle; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExportMemoryWin32HandleInfoNV::safe_VkExportMemoryWin32HandleInfoNV(const VkExportMemoryWin32HandleInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), pAttributes(nullptr), dwAccess(in_struct->dwAccess) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes); + } +} + +safe_VkExportMemoryWin32HandleInfoNV::safe_VkExportMemoryWin32HandleInfoNV() + : sType(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV), pNext(nullptr), pAttributes(nullptr), dwAccess() {} + +safe_VkExportMemoryWin32HandleInfoNV::safe_VkExportMemoryWin32HandleInfoNV(const safe_VkExportMemoryWin32HandleInfoNV& copy_src) { + sType = copy_src.sType; + pAttributes = nullptr; + dwAccess = copy_src.dwAccess; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes); + } +} + +safe_VkExportMemoryWin32HandleInfoNV& safe_VkExportMemoryWin32HandleInfoNV::operator=( + const safe_VkExportMemoryWin32HandleInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pAttributes) delete pAttributes; + FreePnextChain(pNext); + + sType = copy_src.sType; + pAttributes = nullptr; + dwAccess = copy_src.dwAccess; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes); + } + + return *this; +} + +safe_VkExportMemoryWin32HandleInfoNV::~safe_VkExportMemoryWin32HandleInfoNV() { + if (pAttributes) delete pAttributes; + FreePnextChain(pNext); +} + +void safe_VkExportMemoryWin32HandleInfoNV::initialize(const VkExportMemoryWin32HandleInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pAttributes) delete pAttributes; + FreePnextChain(pNext); + sType = in_struct->sType; + pAttributes = nullptr; + dwAccess = in_struct->dwAccess; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes); + } +} + +void safe_VkExportMemoryWin32HandleInfoNV::initialize(const safe_VkExportMemoryWin32HandleInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pAttributes = nullptr; + dwAccess = copy_src->dwAccess; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pAttributes) { + pAttributes = new SECURITY_ATTRIBUTES(*copy_src->pAttributes); + } +} + +safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireReleaseInfoNV( + const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + acquireCount(in_struct->acquireCount), + pAcquireSyncs(nullptr), + pAcquireKeys(nullptr), + pAcquireTimeoutMilliseconds(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]; + } + } + + 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->pAcquireTimeoutMilliseconds) { + pAcquireTimeoutMilliseconds = new uint32_t[in_struct->acquireCount]; + memcpy((void*)pAcquireTimeoutMilliseconds, (void*)in_struct->pAcquireTimeoutMilliseconds, + 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); + } +} + +safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireReleaseInfoNV() + : sType(VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV), + pNext(nullptr), + acquireCount(), + pAcquireSyncs(nullptr), + pAcquireKeys(nullptr), + pAcquireTimeoutMilliseconds(nullptr), + releaseCount(), + pReleaseSyncs(nullptr), + pReleaseKeys(nullptr) {} + +safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireReleaseInfoNV( + const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& copy_src) { + sType = copy_src.sType; + acquireCount = copy_src.acquireCount; + pAcquireSyncs = nullptr; + pAcquireKeys = nullptr; + pAcquireTimeoutMilliseconds = 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.pAcquireTimeoutMilliseconds) { + pAcquireTimeoutMilliseconds = new uint32_t[copy_src.acquireCount]; + memcpy((void*)pAcquireTimeoutMilliseconds, (void*)copy_src.pAcquireTimeoutMilliseconds, + 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_VkWin32KeyedMutexAcquireReleaseInfoNV& safe_VkWin32KeyedMutexAcquireReleaseInfoNV::operator=( + const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pAcquireSyncs) delete[] pAcquireSyncs; + if (pAcquireKeys) delete[] pAcquireKeys; + if (pAcquireTimeoutMilliseconds) delete[] pAcquireTimeoutMilliseconds; + if (pReleaseSyncs) delete[] pReleaseSyncs; + if (pReleaseKeys) delete[] pReleaseKeys; + FreePnextChain(pNext); + + sType = copy_src.sType; + acquireCount = copy_src.acquireCount; + pAcquireSyncs = nullptr; + pAcquireKeys = nullptr; + pAcquireTimeoutMilliseconds = 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.pAcquireTimeoutMilliseconds) { + pAcquireTimeoutMilliseconds = new uint32_t[copy_src.acquireCount]; + memcpy((void*)pAcquireTimeoutMilliseconds, (void*)copy_src.pAcquireTimeoutMilliseconds, + 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_VkWin32KeyedMutexAcquireReleaseInfoNV::~safe_VkWin32KeyedMutexAcquireReleaseInfoNV() { + if (pAcquireSyncs) delete[] pAcquireSyncs; + if (pAcquireKeys) delete[] pAcquireKeys; + if (pAcquireTimeoutMilliseconds) delete[] pAcquireTimeoutMilliseconds; + if (pReleaseSyncs) delete[] pReleaseSyncs; + if (pReleaseKeys) delete[] pReleaseKeys; + FreePnextChain(pNext); +} + +void safe_VkWin32KeyedMutexAcquireReleaseInfoNV::initialize(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pAcquireSyncs) delete[] pAcquireSyncs; + if (pAcquireKeys) delete[] pAcquireKeys; + if (pAcquireTimeoutMilliseconds) delete[] pAcquireTimeoutMilliseconds; + if (pReleaseSyncs) delete[] pReleaseSyncs; + if (pReleaseKeys) delete[] pReleaseKeys; + FreePnextChain(pNext); + sType = in_struct->sType; + acquireCount = in_struct->acquireCount; + pAcquireSyncs = nullptr; + pAcquireKeys = nullptr; + pAcquireTimeoutMilliseconds = 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->pAcquireTimeoutMilliseconds) { + pAcquireTimeoutMilliseconds = new uint32_t[in_struct->acquireCount]; + memcpy((void*)pAcquireTimeoutMilliseconds, (void*)in_struct->pAcquireTimeoutMilliseconds, + 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_VkWin32KeyedMutexAcquireReleaseInfoNV::initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + acquireCount = copy_src->acquireCount; + pAcquireSyncs = nullptr; + pAcquireKeys = nullptr; + pAcquireTimeoutMilliseconds = 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->pAcquireTimeoutMilliseconds) { + pAcquireTimeoutMilliseconds = new uint32_t[copy_src->acquireCount]; + memcpy((void*)pAcquireTimeoutMilliseconds, (void*)copy_src->pAcquireTimeoutMilliseconds, + 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); + } +} +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_VI_NN + +safe_VkViSurfaceCreateInfoNN::safe_VkViSurfaceCreateInfoNN(const VkViSurfaceCreateInfoNN* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), window(in_struct->window) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkViSurfaceCreateInfoNN::safe_VkViSurfaceCreateInfoNN() + : sType(VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN), pNext(nullptr), flags(), window(nullptr) {} + +safe_VkViSurfaceCreateInfoNN::safe_VkViSurfaceCreateInfoNN(const safe_VkViSurfaceCreateInfoNN& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + window = copy_src.window; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkViSurfaceCreateInfoNN& safe_VkViSurfaceCreateInfoNN::operator=(const safe_VkViSurfaceCreateInfoNN& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + window = copy_src.window; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkViSurfaceCreateInfoNN::~safe_VkViSurfaceCreateInfoNN() { FreePnextChain(pNext); } + +void safe_VkViSurfaceCreateInfoNN::initialize(const VkViSurfaceCreateInfoNN* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + window = in_struct->window; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkViSurfaceCreateInfoNN::initialize(const safe_VkViSurfaceCreateInfoNN* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + window = copy_src->window; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_VI_NN + +safe_VkPipelineViewportWScalingStateCreateInfoNV::safe_VkPipelineViewportWScalingStateCreateInfoNV( + const VkPipelineViewportWScalingStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + viewportWScalingEnable(in_struct->viewportWScalingEnable), + viewportCount(in_struct->viewportCount), + pViewportWScalings(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pViewportWScalings) { + pViewportWScalings = new VkViewportWScalingNV[in_struct->viewportCount]; + memcpy((void*)pViewportWScalings, (void*)in_struct->pViewportWScalings, + sizeof(VkViewportWScalingNV) * in_struct->viewportCount); + } +} + +safe_VkPipelineViewportWScalingStateCreateInfoNV::safe_VkPipelineViewportWScalingStateCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV), + pNext(nullptr), + viewportWScalingEnable(), + viewportCount(), + pViewportWScalings(nullptr) {} + +safe_VkPipelineViewportWScalingStateCreateInfoNV::safe_VkPipelineViewportWScalingStateCreateInfoNV( + const safe_VkPipelineViewportWScalingStateCreateInfoNV& copy_src) { + sType = copy_src.sType; + viewportWScalingEnable = copy_src.viewportWScalingEnable; + viewportCount = copy_src.viewportCount; + pViewportWScalings = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pViewportWScalings) { + pViewportWScalings = new VkViewportWScalingNV[copy_src.viewportCount]; + memcpy((void*)pViewportWScalings, (void*)copy_src.pViewportWScalings, + sizeof(VkViewportWScalingNV) * copy_src.viewportCount); + } +} + +safe_VkPipelineViewportWScalingStateCreateInfoNV& safe_VkPipelineViewportWScalingStateCreateInfoNV::operator=( + const safe_VkPipelineViewportWScalingStateCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pViewportWScalings) delete[] pViewportWScalings; + FreePnextChain(pNext); + + sType = copy_src.sType; + viewportWScalingEnable = copy_src.viewportWScalingEnable; + viewportCount = copy_src.viewportCount; + pViewportWScalings = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pViewportWScalings) { + pViewportWScalings = new VkViewportWScalingNV[copy_src.viewportCount]; + memcpy((void*)pViewportWScalings, (void*)copy_src.pViewportWScalings, + sizeof(VkViewportWScalingNV) * copy_src.viewportCount); + } + + return *this; +} + +safe_VkPipelineViewportWScalingStateCreateInfoNV::~safe_VkPipelineViewportWScalingStateCreateInfoNV() { + if (pViewportWScalings) delete[] pViewportWScalings; + FreePnextChain(pNext); +} + +void safe_VkPipelineViewportWScalingStateCreateInfoNV::initialize(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pViewportWScalings) delete[] pViewportWScalings; + FreePnextChain(pNext); + sType = in_struct->sType; + viewportWScalingEnable = in_struct->viewportWScalingEnable; + viewportCount = in_struct->viewportCount; + pViewportWScalings = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pViewportWScalings) { + pViewportWScalings = new VkViewportWScalingNV[in_struct->viewportCount]; + memcpy((void*)pViewportWScalings, (void*)in_struct->pViewportWScalings, + sizeof(VkViewportWScalingNV) * in_struct->viewportCount); + } +} + +void safe_VkPipelineViewportWScalingStateCreateInfoNV::initialize(const safe_VkPipelineViewportWScalingStateCreateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + viewportWScalingEnable = copy_src->viewportWScalingEnable; + viewportCount = copy_src->viewportCount; + pViewportWScalings = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pViewportWScalings) { + pViewportWScalings = new VkViewportWScalingNV[copy_src->viewportCount]; + memcpy((void*)pViewportWScalings, (void*)copy_src->pViewportWScalings, + sizeof(VkViewportWScalingNV) * copy_src->viewportCount); + } +} + +safe_VkPresentTimesInfoGOOGLE::safe_VkPresentTimesInfoGOOGLE(const VkPresentTimesInfoGOOGLE* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pTimes(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pTimes) { + pTimes = new VkPresentTimeGOOGLE[in_struct->swapchainCount]; + memcpy((void*)pTimes, (void*)in_struct->pTimes, sizeof(VkPresentTimeGOOGLE) * in_struct->swapchainCount); + } +} + +safe_VkPresentTimesInfoGOOGLE::safe_VkPresentTimesInfoGOOGLE() + : sType(VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE), pNext(nullptr), swapchainCount(), pTimes(nullptr) {} + +safe_VkPresentTimesInfoGOOGLE::safe_VkPresentTimesInfoGOOGLE(const safe_VkPresentTimesInfoGOOGLE& copy_src) { + sType = copy_src.sType; + swapchainCount = copy_src.swapchainCount; + pTimes = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pTimes) { + pTimes = new VkPresentTimeGOOGLE[copy_src.swapchainCount]; + memcpy((void*)pTimes, (void*)copy_src.pTimes, sizeof(VkPresentTimeGOOGLE) * copy_src.swapchainCount); + } +} + +safe_VkPresentTimesInfoGOOGLE& safe_VkPresentTimesInfoGOOGLE::operator=(const safe_VkPresentTimesInfoGOOGLE& copy_src) { + if (©_src == this) return *this; + + if (pTimes) delete[] pTimes; + FreePnextChain(pNext); + + sType = copy_src.sType; + swapchainCount = copy_src.swapchainCount; + pTimes = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pTimes) { + pTimes = new VkPresentTimeGOOGLE[copy_src.swapchainCount]; + memcpy((void*)pTimes, (void*)copy_src.pTimes, sizeof(VkPresentTimeGOOGLE) * copy_src.swapchainCount); + } + + return *this; +} + +safe_VkPresentTimesInfoGOOGLE::~safe_VkPresentTimesInfoGOOGLE() { + if (pTimes) delete[] pTimes; + FreePnextChain(pNext); +} + +void safe_VkPresentTimesInfoGOOGLE::initialize(const VkPresentTimesInfoGOOGLE* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pTimes) delete[] pTimes; + FreePnextChain(pNext); + sType = in_struct->sType; + swapchainCount = in_struct->swapchainCount; + pTimes = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pTimes) { + pTimes = new VkPresentTimeGOOGLE[in_struct->swapchainCount]; + memcpy((void*)pTimes, (void*)in_struct->pTimes, sizeof(VkPresentTimeGOOGLE) * in_struct->swapchainCount); + } +} + +void safe_VkPresentTimesInfoGOOGLE::initialize(const safe_VkPresentTimesInfoGOOGLE* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + swapchainCount = copy_src->swapchainCount; + pTimes = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pTimes) { + pTimes = new VkPresentTimeGOOGLE[copy_src->swapchainCount]; + memcpy((void*)pTimes, (void*)copy_src->pTimes, sizeof(VkPresentTimeGOOGLE) * copy_src->swapchainCount); + } +} + +safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( + const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), perViewPositionAllComponents(in_struct->perViewPositionAllComponents) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX), + pNext(nullptr), + perViewPositionAllComponents() {} + +safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( + const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& copy_src) { + sType = copy_src.sType; + perViewPositionAllComponents = copy_src.perViewPositionAllComponents; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& +safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::operator=( + const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + perViewPositionAllComponents = copy_src.perViewPositionAllComponents; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::~safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::initialize( + const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + perViewPositionAllComponents = in_struct->perViewPositionAllComponents; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::initialize( + const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + perViewPositionAllComponents = copy_src->perViewPositionAllComponents; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineViewportSwizzleStateCreateInfoNV::safe_VkPipelineViewportSwizzleStateCreateInfoNV( + const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), viewportCount(in_struct->viewportCount), pViewportSwizzles(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pViewportSwizzles) { + pViewportSwizzles = new VkViewportSwizzleNV[in_struct->viewportCount]; + memcpy((void*)pViewportSwizzles, (void*)in_struct->pViewportSwizzles, + sizeof(VkViewportSwizzleNV) * in_struct->viewportCount); + } +} + +safe_VkPipelineViewportSwizzleStateCreateInfoNV::safe_VkPipelineViewportSwizzleStateCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV), + pNext(nullptr), + flags(), + viewportCount(), + pViewportSwizzles(nullptr) {} + +safe_VkPipelineViewportSwizzleStateCreateInfoNV::safe_VkPipelineViewportSwizzleStateCreateInfoNV( + const safe_VkPipelineViewportSwizzleStateCreateInfoNV& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + viewportCount = copy_src.viewportCount; + pViewportSwizzles = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pViewportSwizzles) { + pViewportSwizzles = new VkViewportSwizzleNV[copy_src.viewportCount]; + memcpy((void*)pViewportSwizzles, (void*)copy_src.pViewportSwizzles, sizeof(VkViewportSwizzleNV) * copy_src.viewportCount); + } +} + +safe_VkPipelineViewportSwizzleStateCreateInfoNV& safe_VkPipelineViewportSwizzleStateCreateInfoNV::operator=( + const safe_VkPipelineViewportSwizzleStateCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pViewportSwizzles) delete[] pViewportSwizzles; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + viewportCount = copy_src.viewportCount; + pViewportSwizzles = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pViewportSwizzles) { + pViewportSwizzles = new VkViewportSwizzleNV[copy_src.viewportCount]; + memcpy((void*)pViewportSwizzles, (void*)copy_src.pViewportSwizzles, sizeof(VkViewportSwizzleNV) * copy_src.viewportCount); + } + + return *this; +} + +safe_VkPipelineViewportSwizzleStateCreateInfoNV::~safe_VkPipelineViewportSwizzleStateCreateInfoNV() { + if (pViewportSwizzles) delete[] pViewportSwizzles; + FreePnextChain(pNext); +} + +void safe_VkPipelineViewportSwizzleStateCreateInfoNV::initialize(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pViewportSwizzles) delete[] pViewportSwizzles; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + viewportCount = in_struct->viewportCount; + pViewportSwizzles = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pViewportSwizzles) { + pViewportSwizzles = new VkViewportSwizzleNV[in_struct->viewportCount]; + memcpy((void*)pViewportSwizzles, (void*)in_struct->pViewportSwizzles, + sizeof(VkViewportSwizzleNV) * in_struct->viewportCount); + } +} + +void safe_VkPipelineViewportSwizzleStateCreateInfoNV::initialize(const safe_VkPipelineViewportSwizzleStateCreateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + viewportCount = copy_src->viewportCount; + pViewportSwizzles = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pViewportSwizzles) { + pViewportSwizzles = new VkViewportSwizzleNV[copy_src->viewportCount]; + memcpy((void*)pViewportSwizzles, (void*)copy_src->pViewportSwizzles, sizeof(VkViewportSwizzleNV) * copy_src->viewportCount); + } +} + +safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG::safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG( + const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), relaxedLineRasterization(in_struct->relaxedLineRasterization) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG::safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG), + pNext(nullptr), + relaxedLineRasterization() {} + +safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG::safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG( + const safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& copy_src) { + sType = copy_src.sType; + relaxedLineRasterization = copy_src.relaxedLineRasterization; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG::operator=( + const safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + relaxedLineRasterization = copy_src.relaxedLineRasterization; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG::~safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG::initialize( + const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + relaxedLineRasterization = in_struct->relaxedLineRasterization; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG::initialize( + const safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + relaxedLineRasterization = copy_src->relaxedLineRasterization; + pNext = SafePnextCopy(copy_src->pNext); +} +#ifdef VK_USE_PLATFORM_ANDROID_KHR + +safe_VkAndroidHardwareBufferUsageANDROID::safe_VkAndroidHardwareBufferUsageANDROID( + const VkAndroidHardwareBufferUsageANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), androidHardwareBufferUsage(in_struct->androidHardwareBufferUsage) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAndroidHardwareBufferUsageANDROID::safe_VkAndroidHardwareBufferUsageANDROID() + : sType(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID), pNext(nullptr), androidHardwareBufferUsage() {} + +safe_VkAndroidHardwareBufferUsageANDROID::safe_VkAndroidHardwareBufferUsageANDROID( + const safe_VkAndroidHardwareBufferUsageANDROID& copy_src) { + sType = copy_src.sType; + androidHardwareBufferUsage = copy_src.androidHardwareBufferUsage; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAndroidHardwareBufferUsageANDROID& safe_VkAndroidHardwareBufferUsageANDROID::operator=( + const safe_VkAndroidHardwareBufferUsageANDROID& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + androidHardwareBufferUsage = copy_src.androidHardwareBufferUsage; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAndroidHardwareBufferUsageANDROID::~safe_VkAndroidHardwareBufferUsageANDROID() { FreePnextChain(pNext); } + +void safe_VkAndroidHardwareBufferUsageANDROID::initialize(const VkAndroidHardwareBufferUsageANDROID* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + androidHardwareBufferUsage = in_struct->androidHardwareBufferUsage; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAndroidHardwareBufferUsageANDROID::initialize(const safe_VkAndroidHardwareBufferUsageANDROID* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + androidHardwareBufferUsage = copy_src->androidHardwareBufferUsage; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAndroidHardwareBufferPropertiesANDROID::safe_VkAndroidHardwareBufferPropertiesANDROID( + const VkAndroidHardwareBufferPropertiesANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), allocationSize(in_struct->allocationSize), memoryTypeBits(in_struct->memoryTypeBits) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAndroidHardwareBufferPropertiesANDROID::safe_VkAndroidHardwareBufferPropertiesANDROID() + : sType(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID), pNext(nullptr), allocationSize(), memoryTypeBits() {} + +safe_VkAndroidHardwareBufferPropertiesANDROID::safe_VkAndroidHardwareBufferPropertiesANDROID( + const safe_VkAndroidHardwareBufferPropertiesANDROID& copy_src) { + sType = copy_src.sType; + allocationSize = copy_src.allocationSize; + memoryTypeBits = copy_src.memoryTypeBits; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAndroidHardwareBufferPropertiesANDROID& safe_VkAndroidHardwareBufferPropertiesANDROID::operator=( + const safe_VkAndroidHardwareBufferPropertiesANDROID& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + allocationSize = copy_src.allocationSize; + memoryTypeBits = copy_src.memoryTypeBits; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAndroidHardwareBufferPropertiesANDROID::~safe_VkAndroidHardwareBufferPropertiesANDROID() { FreePnextChain(pNext); } + +void safe_VkAndroidHardwareBufferPropertiesANDROID::initialize(const VkAndroidHardwareBufferPropertiesANDROID* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + allocationSize = in_struct->allocationSize; + memoryTypeBits = in_struct->memoryTypeBits; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAndroidHardwareBufferPropertiesANDROID::initialize(const safe_VkAndroidHardwareBufferPropertiesANDROID* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + allocationSize = copy_src->allocationSize; + memoryTypeBits = copy_src->memoryTypeBits; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAndroidHardwareBufferFormatPropertiesANDROID::safe_VkAndroidHardwareBufferFormatPropertiesANDROID( + const VkAndroidHardwareBufferFormatPropertiesANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + format(in_struct->format), + externalFormat(in_struct->externalFormat), + formatFeatures(in_struct->formatFeatures), + samplerYcbcrConversionComponents(in_struct->samplerYcbcrConversionComponents), + suggestedYcbcrModel(in_struct->suggestedYcbcrModel), + suggestedYcbcrRange(in_struct->suggestedYcbcrRange), + suggestedXChromaOffset(in_struct->suggestedXChromaOffset), + suggestedYChromaOffset(in_struct->suggestedYChromaOffset) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAndroidHardwareBufferFormatPropertiesANDROID::safe_VkAndroidHardwareBufferFormatPropertiesANDROID() + : sType(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID), + pNext(nullptr), + format(), + externalFormat(), + formatFeatures(), + samplerYcbcrConversionComponents(), + suggestedYcbcrModel(), + suggestedYcbcrRange(), + suggestedXChromaOffset(), + suggestedYChromaOffset() {} + +safe_VkAndroidHardwareBufferFormatPropertiesANDROID::safe_VkAndroidHardwareBufferFormatPropertiesANDROID( + const safe_VkAndroidHardwareBufferFormatPropertiesANDROID& copy_src) { + sType = copy_src.sType; + format = copy_src.format; + externalFormat = copy_src.externalFormat; + formatFeatures = copy_src.formatFeatures; + samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents; + suggestedYcbcrModel = copy_src.suggestedYcbcrModel; + suggestedYcbcrRange = copy_src.suggestedYcbcrRange; + suggestedXChromaOffset = copy_src.suggestedXChromaOffset; + suggestedYChromaOffset = copy_src.suggestedYChromaOffset; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAndroidHardwareBufferFormatPropertiesANDROID& safe_VkAndroidHardwareBufferFormatPropertiesANDROID::operator=( + const safe_VkAndroidHardwareBufferFormatPropertiesANDROID& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + format = copy_src.format; + externalFormat = copy_src.externalFormat; + formatFeatures = copy_src.formatFeatures; + samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents; + suggestedYcbcrModel = copy_src.suggestedYcbcrModel; + suggestedYcbcrRange = copy_src.suggestedYcbcrRange; + suggestedXChromaOffset = copy_src.suggestedXChromaOffset; + suggestedYChromaOffset = copy_src.suggestedYChromaOffset; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAndroidHardwareBufferFormatPropertiesANDROID::~safe_VkAndroidHardwareBufferFormatPropertiesANDROID() { + FreePnextChain(pNext); +} + +void safe_VkAndroidHardwareBufferFormatPropertiesANDROID::initialize( + const VkAndroidHardwareBufferFormatPropertiesANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + format = in_struct->format; + externalFormat = in_struct->externalFormat; + formatFeatures = in_struct->formatFeatures; + samplerYcbcrConversionComponents = in_struct->samplerYcbcrConversionComponents; + suggestedYcbcrModel = in_struct->suggestedYcbcrModel; + suggestedYcbcrRange = in_struct->suggestedYcbcrRange; + suggestedXChromaOffset = in_struct->suggestedXChromaOffset; + suggestedYChromaOffset = in_struct->suggestedYChromaOffset; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAndroidHardwareBufferFormatPropertiesANDROID::initialize( + const safe_VkAndroidHardwareBufferFormatPropertiesANDROID* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + format = copy_src->format; + externalFormat = copy_src->externalFormat; + formatFeatures = copy_src->formatFeatures; + samplerYcbcrConversionComponents = copy_src->samplerYcbcrConversionComponents; + suggestedYcbcrModel = copy_src->suggestedYcbcrModel; + suggestedYcbcrRange = copy_src->suggestedYcbcrRange; + suggestedXChromaOffset = copy_src->suggestedXChromaOffset; + suggestedYChromaOffset = copy_src->suggestedYChromaOffset; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImportAndroidHardwareBufferInfoANDROID::safe_VkImportAndroidHardwareBufferInfoANDROID( + const VkImportAndroidHardwareBufferInfoANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), buffer(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + buffer = in_struct->buffer; +} + +safe_VkImportAndroidHardwareBufferInfoANDROID::safe_VkImportAndroidHardwareBufferInfoANDROID() + : sType(VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID), pNext(nullptr), buffer(nullptr) {} + +safe_VkImportAndroidHardwareBufferInfoANDROID::safe_VkImportAndroidHardwareBufferInfoANDROID( + const safe_VkImportAndroidHardwareBufferInfoANDROID& copy_src) { + sType = copy_src.sType; + pNext = SafePnextCopy(copy_src.pNext); + buffer = copy_src.buffer; +} + +safe_VkImportAndroidHardwareBufferInfoANDROID& safe_VkImportAndroidHardwareBufferInfoANDROID::operator=( + const safe_VkImportAndroidHardwareBufferInfoANDROID& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pNext = SafePnextCopy(copy_src.pNext); + buffer = copy_src.buffer; + + return *this; +} + +safe_VkImportAndroidHardwareBufferInfoANDROID::~safe_VkImportAndroidHardwareBufferInfoANDROID() { FreePnextChain(pNext); } + +void safe_VkImportAndroidHardwareBufferInfoANDROID::initialize(const VkImportAndroidHardwareBufferInfoANDROID* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + buffer = in_struct->buffer; +} + +void safe_VkImportAndroidHardwareBufferInfoANDROID::initialize(const safe_VkImportAndroidHardwareBufferInfoANDROID* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pNext = SafePnextCopy(copy_src->pNext); + buffer = copy_src->buffer; +} + +safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::safe_VkMemoryGetAndroidHardwareBufferInfoANDROID( + const VkMemoryGetAndroidHardwareBufferInfoANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), memory(in_struct->memory) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::safe_VkMemoryGetAndroidHardwareBufferInfoANDROID() + : sType(VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID), pNext(nullptr), memory() {} + +safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::safe_VkMemoryGetAndroidHardwareBufferInfoANDROID( + const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& copy_src) { + sType = copy_src.sType; + memory = copy_src.memory; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::operator=( + const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memory = copy_src.memory; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::~safe_VkMemoryGetAndroidHardwareBufferInfoANDROID() { FreePnextChain(pNext); } + +void safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::initialize(const VkMemoryGetAndroidHardwareBufferInfoANDROID* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memory = in_struct->memory; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::initialize(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memory = copy_src->memory; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExternalFormatANDROID::safe_VkExternalFormatANDROID(const VkExternalFormatANDROID* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), externalFormat(in_struct->externalFormat) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExternalFormatANDROID::safe_VkExternalFormatANDROID() + : sType(VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID), pNext(nullptr), externalFormat() {} + +safe_VkExternalFormatANDROID::safe_VkExternalFormatANDROID(const safe_VkExternalFormatANDROID& copy_src) { + sType = copy_src.sType; + externalFormat = copy_src.externalFormat; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExternalFormatANDROID& safe_VkExternalFormatANDROID::operator=(const safe_VkExternalFormatANDROID& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + externalFormat = copy_src.externalFormat; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExternalFormatANDROID::~safe_VkExternalFormatANDROID() { FreePnextChain(pNext); } + +void safe_VkExternalFormatANDROID::initialize(const VkExternalFormatANDROID* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + externalFormat = in_struct->externalFormat; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExternalFormatANDROID::initialize(const safe_VkExternalFormatANDROID* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + externalFormat = copy_src->externalFormat; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAndroidHardwareBufferFormatProperties2ANDROID::safe_VkAndroidHardwareBufferFormatProperties2ANDROID( + const VkAndroidHardwareBufferFormatProperties2ANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + format(in_struct->format), + externalFormat(in_struct->externalFormat), + formatFeatures(in_struct->formatFeatures), + samplerYcbcrConversionComponents(in_struct->samplerYcbcrConversionComponents), + suggestedYcbcrModel(in_struct->suggestedYcbcrModel), + suggestedYcbcrRange(in_struct->suggestedYcbcrRange), + suggestedXChromaOffset(in_struct->suggestedXChromaOffset), + suggestedYChromaOffset(in_struct->suggestedYChromaOffset) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAndroidHardwareBufferFormatProperties2ANDROID::safe_VkAndroidHardwareBufferFormatProperties2ANDROID() + : sType(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID), + pNext(nullptr), + format(), + externalFormat(), + formatFeatures(), + samplerYcbcrConversionComponents(), + suggestedYcbcrModel(), + suggestedYcbcrRange(), + suggestedXChromaOffset(), + suggestedYChromaOffset() {} + +safe_VkAndroidHardwareBufferFormatProperties2ANDROID::safe_VkAndroidHardwareBufferFormatProperties2ANDROID( + const safe_VkAndroidHardwareBufferFormatProperties2ANDROID& copy_src) { + sType = copy_src.sType; + format = copy_src.format; + externalFormat = copy_src.externalFormat; + formatFeatures = copy_src.formatFeatures; + samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents; + suggestedYcbcrModel = copy_src.suggestedYcbcrModel; + suggestedYcbcrRange = copy_src.suggestedYcbcrRange; + suggestedXChromaOffset = copy_src.suggestedXChromaOffset; + suggestedYChromaOffset = copy_src.suggestedYChromaOffset; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAndroidHardwareBufferFormatProperties2ANDROID& safe_VkAndroidHardwareBufferFormatProperties2ANDROID::operator=( + const safe_VkAndroidHardwareBufferFormatProperties2ANDROID& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + format = copy_src.format; + externalFormat = copy_src.externalFormat; + formatFeatures = copy_src.formatFeatures; + samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents; + suggestedYcbcrModel = copy_src.suggestedYcbcrModel; + suggestedYcbcrRange = copy_src.suggestedYcbcrRange; + suggestedXChromaOffset = copy_src.suggestedXChromaOffset; + suggestedYChromaOffset = copy_src.suggestedYChromaOffset; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAndroidHardwareBufferFormatProperties2ANDROID::~safe_VkAndroidHardwareBufferFormatProperties2ANDROID() { + FreePnextChain(pNext); +} + +void safe_VkAndroidHardwareBufferFormatProperties2ANDROID::initialize( + const VkAndroidHardwareBufferFormatProperties2ANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + format = in_struct->format; + externalFormat = in_struct->externalFormat; + formatFeatures = in_struct->formatFeatures; + samplerYcbcrConversionComponents = in_struct->samplerYcbcrConversionComponents; + suggestedYcbcrModel = in_struct->suggestedYcbcrModel; + suggestedYcbcrRange = in_struct->suggestedYcbcrRange; + suggestedXChromaOffset = in_struct->suggestedXChromaOffset; + suggestedYChromaOffset = in_struct->suggestedYChromaOffset; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAndroidHardwareBufferFormatProperties2ANDROID::initialize( + const safe_VkAndroidHardwareBufferFormatProperties2ANDROID* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + format = copy_src->format; + externalFormat = copy_src->externalFormat; + formatFeatures = copy_src->formatFeatures; + samplerYcbcrConversionComponents = copy_src->samplerYcbcrConversionComponents; + suggestedYcbcrModel = copy_src->suggestedYcbcrModel; + suggestedYcbcrRange = copy_src->suggestedYcbcrRange; + suggestedXChromaOffset = copy_src->suggestedXChromaOffset; + suggestedYChromaOffset = copy_src->suggestedYChromaOffset; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_ANDROID_KHR +#ifdef VK_ENABLE_BETA_EXTENSIONS + +safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX( + const VkPhysicalDeviceShaderEnqueueFeaturesAMDX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), shaderEnqueue(in_struct->shaderEnqueue) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX), pNext(nullptr), shaderEnqueue() {} + +safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX( + const safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX& copy_src) { + sType = copy_src.sType; + shaderEnqueue = copy_src.shaderEnqueue; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX& safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::operator=( + const safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderEnqueue = copy_src.shaderEnqueue; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::~safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::initialize(const VkPhysicalDeviceShaderEnqueueFeaturesAMDX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderEnqueue = in_struct->shaderEnqueue; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::initialize(const safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderEnqueue = copy_src->shaderEnqueue; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX( + const VkPhysicalDeviceShaderEnqueuePropertiesAMDX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + maxExecutionGraphDepth(in_struct->maxExecutionGraphDepth), + maxExecutionGraphShaderOutputNodes(in_struct->maxExecutionGraphShaderOutputNodes), + maxExecutionGraphShaderPayloadSize(in_struct->maxExecutionGraphShaderPayloadSize), + maxExecutionGraphShaderPayloadCount(in_struct->maxExecutionGraphShaderPayloadCount), + executionGraphDispatchAddressAlignment(in_struct->executionGraphDispatchAddressAlignment) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX), + pNext(nullptr), + maxExecutionGraphDepth(), + maxExecutionGraphShaderOutputNodes(), + maxExecutionGraphShaderPayloadSize(), + maxExecutionGraphShaderPayloadCount(), + executionGraphDispatchAddressAlignment() {} + +safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX( + const safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX& copy_src) { + sType = copy_src.sType; + maxExecutionGraphDepth = copy_src.maxExecutionGraphDepth; + maxExecutionGraphShaderOutputNodes = copy_src.maxExecutionGraphShaderOutputNodes; + maxExecutionGraphShaderPayloadSize = copy_src.maxExecutionGraphShaderPayloadSize; + maxExecutionGraphShaderPayloadCount = copy_src.maxExecutionGraphShaderPayloadCount; + executionGraphDispatchAddressAlignment = copy_src.executionGraphDispatchAddressAlignment; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX& safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::operator=( + const safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxExecutionGraphDepth = copy_src.maxExecutionGraphDepth; + maxExecutionGraphShaderOutputNodes = copy_src.maxExecutionGraphShaderOutputNodes; + maxExecutionGraphShaderPayloadSize = copy_src.maxExecutionGraphShaderPayloadSize; + maxExecutionGraphShaderPayloadCount = copy_src.maxExecutionGraphShaderPayloadCount; + executionGraphDispatchAddressAlignment = copy_src.executionGraphDispatchAddressAlignment; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::~safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::initialize(const VkPhysicalDeviceShaderEnqueuePropertiesAMDX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxExecutionGraphDepth = in_struct->maxExecutionGraphDepth; + maxExecutionGraphShaderOutputNodes = in_struct->maxExecutionGraphShaderOutputNodes; + maxExecutionGraphShaderPayloadSize = in_struct->maxExecutionGraphShaderPayloadSize; + maxExecutionGraphShaderPayloadCount = in_struct->maxExecutionGraphShaderPayloadCount; + executionGraphDispatchAddressAlignment = in_struct->executionGraphDispatchAddressAlignment; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::initialize(const safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxExecutionGraphDepth = copy_src->maxExecutionGraphDepth; + maxExecutionGraphShaderOutputNodes = copy_src->maxExecutionGraphShaderOutputNodes; + maxExecutionGraphShaderPayloadSize = copy_src->maxExecutionGraphShaderPayloadSize; + maxExecutionGraphShaderPayloadCount = copy_src->maxExecutionGraphShaderPayloadCount; + executionGraphDispatchAddressAlignment = copy_src->executionGraphDispatchAddressAlignment; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExecutionGraphPipelineScratchSizeAMDX::safe_VkExecutionGraphPipelineScratchSizeAMDX( + const VkExecutionGraphPipelineScratchSizeAMDX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), size(in_struct->size) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExecutionGraphPipelineScratchSizeAMDX::safe_VkExecutionGraphPipelineScratchSizeAMDX() + : sType(VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX), pNext(nullptr), size() {} + +safe_VkExecutionGraphPipelineScratchSizeAMDX::safe_VkExecutionGraphPipelineScratchSizeAMDX( + const safe_VkExecutionGraphPipelineScratchSizeAMDX& copy_src) { + sType = copy_src.sType; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExecutionGraphPipelineScratchSizeAMDX& safe_VkExecutionGraphPipelineScratchSizeAMDX::operator=( + const safe_VkExecutionGraphPipelineScratchSizeAMDX& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + size = copy_src.size; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExecutionGraphPipelineScratchSizeAMDX::~safe_VkExecutionGraphPipelineScratchSizeAMDX() { FreePnextChain(pNext); } + +void safe_VkExecutionGraphPipelineScratchSizeAMDX::initialize(const VkExecutionGraphPipelineScratchSizeAMDX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + size = in_struct->size; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExecutionGraphPipelineScratchSizeAMDX::initialize(const safe_VkExecutionGraphPipelineScratchSizeAMDX* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + size = copy_src->size; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkExecutionGraphPipelineCreateInfoAMDX::safe_VkExecutionGraphPipelineCreateInfoAMDX( + const VkExecutionGraphPipelineCreateInfoAMDX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + stageCount(in_struct->stageCount), + pStages(nullptr), + pLibraryInfo(nullptr), + layout(in_struct->layout), + basePipelineHandle(in_struct->basePipelineHandle), + basePipelineIndex(in_struct->basePipelineIndex) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (stageCount && in_struct->pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(&in_struct->pStages[i]); + } + } + if (in_struct->pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(in_struct->pLibraryInfo); +} + +safe_VkExecutionGraphPipelineCreateInfoAMDX::safe_VkExecutionGraphPipelineCreateInfoAMDX() + : sType(VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX), + pNext(nullptr), + flags(), + stageCount(), + pStages(nullptr), + pLibraryInfo(nullptr), + layout(), + basePipelineHandle(), + basePipelineIndex() {} + +safe_VkExecutionGraphPipelineCreateInfoAMDX::safe_VkExecutionGraphPipelineCreateInfoAMDX( + const safe_VkExecutionGraphPipelineCreateInfoAMDX& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + stageCount = copy_src.stageCount; + pStages = nullptr; + pLibraryInfo = nullptr; + layout = copy_src.layout; + basePipelineHandle = copy_src.basePipelineHandle; + basePipelineIndex = copy_src.basePipelineIndex; + pNext = SafePnextCopy(copy_src.pNext); + if (stageCount && copy_src.pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(©_src.pStages[i]); + } + } + if (copy_src.pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(*copy_src.pLibraryInfo); +} + +safe_VkExecutionGraphPipelineCreateInfoAMDX& safe_VkExecutionGraphPipelineCreateInfoAMDX::operator=( + const safe_VkExecutionGraphPipelineCreateInfoAMDX& copy_src) { + if (©_src == this) return *this; + + if (pStages) delete[] pStages; + if (pLibraryInfo) delete pLibraryInfo; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + stageCount = copy_src.stageCount; + pStages = nullptr; + pLibraryInfo = nullptr; + layout = copy_src.layout; + basePipelineHandle = copy_src.basePipelineHandle; + basePipelineIndex = copy_src.basePipelineIndex; + pNext = SafePnextCopy(copy_src.pNext); + if (stageCount && copy_src.pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(©_src.pStages[i]); + } + } + if (copy_src.pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(*copy_src.pLibraryInfo); + + return *this; +} + +safe_VkExecutionGraphPipelineCreateInfoAMDX::~safe_VkExecutionGraphPipelineCreateInfoAMDX() { + if (pStages) delete[] pStages; + if (pLibraryInfo) delete pLibraryInfo; + FreePnextChain(pNext); +} + +void safe_VkExecutionGraphPipelineCreateInfoAMDX::initialize(const VkExecutionGraphPipelineCreateInfoAMDX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStages) delete[] pStages; + if (pLibraryInfo) delete pLibraryInfo; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + stageCount = in_struct->stageCount; + pStages = nullptr; + pLibraryInfo = nullptr; + layout = in_struct->layout; + basePipelineHandle = in_struct->basePipelineHandle; + basePipelineIndex = in_struct->basePipelineIndex; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (stageCount && in_struct->pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(&in_struct->pStages[i]); + } + } + if (in_struct->pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(in_struct->pLibraryInfo); +} + +void safe_VkExecutionGraphPipelineCreateInfoAMDX::initialize(const safe_VkExecutionGraphPipelineCreateInfoAMDX* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + stageCount = copy_src->stageCount; + pStages = nullptr; + pLibraryInfo = nullptr; + layout = copy_src->layout; + basePipelineHandle = copy_src->basePipelineHandle; + basePipelineIndex = copy_src->basePipelineIndex; + pNext = SafePnextCopy(copy_src->pNext); + if (stageCount && copy_src->pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(©_src->pStages[i]); + } + } + if (copy_src->pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(*copy_src->pLibraryInfo); +} + +safe_VkDeviceOrHostAddressConstAMDX::safe_VkDeviceOrHostAddressConstAMDX(const VkDeviceOrHostAddressConstAMDX* in_struct, + PNextCopyState*) { + initialize(in_struct); +} + +safe_VkDeviceOrHostAddressConstAMDX::safe_VkDeviceOrHostAddressConstAMDX() : hostAddress(nullptr) {} + +safe_VkDeviceOrHostAddressConstAMDX::safe_VkDeviceOrHostAddressConstAMDX(const safe_VkDeviceOrHostAddressConstAMDX& copy_src) { + deviceAddress = copy_src.deviceAddress; + hostAddress = copy_src.hostAddress; +} + +safe_VkDeviceOrHostAddressConstAMDX& safe_VkDeviceOrHostAddressConstAMDX::operator=( + const safe_VkDeviceOrHostAddressConstAMDX& copy_src) { + if (©_src == this) return *this; + + deviceAddress = copy_src.deviceAddress; + hostAddress = copy_src.hostAddress; + + return *this; +} + +safe_VkDeviceOrHostAddressConstAMDX::~safe_VkDeviceOrHostAddressConstAMDX() {} + +void safe_VkDeviceOrHostAddressConstAMDX::initialize(const VkDeviceOrHostAddressConstAMDX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + deviceAddress = in_struct->deviceAddress; + hostAddress = in_struct->hostAddress; +} + +void safe_VkDeviceOrHostAddressConstAMDX::initialize(const safe_VkDeviceOrHostAddressConstAMDX* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + deviceAddress = copy_src->deviceAddress; + hostAddress = copy_src->hostAddress; +} + +safe_VkPipelineShaderStageNodeCreateInfoAMDX::safe_VkPipelineShaderStageNodeCreateInfoAMDX( + const VkPipelineShaderStageNodeCreateInfoAMDX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), index(in_struct->index) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + pName = SafeStringCopy(in_struct->pName); +} + +safe_VkPipelineShaderStageNodeCreateInfoAMDX::safe_VkPipelineShaderStageNodeCreateInfoAMDX() + : sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX), pNext(nullptr), pName(nullptr), index() {} + +safe_VkPipelineShaderStageNodeCreateInfoAMDX::safe_VkPipelineShaderStageNodeCreateInfoAMDX( + const safe_VkPipelineShaderStageNodeCreateInfoAMDX& copy_src) { + sType = copy_src.sType; + index = copy_src.index; + pNext = SafePnextCopy(copy_src.pNext); + pName = SafeStringCopy(copy_src.pName); +} + +safe_VkPipelineShaderStageNodeCreateInfoAMDX& safe_VkPipelineShaderStageNodeCreateInfoAMDX::operator=( + const safe_VkPipelineShaderStageNodeCreateInfoAMDX& copy_src) { + if (©_src == this) return *this; + + if (pName) delete[] pName; + FreePnextChain(pNext); + + sType = copy_src.sType; + index = copy_src.index; + pNext = SafePnextCopy(copy_src.pNext); + pName = SafeStringCopy(copy_src.pName); + + return *this; +} + +safe_VkPipelineShaderStageNodeCreateInfoAMDX::~safe_VkPipelineShaderStageNodeCreateInfoAMDX() { + if (pName) delete[] pName; + FreePnextChain(pNext); +} + +void safe_VkPipelineShaderStageNodeCreateInfoAMDX::initialize(const VkPipelineShaderStageNodeCreateInfoAMDX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pName) delete[] pName; + FreePnextChain(pNext); + sType = in_struct->sType; + index = in_struct->index; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + pName = SafeStringCopy(in_struct->pName); +} + +void safe_VkPipelineShaderStageNodeCreateInfoAMDX::initialize(const safe_VkPipelineShaderStageNodeCreateInfoAMDX* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + index = copy_src->index; + pNext = SafePnextCopy(copy_src->pNext); + pName = SafeStringCopy(copy_src->pName); +} +#endif // VK_ENABLE_BETA_EXTENSIONS + +safe_VkPipelineCoverageToColorStateCreateInfoNV::safe_VkPipelineCoverageToColorStateCreateInfoNV( + const VkPipelineCoverageToColorStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + coverageToColorEnable(in_struct->coverageToColorEnable), + coverageToColorLocation(in_struct->coverageToColorLocation) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineCoverageToColorStateCreateInfoNV::safe_VkPipelineCoverageToColorStateCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV), + pNext(nullptr), + flags(), + coverageToColorEnable(), + coverageToColorLocation() {} + +safe_VkPipelineCoverageToColorStateCreateInfoNV::safe_VkPipelineCoverageToColorStateCreateInfoNV( + const safe_VkPipelineCoverageToColorStateCreateInfoNV& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + coverageToColorEnable = copy_src.coverageToColorEnable; + coverageToColorLocation = copy_src.coverageToColorLocation; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineCoverageToColorStateCreateInfoNV& safe_VkPipelineCoverageToColorStateCreateInfoNV::operator=( + const safe_VkPipelineCoverageToColorStateCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + coverageToColorEnable = copy_src.coverageToColorEnable; + coverageToColorLocation = copy_src.coverageToColorLocation; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineCoverageToColorStateCreateInfoNV::~safe_VkPipelineCoverageToColorStateCreateInfoNV() { FreePnextChain(pNext); } + +void safe_VkPipelineCoverageToColorStateCreateInfoNV::initialize(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + coverageToColorEnable = in_struct->coverageToColorEnable; + coverageToColorLocation = in_struct->coverageToColorLocation; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineCoverageToColorStateCreateInfoNV::initialize(const safe_VkPipelineCoverageToColorStateCreateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + coverageToColorEnable = copy_src->coverageToColorEnable; + coverageToColorLocation = copy_src->coverageToColorLocation; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineCoverageModulationStateCreateInfoNV::safe_VkPipelineCoverageModulationStateCreateInfoNV( + const VkPipelineCoverageModulationStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + coverageModulationMode(in_struct->coverageModulationMode), + coverageModulationTableEnable(in_struct->coverageModulationTableEnable), + coverageModulationTableCount(in_struct->coverageModulationTableCount), + pCoverageModulationTable(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pCoverageModulationTable) { + pCoverageModulationTable = new float[in_struct->coverageModulationTableCount]; + memcpy((void*)pCoverageModulationTable, (void*)in_struct->pCoverageModulationTable, + sizeof(float) * in_struct->coverageModulationTableCount); + } +} + +safe_VkPipelineCoverageModulationStateCreateInfoNV::safe_VkPipelineCoverageModulationStateCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV), + pNext(nullptr), + flags(), + coverageModulationMode(), + coverageModulationTableEnable(), + coverageModulationTableCount(), + pCoverageModulationTable(nullptr) {} + +safe_VkPipelineCoverageModulationStateCreateInfoNV::safe_VkPipelineCoverageModulationStateCreateInfoNV( + const safe_VkPipelineCoverageModulationStateCreateInfoNV& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + coverageModulationMode = copy_src.coverageModulationMode; + coverageModulationTableEnable = copy_src.coverageModulationTableEnable; + coverageModulationTableCount = copy_src.coverageModulationTableCount; + pCoverageModulationTable = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pCoverageModulationTable) { + pCoverageModulationTable = new float[copy_src.coverageModulationTableCount]; + memcpy((void*)pCoverageModulationTable, (void*)copy_src.pCoverageModulationTable, + sizeof(float) * copy_src.coverageModulationTableCount); + } +} + +safe_VkPipelineCoverageModulationStateCreateInfoNV& safe_VkPipelineCoverageModulationStateCreateInfoNV::operator=( + const safe_VkPipelineCoverageModulationStateCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pCoverageModulationTable) delete[] pCoverageModulationTable; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + coverageModulationMode = copy_src.coverageModulationMode; + coverageModulationTableEnable = copy_src.coverageModulationTableEnable; + coverageModulationTableCount = copy_src.coverageModulationTableCount; + pCoverageModulationTable = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pCoverageModulationTable) { + pCoverageModulationTable = new float[copy_src.coverageModulationTableCount]; + memcpy((void*)pCoverageModulationTable, (void*)copy_src.pCoverageModulationTable, + sizeof(float) * copy_src.coverageModulationTableCount); + } + + return *this; +} + +safe_VkPipelineCoverageModulationStateCreateInfoNV::~safe_VkPipelineCoverageModulationStateCreateInfoNV() { + if (pCoverageModulationTable) delete[] pCoverageModulationTable; + FreePnextChain(pNext); +} + +void safe_VkPipelineCoverageModulationStateCreateInfoNV::initialize(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pCoverageModulationTable) delete[] pCoverageModulationTable; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + coverageModulationMode = in_struct->coverageModulationMode; + coverageModulationTableEnable = in_struct->coverageModulationTableEnable; + coverageModulationTableCount = in_struct->coverageModulationTableCount; + pCoverageModulationTable = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pCoverageModulationTable) { + pCoverageModulationTable = new float[in_struct->coverageModulationTableCount]; + memcpy((void*)pCoverageModulationTable, (void*)in_struct->pCoverageModulationTable, + sizeof(float) * in_struct->coverageModulationTableCount); + } +} + +void safe_VkPipelineCoverageModulationStateCreateInfoNV::initialize( + const safe_VkPipelineCoverageModulationStateCreateInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + coverageModulationMode = copy_src->coverageModulationMode; + coverageModulationTableEnable = copy_src->coverageModulationTableEnable; + coverageModulationTableCount = copy_src->coverageModulationTableCount; + pCoverageModulationTable = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pCoverageModulationTable) { + pCoverageModulationTable = new float[copy_src->coverageModulationTableCount]; + memcpy((void*)pCoverageModulationTable, (void*)copy_src->pCoverageModulationTable, + sizeof(float) * copy_src->coverageModulationTableCount); + } +} + +safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV( + const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), shaderSMCount(in_struct->shaderSMCount), shaderWarpsPerSM(in_struct->shaderWarpsPerSM) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV), + pNext(nullptr), + shaderSMCount(), + shaderWarpsPerSM() {} + +safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV( + const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& copy_src) { + sType = copy_src.sType; + shaderSMCount = copy_src.shaderSMCount; + shaderWarpsPerSM = copy_src.shaderWarpsPerSM; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::operator=( + const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderSMCount = copy_src.shaderSMCount; + shaderWarpsPerSM = copy_src.shaderWarpsPerSM; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::~safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::initialize(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderSMCount = in_struct->shaderSMCount; + shaderWarpsPerSM = in_struct->shaderWarpsPerSM; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::initialize( + const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderSMCount = copy_src->shaderSMCount; + shaderWarpsPerSM = copy_src->shaderWarpsPerSM; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV( + const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), shaderSMBuiltins(in_struct->shaderSMBuiltins) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV), pNext(nullptr), shaderSMBuiltins() {} + +safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV( + const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& copy_src) { + sType = copy_src.sType; + shaderSMBuiltins = copy_src.shaderSMBuiltins; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::operator=( + const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderSMBuiltins = copy_src.shaderSMBuiltins; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::~safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::initialize(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderSMBuiltins = in_struct->shaderSMBuiltins; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::initialize(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderSMBuiltins = copy_src->shaderSMBuiltins; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkShadingRatePaletteNV::safe_VkShadingRatePaletteNV(const VkShadingRatePaletteNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) + : shadingRatePaletteEntryCount(in_struct->shadingRatePaletteEntryCount), pShadingRatePaletteEntries(nullptr) { + if (in_struct->pShadingRatePaletteEntries) { + pShadingRatePaletteEntries = new VkShadingRatePaletteEntryNV[in_struct->shadingRatePaletteEntryCount]; + memcpy((void*)pShadingRatePaletteEntries, (void*)in_struct->pShadingRatePaletteEntries, + sizeof(VkShadingRatePaletteEntryNV) * in_struct->shadingRatePaletteEntryCount); + } +} + +safe_VkShadingRatePaletteNV::safe_VkShadingRatePaletteNV() : shadingRatePaletteEntryCount(), pShadingRatePaletteEntries(nullptr) {} + +safe_VkShadingRatePaletteNV::safe_VkShadingRatePaletteNV(const safe_VkShadingRatePaletteNV& copy_src) { + shadingRatePaletteEntryCount = copy_src.shadingRatePaletteEntryCount; + pShadingRatePaletteEntries = nullptr; + + if (copy_src.pShadingRatePaletteEntries) { + pShadingRatePaletteEntries = new VkShadingRatePaletteEntryNV[copy_src.shadingRatePaletteEntryCount]; + memcpy((void*)pShadingRatePaletteEntries, (void*)copy_src.pShadingRatePaletteEntries, + sizeof(VkShadingRatePaletteEntryNV) * copy_src.shadingRatePaletteEntryCount); + } +} + +safe_VkShadingRatePaletteNV& safe_VkShadingRatePaletteNV::operator=(const safe_VkShadingRatePaletteNV& copy_src) { + if (©_src == this) return *this; + + if (pShadingRatePaletteEntries) delete[] pShadingRatePaletteEntries; + + shadingRatePaletteEntryCount = copy_src.shadingRatePaletteEntryCount; + pShadingRatePaletteEntries = nullptr; + + if (copy_src.pShadingRatePaletteEntries) { + pShadingRatePaletteEntries = new VkShadingRatePaletteEntryNV[copy_src.shadingRatePaletteEntryCount]; + memcpy((void*)pShadingRatePaletteEntries, (void*)copy_src.pShadingRatePaletteEntries, + sizeof(VkShadingRatePaletteEntryNV) * copy_src.shadingRatePaletteEntryCount); + } + + return *this; +} + +safe_VkShadingRatePaletteNV::~safe_VkShadingRatePaletteNV() { + if (pShadingRatePaletteEntries) delete[] pShadingRatePaletteEntries; +} + +void safe_VkShadingRatePaletteNV::initialize(const VkShadingRatePaletteNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pShadingRatePaletteEntries) delete[] pShadingRatePaletteEntries; + shadingRatePaletteEntryCount = in_struct->shadingRatePaletteEntryCount; + pShadingRatePaletteEntries = nullptr; + + if (in_struct->pShadingRatePaletteEntries) { + pShadingRatePaletteEntries = new VkShadingRatePaletteEntryNV[in_struct->shadingRatePaletteEntryCount]; + memcpy((void*)pShadingRatePaletteEntries, (void*)in_struct->pShadingRatePaletteEntries, + sizeof(VkShadingRatePaletteEntryNV) * in_struct->shadingRatePaletteEntryCount); + } +} + +void safe_VkShadingRatePaletteNV::initialize(const safe_VkShadingRatePaletteNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + shadingRatePaletteEntryCount = copy_src->shadingRatePaletteEntryCount; + pShadingRatePaletteEntries = nullptr; + + if (copy_src->pShadingRatePaletteEntries) { + pShadingRatePaletteEntries = new VkShadingRatePaletteEntryNV[copy_src->shadingRatePaletteEntryCount]; + memcpy((void*)pShadingRatePaletteEntries, (void*)copy_src->pShadingRatePaletteEntries, + sizeof(VkShadingRatePaletteEntryNV) * copy_src->shadingRatePaletteEntryCount); + } +} + +safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::safe_VkPipelineViewportShadingRateImageStateCreateInfoNV( + const VkPipelineViewportShadingRateImageStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + shadingRateImageEnable(in_struct->shadingRateImageEnable), + viewportCount(in_struct->viewportCount), + pShadingRatePalettes(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (viewportCount && in_struct->pShadingRatePalettes) { + pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount]; + for (uint32_t i = 0; i < viewportCount; ++i) { + pShadingRatePalettes[i].initialize(&in_struct->pShadingRatePalettes[i]); + } + } +} + +safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::safe_VkPipelineViewportShadingRateImageStateCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV), + pNext(nullptr), + shadingRateImageEnable(), + viewportCount(), + pShadingRatePalettes(nullptr) {} + +safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::safe_VkPipelineViewportShadingRateImageStateCreateInfoNV( + const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& copy_src) { + sType = copy_src.sType; + shadingRateImageEnable = copy_src.shadingRateImageEnable; + viewportCount = copy_src.viewportCount; + pShadingRatePalettes = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (viewportCount && copy_src.pShadingRatePalettes) { + pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount]; + for (uint32_t i = 0; i < viewportCount; ++i) { + pShadingRatePalettes[i].initialize(©_src.pShadingRatePalettes[i]); + } + } +} + +safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::operator=( + const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pShadingRatePalettes) delete[] pShadingRatePalettes; + FreePnextChain(pNext); + + sType = copy_src.sType; + shadingRateImageEnable = copy_src.shadingRateImageEnable; + viewportCount = copy_src.viewportCount; + pShadingRatePalettes = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (viewportCount && copy_src.pShadingRatePalettes) { + pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount]; + for (uint32_t i = 0; i < viewportCount; ++i) { + pShadingRatePalettes[i].initialize(©_src.pShadingRatePalettes[i]); + } + } + + return *this; +} + +safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::~safe_VkPipelineViewportShadingRateImageStateCreateInfoNV() { + if (pShadingRatePalettes) delete[] pShadingRatePalettes; + FreePnextChain(pNext); +} + +void safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::initialize( + const VkPipelineViewportShadingRateImageStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pShadingRatePalettes) delete[] pShadingRatePalettes; + FreePnextChain(pNext); + sType = in_struct->sType; + shadingRateImageEnable = in_struct->shadingRateImageEnable; + viewportCount = in_struct->viewportCount; + pShadingRatePalettes = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (viewportCount && in_struct->pShadingRatePalettes) { + pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount]; + for (uint32_t i = 0; i < viewportCount; ++i) { + pShadingRatePalettes[i].initialize(&in_struct->pShadingRatePalettes[i]); + } + } +} + +void safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::initialize( + const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shadingRateImageEnable = copy_src->shadingRateImageEnable; + viewportCount = copy_src->viewportCount; + pShadingRatePalettes = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (viewportCount && copy_src->pShadingRatePalettes) { + pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount]; + for (uint32_t i = 0; i < viewportCount; ++i) { + pShadingRatePalettes[i].initialize(©_src->pShadingRatePalettes[i]); + } + } +} + +safe_VkPhysicalDeviceShadingRateImageFeaturesNV::safe_VkPhysicalDeviceShadingRateImageFeaturesNV( + const VkPhysicalDeviceShadingRateImageFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shadingRateImage(in_struct->shadingRateImage), + shadingRateCoarseSampleOrder(in_struct->shadingRateCoarseSampleOrder) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShadingRateImageFeaturesNV::safe_VkPhysicalDeviceShadingRateImageFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV), + pNext(nullptr), + shadingRateImage(), + shadingRateCoarseSampleOrder() {} + +safe_VkPhysicalDeviceShadingRateImageFeaturesNV::safe_VkPhysicalDeviceShadingRateImageFeaturesNV( + const safe_VkPhysicalDeviceShadingRateImageFeaturesNV& copy_src) { + sType = copy_src.sType; + shadingRateImage = copy_src.shadingRateImage; + shadingRateCoarseSampleOrder = copy_src.shadingRateCoarseSampleOrder; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShadingRateImageFeaturesNV& safe_VkPhysicalDeviceShadingRateImageFeaturesNV::operator=( + const safe_VkPhysicalDeviceShadingRateImageFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shadingRateImage = copy_src.shadingRateImage; + shadingRateCoarseSampleOrder = copy_src.shadingRateCoarseSampleOrder; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShadingRateImageFeaturesNV::~safe_VkPhysicalDeviceShadingRateImageFeaturesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShadingRateImageFeaturesNV::initialize(const VkPhysicalDeviceShadingRateImageFeaturesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shadingRateImage = in_struct->shadingRateImage; + shadingRateCoarseSampleOrder = in_struct->shadingRateCoarseSampleOrder; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShadingRateImageFeaturesNV::initialize(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shadingRateImage = copy_src->shadingRateImage; + shadingRateCoarseSampleOrder = copy_src->shadingRateCoarseSampleOrder; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShadingRateImagePropertiesNV::safe_VkPhysicalDeviceShadingRateImagePropertiesNV( + const VkPhysicalDeviceShadingRateImagePropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shadingRateTexelSize(in_struct->shadingRateTexelSize), + shadingRatePaletteSize(in_struct->shadingRatePaletteSize), + shadingRateMaxCoarseSamples(in_struct->shadingRateMaxCoarseSamples) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShadingRateImagePropertiesNV::safe_VkPhysicalDeviceShadingRateImagePropertiesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV), + pNext(nullptr), + shadingRateTexelSize(), + shadingRatePaletteSize(), + shadingRateMaxCoarseSamples() {} + +safe_VkPhysicalDeviceShadingRateImagePropertiesNV::safe_VkPhysicalDeviceShadingRateImagePropertiesNV( + const safe_VkPhysicalDeviceShadingRateImagePropertiesNV& copy_src) { + sType = copy_src.sType; + shadingRateTexelSize = copy_src.shadingRateTexelSize; + shadingRatePaletteSize = copy_src.shadingRatePaletteSize; + shadingRateMaxCoarseSamples = copy_src.shadingRateMaxCoarseSamples; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShadingRateImagePropertiesNV& safe_VkPhysicalDeviceShadingRateImagePropertiesNV::operator=( + const safe_VkPhysicalDeviceShadingRateImagePropertiesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shadingRateTexelSize = copy_src.shadingRateTexelSize; + shadingRatePaletteSize = copy_src.shadingRatePaletteSize; + shadingRateMaxCoarseSamples = copy_src.shadingRateMaxCoarseSamples; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShadingRateImagePropertiesNV::~safe_VkPhysicalDeviceShadingRateImagePropertiesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShadingRateImagePropertiesNV::initialize(const VkPhysicalDeviceShadingRateImagePropertiesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shadingRateTexelSize = in_struct->shadingRateTexelSize; + shadingRatePaletteSize = in_struct->shadingRatePaletteSize; + shadingRateMaxCoarseSamples = in_struct->shadingRateMaxCoarseSamples; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShadingRateImagePropertiesNV::initialize( + const safe_VkPhysicalDeviceShadingRateImagePropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shadingRateTexelSize = copy_src->shadingRateTexelSize; + shadingRatePaletteSize = copy_src->shadingRatePaletteSize; + shadingRateMaxCoarseSamples = copy_src->shadingRateMaxCoarseSamples; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCoarseSampleOrderCustomNV::safe_VkCoarseSampleOrderCustomNV(const VkCoarseSampleOrderCustomNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) + : shadingRate(in_struct->shadingRate), + sampleCount(in_struct->sampleCount), + sampleLocationCount(in_struct->sampleLocationCount), + pSampleLocations(nullptr) { + if (in_struct->pSampleLocations) { + pSampleLocations = new VkCoarseSampleLocationNV[in_struct->sampleLocationCount]; + memcpy((void*)pSampleLocations, (void*)in_struct->pSampleLocations, + sizeof(VkCoarseSampleLocationNV) * in_struct->sampleLocationCount); + } +} + +safe_VkCoarseSampleOrderCustomNV::safe_VkCoarseSampleOrderCustomNV() + : shadingRate(), sampleCount(), sampleLocationCount(), pSampleLocations(nullptr) {} + +safe_VkCoarseSampleOrderCustomNV::safe_VkCoarseSampleOrderCustomNV(const safe_VkCoarseSampleOrderCustomNV& copy_src) { + shadingRate = copy_src.shadingRate; + sampleCount = copy_src.sampleCount; + sampleLocationCount = copy_src.sampleLocationCount; + pSampleLocations = nullptr; + + if (copy_src.pSampleLocations) { + pSampleLocations = new VkCoarseSampleLocationNV[copy_src.sampleLocationCount]; + memcpy((void*)pSampleLocations, (void*)copy_src.pSampleLocations, + sizeof(VkCoarseSampleLocationNV) * copy_src.sampleLocationCount); + } +} + +safe_VkCoarseSampleOrderCustomNV& safe_VkCoarseSampleOrderCustomNV::operator=(const safe_VkCoarseSampleOrderCustomNV& copy_src) { + if (©_src == this) return *this; + + if (pSampleLocations) delete[] pSampleLocations; + + shadingRate = copy_src.shadingRate; + sampleCount = copy_src.sampleCount; + sampleLocationCount = copy_src.sampleLocationCount; + pSampleLocations = nullptr; + + if (copy_src.pSampleLocations) { + pSampleLocations = new VkCoarseSampleLocationNV[copy_src.sampleLocationCount]; + memcpy((void*)pSampleLocations, (void*)copy_src.pSampleLocations, + sizeof(VkCoarseSampleLocationNV) * copy_src.sampleLocationCount); + } + + return *this; +} + +safe_VkCoarseSampleOrderCustomNV::~safe_VkCoarseSampleOrderCustomNV() { + if (pSampleLocations) delete[] pSampleLocations; +} + +void safe_VkCoarseSampleOrderCustomNV::initialize(const VkCoarseSampleOrderCustomNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pSampleLocations) delete[] pSampleLocations; + shadingRate = in_struct->shadingRate; + sampleCount = in_struct->sampleCount; + sampleLocationCount = in_struct->sampleLocationCount; + pSampleLocations = nullptr; + + if (in_struct->pSampleLocations) { + pSampleLocations = new VkCoarseSampleLocationNV[in_struct->sampleLocationCount]; + memcpy((void*)pSampleLocations, (void*)in_struct->pSampleLocations, + sizeof(VkCoarseSampleLocationNV) * in_struct->sampleLocationCount); + } +} + +void safe_VkCoarseSampleOrderCustomNV::initialize(const safe_VkCoarseSampleOrderCustomNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + shadingRate = copy_src->shadingRate; + sampleCount = copy_src->sampleCount; + sampleLocationCount = copy_src->sampleLocationCount; + pSampleLocations = nullptr; + + if (copy_src->pSampleLocations) { + pSampleLocations = new VkCoarseSampleLocationNV[copy_src->sampleLocationCount]; + memcpy((void*)pSampleLocations, (void*)copy_src->pSampleLocations, + sizeof(VkCoarseSampleLocationNV) * copy_src->sampleLocationCount); + } +} + +safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV( + const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + sampleOrderType(in_struct->sampleOrderType), + customSampleOrderCount(in_struct->customSampleOrderCount), + pCustomSampleOrders(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (customSampleOrderCount && in_struct->pCustomSampleOrders) { + pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount]; + for (uint32_t i = 0; i < customSampleOrderCount; ++i) { + pCustomSampleOrders[i].initialize(&in_struct->pCustomSampleOrders[i]); + } + } +} + +safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV), + pNext(nullptr), + sampleOrderType(), + customSampleOrderCount(), + pCustomSampleOrders(nullptr) {} + +safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV( + const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& copy_src) { + sType = copy_src.sType; + sampleOrderType = copy_src.sampleOrderType; + customSampleOrderCount = copy_src.customSampleOrderCount; + pCustomSampleOrders = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (customSampleOrderCount && copy_src.pCustomSampleOrders) { + pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount]; + for (uint32_t i = 0; i < customSampleOrderCount; ++i) { + pCustomSampleOrders[i].initialize(©_src.pCustomSampleOrders[i]); + } + } +} + +safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::operator=( + const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pCustomSampleOrders) delete[] pCustomSampleOrders; + FreePnextChain(pNext); + + sType = copy_src.sType; + sampleOrderType = copy_src.sampleOrderType; + customSampleOrderCount = copy_src.customSampleOrderCount; + pCustomSampleOrders = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (customSampleOrderCount && copy_src.pCustomSampleOrders) { + pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount]; + for (uint32_t i = 0; i < customSampleOrderCount; ++i) { + pCustomSampleOrders[i].initialize(©_src.pCustomSampleOrders[i]); + } + } + + return *this; +} + +safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::~safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV() { + if (pCustomSampleOrders) delete[] pCustomSampleOrders; + FreePnextChain(pNext); +} + +void safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::initialize( + const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pCustomSampleOrders) delete[] pCustomSampleOrders; + FreePnextChain(pNext); + sType = in_struct->sType; + sampleOrderType = in_struct->sampleOrderType; + customSampleOrderCount = in_struct->customSampleOrderCount; + pCustomSampleOrders = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (customSampleOrderCount && in_struct->pCustomSampleOrders) { + pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount]; + for (uint32_t i = 0; i < customSampleOrderCount; ++i) { + pCustomSampleOrders[i].initialize(&in_struct->pCustomSampleOrders[i]); + } + } +} + +void safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::initialize( + const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + sampleOrderType = copy_src->sampleOrderType; + customSampleOrderCount = copy_src->customSampleOrderCount; + pCustomSampleOrders = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (customSampleOrderCount && copy_src->pCustomSampleOrders) { + pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount]; + for (uint32_t i = 0; i < customSampleOrderCount; ++i) { + pCustomSampleOrders[i].initialize(©_src->pCustomSampleOrders[i]); + } + } +} + +safe_VkRayTracingShaderGroupCreateInfoNV::safe_VkRayTracingShaderGroupCreateInfoNV( + const VkRayTracingShaderGroupCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + type(in_struct->type), + generalShader(in_struct->generalShader), + closestHitShader(in_struct->closestHitShader), + anyHitShader(in_struct->anyHitShader), + intersectionShader(in_struct->intersectionShader) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkRayTracingShaderGroupCreateInfoNV::safe_VkRayTracingShaderGroupCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV), + pNext(nullptr), + type(), + generalShader(), + closestHitShader(), + anyHitShader(), + intersectionShader() {} + +safe_VkRayTracingShaderGroupCreateInfoNV::safe_VkRayTracingShaderGroupCreateInfoNV( + const safe_VkRayTracingShaderGroupCreateInfoNV& copy_src) { + sType = copy_src.sType; + type = copy_src.type; + generalShader = copy_src.generalShader; + closestHitShader = copy_src.closestHitShader; + anyHitShader = copy_src.anyHitShader; + intersectionShader = copy_src.intersectionShader; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkRayTracingShaderGroupCreateInfoNV& safe_VkRayTracingShaderGroupCreateInfoNV::operator=( + const safe_VkRayTracingShaderGroupCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + type = copy_src.type; + generalShader = copy_src.generalShader; + closestHitShader = copy_src.closestHitShader; + anyHitShader = copy_src.anyHitShader; + intersectionShader = copy_src.intersectionShader; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkRayTracingShaderGroupCreateInfoNV::~safe_VkRayTracingShaderGroupCreateInfoNV() { FreePnextChain(pNext); } + +void safe_VkRayTracingShaderGroupCreateInfoNV::initialize(const VkRayTracingShaderGroupCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + type = in_struct->type; + generalShader = in_struct->generalShader; + closestHitShader = in_struct->closestHitShader; + anyHitShader = in_struct->anyHitShader; + intersectionShader = in_struct->intersectionShader; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkRayTracingShaderGroupCreateInfoNV::initialize(const safe_VkRayTracingShaderGroupCreateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + type = copy_src->type; + generalShader = copy_src->generalShader; + closestHitShader = copy_src->closestHitShader; + anyHitShader = copy_src->anyHitShader; + intersectionShader = copy_src->intersectionShader; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkRayTracingPipelineCreateInfoNV::safe_VkRayTracingPipelineCreateInfoNV(const VkRayTracingPipelineCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + stageCount(in_struct->stageCount), + pStages(nullptr), + groupCount(in_struct->groupCount), + pGroups(nullptr), + maxRecursionDepth(in_struct->maxRecursionDepth), + layout(in_struct->layout), + basePipelineHandle(in_struct->basePipelineHandle), + basePipelineIndex(in_struct->basePipelineIndex) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (stageCount && in_struct->pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(&in_struct->pStages[i]); + } + } + if (groupCount && in_struct->pGroups) { + pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount]; + for (uint32_t i = 0; i < groupCount; ++i) { + pGroups[i].initialize(&in_struct->pGroups[i]); + } + } +} + +safe_VkRayTracingPipelineCreateInfoNV::safe_VkRayTracingPipelineCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV), + pNext(nullptr), + flags(), + stageCount(), + pStages(nullptr), + groupCount(), + pGroups(nullptr), + maxRecursionDepth(), + layout(), + basePipelineHandle(), + basePipelineIndex() {} + +safe_VkRayTracingPipelineCreateInfoNV::safe_VkRayTracingPipelineCreateInfoNV( + const safe_VkRayTracingPipelineCreateInfoNV& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + stageCount = copy_src.stageCount; + pStages = nullptr; + groupCount = copy_src.groupCount; + pGroups = nullptr; + maxRecursionDepth = copy_src.maxRecursionDepth; + layout = copy_src.layout; + basePipelineHandle = copy_src.basePipelineHandle; + basePipelineIndex = copy_src.basePipelineIndex; + pNext = SafePnextCopy(copy_src.pNext); + if (stageCount && copy_src.pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(©_src.pStages[i]); + } + } + if (groupCount && copy_src.pGroups) { + pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount]; + for (uint32_t i = 0; i < groupCount; ++i) { + pGroups[i].initialize(©_src.pGroups[i]); + } + } +} + +safe_VkRayTracingPipelineCreateInfoNV& safe_VkRayTracingPipelineCreateInfoNV::operator=( + const safe_VkRayTracingPipelineCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pStages) delete[] pStages; + if (pGroups) delete[] pGroups; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + stageCount = copy_src.stageCount; + pStages = nullptr; + groupCount = copy_src.groupCount; + pGroups = nullptr; + maxRecursionDepth = copy_src.maxRecursionDepth; + layout = copy_src.layout; + basePipelineHandle = copy_src.basePipelineHandle; + basePipelineIndex = copy_src.basePipelineIndex; + pNext = SafePnextCopy(copy_src.pNext); + if (stageCount && copy_src.pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(©_src.pStages[i]); + } + } + if (groupCount && copy_src.pGroups) { + pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount]; + for (uint32_t i = 0; i < groupCount; ++i) { + pGroups[i].initialize(©_src.pGroups[i]); + } + } + + return *this; +} + +safe_VkRayTracingPipelineCreateInfoNV::~safe_VkRayTracingPipelineCreateInfoNV() { + if (pStages) delete[] pStages; + if (pGroups) delete[] pGroups; + FreePnextChain(pNext); +} + +void safe_VkRayTracingPipelineCreateInfoNV::initialize(const VkRayTracingPipelineCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStages) delete[] pStages; + if (pGroups) delete[] pGroups; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + stageCount = in_struct->stageCount; + pStages = nullptr; + groupCount = in_struct->groupCount; + pGroups = nullptr; + maxRecursionDepth = in_struct->maxRecursionDepth; + layout = in_struct->layout; + basePipelineHandle = in_struct->basePipelineHandle; + basePipelineIndex = in_struct->basePipelineIndex; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (stageCount && in_struct->pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(&in_struct->pStages[i]); + } + } + if (groupCount && in_struct->pGroups) { + pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount]; + for (uint32_t i = 0; i < groupCount; ++i) { + pGroups[i].initialize(&in_struct->pGroups[i]); + } + } +} + +void safe_VkRayTracingPipelineCreateInfoNV::initialize(const safe_VkRayTracingPipelineCreateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + stageCount = copy_src->stageCount; + pStages = nullptr; + groupCount = copy_src->groupCount; + pGroups = nullptr; + maxRecursionDepth = copy_src->maxRecursionDepth; + layout = copy_src->layout; + basePipelineHandle = copy_src->basePipelineHandle; + basePipelineIndex = copy_src->basePipelineIndex; + pNext = SafePnextCopy(copy_src->pNext); + if (stageCount && copy_src->pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(©_src->pStages[i]); + } + } + if (groupCount && copy_src->pGroups) { + pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount]; + for (uint32_t i = 0; i < groupCount; ++i) { + pGroups[i].initialize(©_src->pGroups[i]); + } + } +} + +safe_VkGeometryTrianglesNV::safe_VkGeometryTrianglesNV(const VkGeometryTrianglesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + vertexData(in_struct->vertexData), + vertexOffset(in_struct->vertexOffset), + vertexCount(in_struct->vertexCount), + vertexStride(in_struct->vertexStride), + vertexFormat(in_struct->vertexFormat), + indexData(in_struct->indexData), + indexOffset(in_struct->indexOffset), + indexCount(in_struct->indexCount), + indexType(in_struct->indexType), + transformData(in_struct->transformData), + transformOffset(in_struct->transformOffset) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkGeometryTrianglesNV::safe_VkGeometryTrianglesNV() + : sType(VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV), + pNext(nullptr), + vertexData(), + vertexOffset(), + vertexCount(), + vertexStride(), + vertexFormat(), + indexData(), + indexOffset(), + indexCount(), + indexType(), + transformData(), + transformOffset() {} + +safe_VkGeometryTrianglesNV::safe_VkGeometryTrianglesNV(const safe_VkGeometryTrianglesNV& copy_src) { + sType = copy_src.sType; + vertexData = copy_src.vertexData; + vertexOffset = copy_src.vertexOffset; + vertexCount = copy_src.vertexCount; + vertexStride = copy_src.vertexStride; + vertexFormat = copy_src.vertexFormat; + indexData = copy_src.indexData; + indexOffset = copy_src.indexOffset; + indexCount = copy_src.indexCount; + indexType = copy_src.indexType; + transformData = copy_src.transformData; + transformOffset = copy_src.transformOffset; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkGeometryTrianglesNV& safe_VkGeometryTrianglesNV::operator=(const safe_VkGeometryTrianglesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + vertexData = copy_src.vertexData; + vertexOffset = copy_src.vertexOffset; + vertexCount = copy_src.vertexCount; + vertexStride = copy_src.vertexStride; + vertexFormat = copy_src.vertexFormat; + indexData = copy_src.indexData; + indexOffset = copy_src.indexOffset; + indexCount = copy_src.indexCount; + indexType = copy_src.indexType; + transformData = copy_src.transformData; + transformOffset = copy_src.transformOffset; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkGeometryTrianglesNV::~safe_VkGeometryTrianglesNV() { FreePnextChain(pNext); } + +void safe_VkGeometryTrianglesNV::initialize(const VkGeometryTrianglesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + vertexData = in_struct->vertexData; + vertexOffset = in_struct->vertexOffset; + vertexCount = in_struct->vertexCount; + vertexStride = in_struct->vertexStride; + vertexFormat = in_struct->vertexFormat; + indexData = in_struct->indexData; + indexOffset = in_struct->indexOffset; + indexCount = in_struct->indexCount; + indexType = in_struct->indexType; + transformData = in_struct->transformData; + transformOffset = in_struct->transformOffset; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkGeometryTrianglesNV::initialize(const safe_VkGeometryTrianglesNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + vertexData = copy_src->vertexData; + vertexOffset = copy_src->vertexOffset; + vertexCount = copy_src->vertexCount; + vertexStride = copy_src->vertexStride; + vertexFormat = copy_src->vertexFormat; + indexData = copy_src->indexData; + indexOffset = copy_src->indexOffset; + indexCount = copy_src->indexCount; + indexType = copy_src->indexType; + transformData = copy_src->transformData; + transformOffset = copy_src->transformOffset; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkGeometryAABBNV::safe_VkGeometryAABBNV(const VkGeometryAABBNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + aabbData(in_struct->aabbData), + numAABBs(in_struct->numAABBs), + stride(in_struct->stride), + offset(in_struct->offset) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkGeometryAABBNV::safe_VkGeometryAABBNV() + : sType(VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV), pNext(nullptr), aabbData(), numAABBs(), stride(), offset() {} + +safe_VkGeometryAABBNV::safe_VkGeometryAABBNV(const safe_VkGeometryAABBNV& copy_src) { + sType = copy_src.sType; + aabbData = copy_src.aabbData; + numAABBs = copy_src.numAABBs; + stride = copy_src.stride; + offset = copy_src.offset; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkGeometryAABBNV& safe_VkGeometryAABBNV::operator=(const safe_VkGeometryAABBNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + aabbData = copy_src.aabbData; + numAABBs = copy_src.numAABBs; + stride = copy_src.stride; + offset = copy_src.offset; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkGeometryAABBNV::~safe_VkGeometryAABBNV() { FreePnextChain(pNext); } + +void safe_VkGeometryAABBNV::initialize(const VkGeometryAABBNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + aabbData = in_struct->aabbData; + numAABBs = in_struct->numAABBs; + stride = in_struct->stride; + offset = in_struct->offset; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkGeometryAABBNV::initialize(const safe_VkGeometryAABBNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + aabbData = copy_src->aabbData; + numAABBs = copy_src->numAABBs; + stride = copy_src->stride; + offset = copy_src->offset; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkGeometryNV::safe_VkGeometryNV(const VkGeometryNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), geometryType(in_struct->geometryType), geometry(in_struct->geometry), flags(in_struct->flags) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkGeometryNV::safe_VkGeometryNV() + : sType(VK_STRUCTURE_TYPE_GEOMETRY_NV), pNext(nullptr), geometryType(), geometry(), flags() {} + +safe_VkGeometryNV::safe_VkGeometryNV(const safe_VkGeometryNV& copy_src) { + sType = copy_src.sType; + geometryType = copy_src.geometryType; + geometry = copy_src.geometry; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkGeometryNV& safe_VkGeometryNV::operator=(const safe_VkGeometryNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + geometryType = copy_src.geometryType; + geometry = copy_src.geometry; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkGeometryNV::~safe_VkGeometryNV() { FreePnextChain(pNext); } + +void safe_VkGeometryNV::initialize(const VkGeometryNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + geometryType = in_struct->geometryType; + geometry = in_struct->geometry; + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkGeometryNV::initialize(const safe_VkGeometryNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + geometryType = copy_src->geometryType; + geometry = copy_src->geometry; + flags = copy_src->flags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAccelerationStructureInfoNV::safe_VkAccelerationStructureInfoNV(const VkAccelerationStructureInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + type(in_struct->type), + flags(in_struct->flags), + instanceCount(in_struct->instanceCount), + geometryCount(in_struct->geometryCount), + pGeometries(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (geometryCount && in_struct->pGeometries) { + pGeometries = new safe_VkGeometryNV[geometryCount]; + for (uint32_t i = 0; i < geometryCount; ++i) { + pGeometries[i].initialize(&in_struct->pGeometries[i]); + } + } +} + +safe_VkAccelerationStructureInfoNV::safe_VkAccelerationStructureInfoNV() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV), + pNext(nullptr), + type(), + flags(), + instanceCount(), + geometryCount(), + pGeometries(nullptr) {} + +safe_VkAccelerationStructureInfoNV::safe_VkAccelerationStructureInfoNV(const safe_VkAccelerationStructureInfoNV& copy_src) { + sType = copy_src.sType; + type = copy_src.type; + flags = copy_src.flags; + instanceCount = copy_src.instanceCount; + geometryCount = copy_src.geometryCount; + pGeometries = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (geometryCount && copy_src.pGeometries) { + pGeometries = new safe_VkGeometryNV[geometryCount]; + for (uint32_t i = 0; i < geometryCount; ++i) { + pGeometries[i].initialize(©_src.pGeometries[i]); + } + } +} + +safe_VkAccelerationStructureInfoNV& safe_VkAccelerationStructureInfoNV::operator=( + const safe_VkAccelerationStructureInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pGeometries) delete[] pGeometries; + FreePnextChain(pNext); + + sType = copy_src.sType; + type = copy_src.type; + flags = copy_src.flags; + instanceCount = copy_src.instanceCount; + geometryCount = copy_src.geometryCount; + pGeometries = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (geometryCount && copy_src.pGeometries) { + pGeometries = new safe_VkGeometryNV[geometryCount]; + for (uint32_t i = 0; i < geometryCount; ++i) { + pGeometries[i].initialize(©_src.pGeometries[i]); + } + } + + return *this; +} + +safe_VkAccelerationStructureInfoNV::~safe_VkAccelerationStructureInfoNV() { + if (pGeometries) delete[] pGeometries; + FreePnextChain(pNext); +} + +void safe_VkAccelerationStructureInfoNV::initialize(const VkAccelerationStructureInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pGeometries) delete[] pGeometries; + FreePnextChain(pNext); + sType = in_struct->sType; + type = in_struct->type; + flags = in_struct->flags; + instanceCount = in_struct->instanceCount; + geometryCount = in_struct->geometryCount; + pGeometries = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (geometryCount && in_struct->pGeometries) { + pGeometries = new safe_VkGeometryNV[geometryCount]; + for (uint32_t i = 0; i < geometryCount; ++i) { + pGeometries[i].initialize(&in_struct->pGeometries[i]); + } + } +} + +void safe_VkAccelerationStructureInfoNV::initialize(const safe_VkAccelerationStructureInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + type = copy_src->type; + flags = copy_src->flags; + instanceCount = copy_src->instanceCount; + geometryCount = copy_src->geometryCount; + pGeometries = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (geometryCount && copy_src->pGeometries) { + pGeometries = new safe_VkGeometryNV[geometryCount]; + for (uint32_t i = 0; i < geometryCount; ++i) { + pGeometries[i].initialize(©_src->pGeometries[i]); + } + } +} + +safe_VkAccelerationStructureCreateInfoNV::safe_VkAccelerationStructureCreateInfoNV( + const VkAccelerationStructureCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), compactedSize(in_struct->compactedSize), info(&in_struct->info) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAccelerationStructureCreateInfoNV::safe_VkAccelerationStructureCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV), pNext(nullptr), compactedSize() {} + +safe_VkAccelerationStructureCreateInfoNV::safe_VkAccelerationStructureCreateInfoNV( + const safe_VkAccelerationStructureCreateInfoNV& copy_src) { + sType = copy_src.sType; + compactedSize = copy_src.compactedSize; + info.initialize(©_src.info); + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAccelerationStructureCreateInfoNV& safe_VkAccelerationStructureCreateInfoNV::operator=( + const safe_VkAccelerationStructureCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + compactedSize = copy_src.compactedSize; + info.initialize(©_src.info); + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAccelerationStructureCreateInfoNV::~safe_VkAccelerationStructureCreateInfoNV() { FreePnextChain(pNext); } + +void safe_VkAccelerationStructureCreateInfoNV::initialize(const VkAccelerationStructureCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + compactedSize = in_struct->compactedSize; + info.initialize(&in_struct->info); + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAccelerationStructureCreateInfoNV::initialize(const safe_VkAccelerationStructureCreateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + compactedSize = copy_src->compactedSize; + info.initialize(©_src->info); + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBindAccelerationStructureMemoryInfoNV::safe_VkBindAccelerationStructureMemoryInfoNV( + const VkBindAccelerationStructureMemoryInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + accelerationStructure(in_struct->accelerationStructure), + memory(in_struct->memory), + memoryOffset(in_struct->memoryOffset), + deviceIndexCount(in_struct->deviceIndexCount), + pDeviceIndices(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pDeviceIndices) { + pDeviceIndices = new uint32_t[in_struct->deviceIndexCount]; + memcpy((void*)pDeviceIndices, (void*)in_struct->pDeviceIndices, sizeof(uint32_t) * in_struct->deviceIndexCount); + } +} + +safe_VkBindAccelerationStructureMemoryInfoNV::safe_VkBindAccelerationStructureMemoryInfoNV() + : sType(VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV), + pNext(nullptr), + accelerationStructure(), + memory(), + memoryOffset(), + deviceIndexCount(), + pDeviceIndices(nullptr) {} + +safe_VkBindAccelerationStructureMemoryInfoNV::safe_VkBindAccelerationStructureMemoryInfoNV( + const safe_VkBindAccelerationStructureMemoryInfoNV& copy_src) { + sType = copy_src.sType; + accelerationStructure = copy_src.accelerationStructure; + memory = copy_src.memory; + memoryOffset = copy_src.memoryOffset; + deviceIndexCount = copy_src.deviceIndexCount; + pDeviceIndices = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDeviceIndices) { + pDeviceIndices = new uint32_t[copy_src.deviceIndexCount]; + memcpy((void*)pDeviceIndices, (void*)copy_src.pDeviceIndices, sizeof(uint32_t) * copy_src.deviceIndexCount); + } +} + +safe_VkBindAccelerationStructureMemoryInfoNV& safe_VkBindAccelerationStructureMemoryInfoNV::operator=( + const safe_VkBindAccelerationStructureMemoryInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pDeviceIndices) delete[] pDeviceIndices; + FreePnextChain(pNext); + + sType = copy_src.sType; + accelerationStructure = copy_src.accelerationStructure; + memory = copy_src.memory; + memoryOffset = copy_src.memoryOffset; + deviceIndexCount = copy_src.deviceIndexCount; + pDeviceIndices = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pDeviceIndices) { + pDeviceIndices = new uint32_t[copy_src.deviceIndexCount]; + memcpy((void*)pDeviceIndices, (void*)copy_src.pDeviceIndices, sizeof(uint32_t) * copy_src.deviceIndexCount); + } + + return *this; +} + +safe_VkBindAccelerationStructureMemoryInfoNV::~safe_VkBindAccelerationStructureMemoryInfoNV() { + if (pDeviceIndices) delete[] pDeviceIndices; + FreePnextChain(pNext); +} + +void safe_VkBindAccelerationStructureMemoryInfoNV::initialize(const VkBindAccelerationStructureMemoryInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDeviceIndices) delete[] pDeviceIndices; + FreePnextChain(pNext); + sType = in_struct->sType; + accelerationStructure = in_struct->accelerationStructure; + memory = in_struct->memory; + memoryOffset = in_struct->memoryOffset; + deviceIndexCount = in_struct->deviceIndexCount; + pDeviceIndices = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pDeviceIndices) { + pDeviceIndices = new uint32_t[in_struct->deviceIndexCount]; + memcpy((void*)pDeviceIndices, (void*)in_struct->pDeviceIndices, sizeof(uint32_t) * in_struct->deviceIndexCount); + } +} + +void safe_VkBindAccelerationStructureMemoryInfoNV::initialize(const safe_VkBindAccelerationStructureMemoryInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + accelerationStructure = copy_src->accelerationStructure; + memory = copy_src->memory; + memoryOffset = copy_src->memoryOffset; + deviceIndexCount = copy_src->deviceIndexCount; + pDeviceIndices = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pDeviceIndices) { + pDeviceIndices = new uint32_t[copy_src->deviceIndexCount]; + memcpy((void*)pDeviceIndices, (void*)copy_src->pDeviceIndices, sizeof(uint32_t) * copy_src->deviceIndexCount); + } +} + +safe_VkWriteDescriptorSetAccelerationStructureNV::safe_VkWriteDescriptorSetAccelerationStructureNV( + const VkWriteDescriptorSetAccelerationStructureNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), accelerationStructureCount(in_struct->accelerationStructureCount), pAccelerationStructures(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (accelerationStructureCount && in_struct->pAccelerationStructures) { + pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount]; + for (uint32_t i = 0; i < accelerationStructureCount; ++i) { + pAccelerationStructures[i] = in_struct->pAccelerationStructures[i]; + } + } +} + +safe_VkWriteDescriptorSetAccelerationStructureNV::safe_VkWriteDescriptorSetAccelerationStructureNV() + : sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV), + pNext(nullptr), + accelerationStructureCount(), + pAccelerationStructures(nullptr) {} + +safe_VkWriteDescriptorSetAccelerationStructureNV::safe_VkWriteDescriptorSetAccelerationStructureNV( + const safe_VkWriteDescriptorSetAccelerationStructureNV& copy_src) { + sType = copy_src.sType; + accelerationStructureCount = copy_src.accelerationStructureCount; + pAccelerationStructures = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (accelerationStructureCount && copy_src.pAccelerationStructures) { + pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount]; + for (uint32_t i = 0; i < accelerationStructureCount; ++i) { + pAccelerationStructures[i] = copy_src.pAccelerationStructures[i]; + } + } +} + +safe_VkWriteDescriptorSetAccelerationStructureNV& safe_VkWriteDescriptorSetAccelerationStructureNV::operator=( + const safe_VkWriteDescriptorSetAccelerationStructureNV& copy_src) { + if (©_src == this) return *this; + + if (pAccelerationStructures) delete[] pAccelerationStructures; + FreePnextChain(pNext); + + sType = copy_src.sType; + accelerationStructureCount = copy_src.accelerationStructureCount; + pAccelerationStructures = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (accelerationStructureCount && copy_src.pAccelerationStructures) { + pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount]; + for (uint32_t i = 0; i < accelerationStructureCount; ++i) { + pAccelerationStructures[i] = copy_src.pAccelerationStructures[i]; + } + } + + return *this; +} + +safe_VkWriteDescriptorSetAccelerationStructureNV::~safe_VkWriteDescriptorSetAccelerationStructureNV() { + if (pAccelerationStructures) delete[] pAccelerationStructures; + FreePnextChain(pNext); +} + +void safe_VkWriteDescriptorSetAccelerationStructureNV::initialize(const VkWriteDescriptorSetAccelerationStructureNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pAccelerationStructures) delete[] pAccelerationStructures; + FreePnextChain(pNext); + sType = in_struct->sType; + accelerationStructureCount = in_struct->accelerationStructureCount; + pAccelerationStructures = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (accelerationStructureCount && in_struct->pAccelerationStructures) { + pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount]; + for (uint32_t i = 0; i < accelerationStructureCount; ++i) { + pAccelerationStructures[i] = in_struct->pAccelerationStructures[i]; + } + } +} + +void safe_VkWriteDescriptorSetAccelerationStructureNV::initialize(const safe_VkWriteDescriptorSetAccelerationStructureNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + accelerationStructureCount = copy_src->accelerationStructureCount; + pAccelerationStructures = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (accelerationStructureCount && copy_src->pAccelerationStructures) { + pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount]; + for (uint32_t i = 0; i < accelerationStructureCount; ++i) { + pAccelerationStructures[i] = copy_src->pAccelerationStructures[i]; + } + } +} + +safe_VkAccelerationStructureMemoryRequirementsInfoNV::safe_VkAccelerationStructureMemoryRequirementsInfoNV( + const VkAccelerationStructureMemoryRequirementsInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), type(in_struct->type), accelerationStructure(in_struct->accelerationStructure) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAccelerationStructureMemoryRequirementsInfoNV::safe_VkAccelerationStructureMemoryRequirementsInfoNV() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV), + pNext(nullptr), + type(), + accelerationStructure() {} + +safe_VkAccelerationStructureMemoryRequirementsInfoNV::safe_VkAccelerationStructureMemoryRequirementsInfoNV( + const safe_VkAccelerationStructureMemoryRequirementsInfoNV& copy_src) { + sType = copy_src.sType; + type = copy_src.type; + accelerationStructure = copy_src.accelerationStructure; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAccelerationStructureMemoryRequirementsInfoNV& safe_VkAccelerationStructureMemoryRequirementsInfoNV::operator=( + const safe_VkAccelerationStructureMemoryRequirementsInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + type = copy_src.type; + accelerationStructure = copy_src.accelerationStructure; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAccelerationStructureMemoryRequirementsInfoNV::~safe_VkAccelerationStructureMemoryRequirementsInfoNV() { + FreePnextChain(pNext); +} + +void safe_VkAccelerationStructureMemoryRequirementsInfoNV::initialize( + const VkAccelerationStructureMemoryRequirementsInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + type = in_struct->type; + accelerationStructure = in_struct->accelerationStructure; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAccelerationStructureMemoryRequirementsInfoNV::initialize( + const safe_VkAccelerationStructureMemoryRequirementsInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + type = copy_src->type; + accelerationStructure = copy_src->accelerationStructure; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceRayTracingPropertiesNV::safe_VkPhysicalDeviceRayTracingPropertiesNV( + const VkPhysicalDeviceRayTracingPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shaderGroupHandleSize(in_struct->shaderGroupHandleSize), + maxRecursionDepth(in_struct->maxRecursionDepth), + maxShaderGroupStride(in_struct->maxShaderGroupStride), + shaderGroupBaseAlignment(in_struct->shaderGroupBaseAlignment), + maxGeometryCount(in_struct->maxGeometryCount), + maxInstanceCount(in_struct->maxInstanceCount), + maxTriangleCount(in_struct->maxTriangleCount), + maxDescriptorSetAccelerationStructures(in_struct->maxDescriptorSetAccelerationStructures) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceRayTracingPropertiesNV::safe_VkPhysicalDeviceRayTracingPropertiesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV), + pNext(nullptr), + shaderGroupHandleSize(), + maxRecursionDepth(), + maxShaderGroupStride(), + shaderGroupBaseAlignment(), + maxGeometryCount(), + maxInstanceCount(), + maxTriangleCount(), + maxDescriptorSetAccelerationStructures() {} + +safe_VkPhysicalDeviceRayTracingPropertiesNV::safe_VkPhysicalDeviceRayTracingPropertiesNV( + const safe_VkPhysicalDeviceRayTracingPropertiesNV& copy_src) { + sType = copy_src.sType; + shaderGroupHandleSize = copy_src.shaderGroupHandleSize; + maxRecursionDepth = copy_src.maxRecursionDepth; + maxShaderGroupStride = copy_src.maxShaderGroupStride; + shaderGroupBaseAlignment = copy_src.shaderGroupBaseAlignment; + maxGeometryCount = copy_src.maxGeometryCount; + maxInstanceCount = copy_src.maxInstanceCount; + maxTriangleCount = copy_src.maxTriangleCount; + maxDescriptorSetAccelerationStructures = copy_src.maxDescriptorSetAccelerationStructures; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceRayTracingPropertiesNV& safe_VkPhysicalDeviceRayTracingPropertiesNV::operator=( + const safe_VkPhysicalDeviceRayTracingPropertiesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderGroupHandleSize = copy_src.shaderGroupHandleSize; + maxRecursionDepth = copy_src.maxRecursionDepth; + maxShaderGroupStride = copy_src.maxShaderGroupStride; + shaderGroupBaseAlignment = copy_src.shaderGroupBaseAlignment; + maxGeometryCount = copy_src.maxGeometryCount; + maxInstanceCount = copy_src.maxInstanceCount; + maxTriangleCount = copy_src.maxTriangleCount; + maxDescriptorSetAccelerationStructures = copy_src.maxDescriptorSetAccelerationStructures; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceRayTracingPropertiesNV::~safe_VkPhysicalDeviceRayTracingPropertiesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceRayTracingPropertiesNV::initialize(const VkPhysicalDeviceRayTracingPropertiesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderGroupHandleSize = in_struct->shaderGroupHandleSize; + maxRecursionDepth = in_struct->maxRecursionDepth; + maxShaderGroupStride = in_struct->maxShaderGroupStride; + shaderGroupBaseAlignment = in_struct->shaderGroupBaseAlignment; + maxGeometryCount = in_struct->maxGeometryCount; + maxInstanceCount = in_struct->maxInstanceCount; + maxTriangleCount = in_struct->maxTriangleCount; + maxDescriptorSetAccelerationStructures = in_struct->maxDescriptorSetAccelerationStructures; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceRayTracingPropertiesNV::initialize(const safe_VkPhysicalDeviceRayTracingPropertiesNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderGroupHandleSize = copy_src->shaderGroupHandleSize; + maxRecursionDepth = copy_src->maxRecursionDepth; + maxShaderGroupStride = copy_src->maxShaderGroupStride; + shaderGroupBaseAlignment = copy_src->shaderGroupBaseAlignment; + maxGeometryCount = copy_src->maxGeometryCount; + maxInstanceCount = copy_src->maxInstanceCount; + maxTriangleCount = copy_src->maxTriangleCount; + maxDescriptorSetAccelerationStructures = copy_src->maxDescriptorSetAccelerationStructures; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV( + const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), representativeFragmentTest(in_struct->representativeFragmentTest) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV), + pNext(nullptr), + representativeFragmentTest() {} + +safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV( + const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& copy_src) { + sType = copy_src.sType; + representativeFragmentTest = copy_src.representativeFragmentTest; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::operator=( + const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + representativeFragmentTest = copy_src.representativeFragmentTest; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::~safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::initialize( + const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + representativeFragmentTest = in_struct->representativeFragmentTest; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::initialize( + const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + representativeFragmentTest = copy_src->representativeFragmentTest; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV( + const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), representativeFragmentTestEnable(in_struct->representativeFragmentTestEnable) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV), + pNext(nullptr), + representativeFragmentTestEnable() {} + +safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV( + const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& copy_src) { + sType = copy_src.sType; + representativeFragmentTestEnable = copy_src.representativeFragmentTestEnable; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::operator=( + const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + representativeFragmentTestEnable = copy_src.representativeFragmentTestEnable; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::~safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV() { + FreePnextChain(pNext); +} + +void safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::initialize( + const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + representativeFragmentTestEnable = in_struct->representativeFragmentTestEnable; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::initialize( + const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + representativeFragmentTestEnable = copy_src->representativeFragmentTestEnable; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineCompilerControlCreateInfoAMD::safe_VkPipelineCompilerControlCreateInfoAMD( + const VkPipelineCompilerControlCreateInfoAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), compilerControlFlags(in_struct->compilerControlFlags) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineCompilerControlCreateInfoAMD::safe_VkPipelineCompilerControlCreateInfoAMD() + : sType(VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD), pNext(nullptr), compilerControlFlags() {} + +safe_VkPipelineCompilerControlCreateInfoAMD::safe_VkPipelineCompilerControlCreateInfoAMD( + const safe_VkPipelineCompilerControlCreateInfoAMD& copy_src) { + sType = copy_src.sType; + compilerControlFlags = copy_src.compilerControlFlags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineCompilerControlCreateInfoAMD& safe_VkPipelineCompilerControlCreateInfoAMD::operator=( + const safe_VkPipelineCompilerControlCreateInfoAMD& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + compilerControlFlags = copy_src.compilerControlFlags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineCompilerControlCreateInfoAMD::~safe_VkPipelineCompilerControlCreateInfoAMD() { FreePnextChain(pNext); } + +void safe_VkPipelineCompilerControlCreateInfoAMD::initialize(const VkPipelineCompilerControlCreateInfoAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + compilerControlFlags = in_struct->compilerControlFlags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineCompilerControlCreateInfoAMD::initialize(const safe_VkPipelineCompilerControlCreateInfoAMD* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + compilerControlFlags = copy_src->compilerControlFlags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderCorePropertiesAMD::safe_VkPhysicalDeviceShaderCorePropertiesAMD( + const VkPhysicalDeviceShaderCorePropertiesAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shaderEngineCount(in_struct->shaderEngineCount), + shaderArraysPerEngineCount(in_struct->shaderArraysPerEngineCount), + computeUnitsPerShaderArray(in_struct->computeUnitsPerShaderArray), + simdPerComputeUnit(in_struct->simdPerComputeUnit), + wavefrontsPerSimd(in_struct->wavefrontsPerSimd), + wavefrontSize(in_struct->wavefrontSize), + sgprsPerSimd(in_struct->sgprsPerSimd), + minSgprAllocation(in_struct->minSgprAllocation), + maxSgprAllocation(in_struct->maxSgprAllocation), + sgprAllocationGranularity(in_struct->sgprAllocationGranularity), + vgprsPerSimd(in_struct->vgprsPerSimd), + minVgprAllocation(in_struct->minVgprAllocation), + maxVgprAllocation(in_struct->maxVgprAllocation), + vgprAllocationGranularity(in_struct->vgprAllocationGranularity) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderCorePropertiesAMD::safe_VkPhysicalDeviceShaderCorePropertiesAMD() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD), + pNext(nullptr), + shaderEngineCount(), + shaderArraysPerEngineCount(), + computeUnitsPerShaderArray(), + simdPerComputeUnit(), + wavefrontsPerSimd(), + wavefrontSize(), + sgprsPerSimd(), + minSgprAllocation(), + maxSgprAllocation(), + sgprAllocationGranularity(), + vgprsPerSimd(), + minVgprAllocation(), + maxVgprAllocation(), + vgprAllocationGranularity() {} + +safe_VkPhysicalDeviceShaderCorePropertiesAMD::safe_VkPhysicalDeviceShaderCorePropertiesAMD( + const safe_VkPhysicalDeviceShaderCorePropertiesAMD& copy_src) { + sType = copy_src.sType; + shaderEngineCount = copy_src.shaderEngineCount; + shaderArraysPerEngineCount = copy_src.shaderArraysPerEngineCount; + computeUnitsPerShaderArray = copy_src.computeUnitsPerShaderArray; + simdPerComputeUnit = copy_src.simdPerComputeUnit; + wavefrontsPerSimd = copy_src.wavefrontsPerSimd; + wavefrontSize = copy_src.wavefrontSize; + sgprsPerSimd = copy_src.sgprsPerSimd; + minSgprAllocation = copy_src.minSgprAllocation; + maxSgprAllocation = copy_src.maxSgprAllocation; + sgprAllocationGranularity = copy_src.sgprAllocationGranularity; + vgprsPerSimd = copy_src.vgprsPerSimd; + minVgprAllocation = copy_src.minVgprAllocation; + maxVgprAllocation = copy_src.maxVgprAllocation; + vgprAllocationGranularity = copy_src.vgprAllocationGranularity; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderCorePropertiesAMD& safe_VkPhysicalDeviceShaderCorePropertiesAMD::operator=( + const safe_VkPhysicalDeviceShaderCorePropertiesAMD& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderEngineCount = copy_src.shaderEngineCount; + shaderArraysPerEngineCount = copy_src.shaderArraysPerEngineCount; + computeUnitsPerShaderArray = copy_src.computeUnitsPerShaderArray; + simdPerComputeUnit = copy_src.simdPerComputeUnit; + wavefrontsPerSimd = copy_src.wavefrontsPerSimd; + wavefrontSize = copy_src.wavefrontSize; + sgprsPerSimd = copy_src.sgprsPerSimd; + minSgprAllocation = copy_src.minSgprAllocation; + maxSgprAllocation = copy_src.maxSgprAllocation; + sgprAllocationGranularity = copy_src.sgprAllocationGranularity; + vgprsPerSimd = copy_src.vgprsPerSimd; + minVgprAllocation = copy_src.minVgprAllocation; + maxVgprAllocation = copy_src.maxVgprAllocation; + vgprAllocationGranularity = copy_src.vgprAllocationGranularity; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderCorePropertiesAMD::~safe_VkPhysicalDeviceShaderCorePropertiesAMD() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderCorePropertiesAMD::initialize(const VkPhysicalDeviceShaderCorePropertiesAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderEngineCount = in_struct->shaderEngineCount; + shaderArraysPerEngineCount = in_struct->shaderArraysPerEngineCount; + computeUnitsPerShaderArray = in_struct->computeUnitsPerShaderArray; + simdPerComputeUnit = in_struct->simdPerComputeUnit; + wavefrontsPerSimd = in_struct->wavefrontsPerSimd; + wavefrontSize = in_struct->wavefrontSize; + sgprsPerSimd = in_struct->sgprsPerSimd; + minSgprAllocation = in_struct->minSgprAllocation; + maxSgprAllocation = in_struct->maxSgprAllocation; + sgprAllocationGranularity = in_struct->sgprAllocationGranularity; + vgprsPerSimd = in_struct->vgprsPerSimd; + minVgprAllocation = in_struct->minVgprAllocation; + maxVgprAllocation = in_struct->maxVgprAllocation; + vgprAllocationGranularity = in_struct->vgprAllocationGranularity; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderCorePropertiesAMD::initialize(const safe_VkPhysicalDeviceShaderCorePropertiesAMD* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderEngineCount = copy_src->shaderEngineCount; + shaderArraysPerEngineCount = copy_src->shaderArraysPerEngineCount; + computeUnitsPerShaderArray = copy_src->computeUnitsPerShaderArray; + simdPerComputeUnit = copy_src->simdPerComputeUnit; + wavefrontsPerSimd = copy_src->wavefrontsPerSimd; + wavefrontSize = copy_src->wavefrontSize; + sgprsPerSimd = copy_src->sgprsPerSimd; + minSgprAllocation = copy_src->minSgprAllocation; + maxSgprAllocation = copy_src->maxSgprAllocation; + sgprAllocationGranularity = copy_src->sgprAllocationGranularity; + vgprsPerSimd = copy_src->vgprsPerSimd; + minVgprAllocation = copy_src->minVgprAllocation; + maxVgprAllocation = copy_src->maxVgprAllocation; + vgprAllocationGranularity = copy_src->vgprAllocationGranularity; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDeviceMemoryOverallocationCreateInfoAMD::safe_VkDeviceMemoryOverallocationCreateInfoAMD( + const VkDeviceMemoryOverallocationCreateInfoAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), overallocationBehavior(in_struct->overallocationBehavior) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDeviceMemoryOverallocationCreateInfoAMD::safe_VkDeviceMemoryOverallocationCreateInfoAMD() + : sType(VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD), pNext(nullptr), overallocationBehavior() {} + +safe_VkDeviceMemoryOverallocationCreateInfoAMD::safe_VkDeviceMemoryOverallocationCreateInfoAMD( + const safe_VkDeviceMemoryOverallocationCreateInfoAMD& copy_src) { + sType = copy_src.sType; + overallocationBehavior = copy_src.overallocationBehavior; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDeviceMemoryOverallocationCreateInfoAMD& safe_VkDeviceMemoryOverallocationCreateInfoAMD::operator=( + const safe_VkDeviceMemoryOverallocationCreateInfoAMD& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + overallocationBehavior = copy_src.overallocationBehavior; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDeviceMemoryOverallocationCreateInfoAMD::~safe_VkDeviceMemoryOverallocationCreateInfoAMD() { FreePnextChain(pNext); } + +void safe_VkDeviceMemoryOverallocationCreateInfoAMD::initialize(const VkDeviceMemoryOverallocationCreateInfoAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + overallocationBehavior = in_struct->overallocationBehavior; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDeviceMemoryOverallocationCreateInfoAMD::initialize(const safe_VkDeviceMemoryOverallocationCreateInfoAMD* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + overallocationBehavior = copy_src->overallocationBehavior; + pNext = SafePnextCopy(copy_src->pNext); +} +#ifdef VK_USE_PLATFORM_GGP + +safe_VkPresentFrameTokenGGP::safe_VkPresentFrameTokenGGP(const VkPresentFrameTokenGGP* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), frameToken(in_struct->frameToken) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPresentFrameTokenGGP::safe_VkPresentFrameTokenGGP() + : sType(VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP), pNext(nullptr), frameToken() {} + +safe_VkPresentFrameTokenGGP::safe_VkPresentFrameTokenGGP(const safe_VkPresentFrameTokenGGP& copy_src) { + sType = copy_src.sType; + frameToken = copy_src.frameToken; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPresentFrameTokenGGP& safe_VkPresentFrameTokenGGP::operator=(const safe_VkPresentFrameTokenGGP& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + frameToken = copy_src.frameToken; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPresentFrameTokenGGP::~safe_VkPresentFrameTokenGGP() { FreePnextChain(pNext); } + +void safe_VkPresentFrameTokenGGP::initialize(const VkPresentFrameTokenGGP* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + frameToken = in_struct->frameToken; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPresentFrameTokenGGP::initialize(const safe_VkPresentFrameTokenGGP* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + frameToken = copy_src->frameToken; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_GGP + +safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV( + const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + computeDerivativeGroupQuads(in_struct->computeDerivativeGroupQuads), + computeDerivativeGroupLinear(in_struct->computeDerivativeGroupLinear) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV), + pNext(nullptr), + computeDerivativeGroupQuads(), + computeDerivativeGroupLinear() {} + +safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV( + const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& copy_src) { + sType = copy_src.sType; + computeDerivativeGroupQuads = copy_src.computeDerivativeGroupQuads; + computeDerivativeGroupLinear = copy_src.computeDerivativeGroupLinear; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::operator=( + const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + computeDerivativeGroupQuads = copy_src.computeDerivativeGroupQuads; + computeDerivativeGroupLinear = copy_src.computeDerivativeGroupLinear; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::~safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::initialize( + const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + computeDerivativeGroupQuads = in_struct->computeDerivativeGroupQuads; + computeDerivativeGroupLinear = in_struct->computeDerivativeGroupLinear; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::initialize( + const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + computeDerivativeGroupQuads = copy_src->computeDerivativeGroupQuads; + computeDerivativeGroupLinear = copy_src->computeDerivativeGroupLinear; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMeshShaderFeaturesNV::safe_VkPhysicalDeviceMeshShaderFeaturesNV( + const VkPhysicalDeviceMeshShaderFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), taskShader(in_struct->taskShader), meshShader(in_struct->meshShader) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMeshShaderFeaturesNV::safe_VkPhysicalDeviceMeshShaderFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV), pNext(nullptr), taskShader(), meshShader() {} + +safe_VkPhysicalDeviceMeshShaderFeaturesNV::safe_VkPhysicalDeviceMeshShaderFeaturesNV( + const safe_VkPhysicalDeviceMeshShaderFeaturesNV& copy_src) { + sType = copy_src.sType; + taskShader = copy_src.taskShader; + meshShader = copy_src.meshShader; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMeshShaderFeaturesNV& safe_VkPhysicalDeviceMeshShaderFeaturesNV::operator=( + const safe_VkPhysicalDeviceMeshShaderFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + taskShader = copy_src.taskShader; + meshShader = copy_src.meshShader; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMeshShaderFeaturesNV::~safe_VkPhysicalDeviceMeshShaderFeaturesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMeshShaderFeaturesNV::initialize(const VkPhysicalDeviceMeshShaderFeaturesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + taskShader = in_struct->taskShader; + meshShader = in_struct->meshShader; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMeshShaderFeaturesNV::initialize(const safe_VkPhysicalDeviceMeshShaderFeaturesNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + taskShader = copy_src->taskShader; + meshShader = copy_src->meshShader; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMeshShaderPropertiesNV::safe_VkPhysicalDeviceMeshShaderPropertiesNV( + const VkPhysicalDeviceMeshShaderPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + maxDrawMeshTasksCount(in_struct->maxDrawMeshTasksCount), + maxTaskWorkGroupInvocations(in_struct->maxTaskWorkGroupInvocations), + maxTaskTotalMemorySize(in_struct->maxTaskTotalMemorySize), + maxTaskOutputCount(in_struct->maxTaskOutputCount), + maxMeshWorkGroupInvocations(in_struct->maxMeshWorkGroupInvocations), + maxMeshTotalMemorySize(in_struct->maxMeshTotalMemorySize), + maxMeshOutputVertices(in_struct->maxMeshOutputVertices), + maxMeshOutputPrimitives(in_struct->maxMeshOutputPrimitives), + maxMeshMultiviewViewCount(in_struct->maxMeshMultiviewViewCount), + meshOutputPerVertexGranularity(in_struct->meshOutputPerVertexGranularity), + meshOutputPerPrimitiveGranularity(in_struct->meshOutputPerPrimitiveGranularity) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < 3; ++i) { + maxTaskWorkGroupSize[i] = in_struct->maxTaskWorkGroupSize[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxMeshWorkGroupSize[i] = in_struct->maxMeshWorkGroupSize[i]; + } +} + +safe_VkPhysicalDeviceMeshShaderPropertiesNV::safe_VkPhysicalDeviceMeshShaderPropertiesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV), + pNext(nullptr), + maxDrawMeshTasksCount(), + maxTaskWorkGroupInvocations(), + maxTaskTotalMemorySize(), + maxTaskOutputCount(), + maxMeshWorkGroupInvocations(), + maxMeshTotalMemorySize(), + maxMeshOutputVertices(), + maxMeshOutputPrimitives(), + maxMeshMultiviewViewCount(), + meshOutputPerVertexGranularity(), + meshOutputPerPrimitiveGranularity() {} + +safe_VkPhysicalDeviceMeshShaderPropertiesNV::safe_VkPhysicalDeviceMeshShaderPropertiesNV( + const safe_VkPhysicalDeviceMeshShaderPropertiesNV& copy_src) { + sType = copy_src.sType; + maxDrawMeshTasksCount = copy_src.maxDrawMeshTasksCount; + maxTaskWorkGroupInvocations = copy_src.maxTaskWorkGroupInvocations; + maxTaskTotalMemorySize = copy_src.maxTaskTotalMemorySize; + maxTaskOutputCount = copy_src.maxTaskOutputCount; + maxMeshWorkGroupInvocations = copy_src.maxMeshWorkGroupInvocations; + maxMeshTotalMemorySize = copy_src.maxMeshTotalMemorySize; + maxMeshOutputVertices = copy_src.maxMeshOutputVertices; + maxMeshOutputPrimitives = copy_src.maxMeshOutputPrimitives; + maxMeshMultiviewViewCount = copy_src.maxMeshMultiviewViewCount; + meshOutputPerVertexGranularity = copy_src.meshOutputPerVertexGranularity; + meshOutputPerPrimitiveGranularity = copy_src.meshOutputPerPrimitiveGranularity; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < 3; ++i) { + maxTaskWorkGroupSize[i] = copy_src.maxTaskWorkGroupSize[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxMeshWorkGroupSize[i] = copy_src.maxMeshWorkGroupSize[i]; + } +} + +safe_VkPhysicalDeviceMeshShaderPropertiesNV& safe_VkPhysicalDeviceMeshShaderPropertiesNV::operator=( + const safe_VkPhysicalDeviceMeshShaderPropertiesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxDrawMeshTasksCount = copy_src.maxDrawMeshTasksCount; + maxTaskWorkGroupInvocations = copy_src.maxTaskWorkGroupInvocations; + maxTaskTotalMemorySize = copy_src.maxTaskTotalMemorySize; + maxTaskOutputCount = copy_src.maxTaskOutputCount; + maxMeshWorkGroupInvocations = copy_src.maxMeshWorkGroupInvocations; + maxMeshTotalMemorySize = copy_src.maxMeshTotalMemorySize; + maxMeshOutputVertices = copy_src.maxMeshOutputVertices; + maxMeshOutputPrimitives = copy_src.maxMeshOutputPrimitives; + maxMeshMultiviewViewCount = copy_src.maxMeshMultiviewViewCount; + meshOutputPerVertexGranularity = copy_src.meshOutputPerVertexGranularity; + meshOutputPerPrimitiveGranularity = copy_src.meshOutputPerPrimitiveGranularity; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < 3; ++i) { + maxTaskWorkGroupSize[i] = copy_src.maxTaskWorkGroupSize[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxMeshWorkGroupSize[i] = copy_src.maxMeshWorkGroupSize[i]; + } + + return *this; +} + +safe_VkPhysicalDeviceMeshShaderPropertiesNV::~safe_VkPhysicalDeviceMeshShaderPropertiesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMeshShaderPropertiesNV::initialize(const VkPhysicalDeviceMeshShaderPropertiesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxDrawMeshTasksCount = in_struct->maxDrawMeshTasksCount; + maxTaskWorkGroupInvocations = in_struct->maxTaskWorkGroupInvocations; + maxTaskTotalMemorySize = in_struct->maxTaskTotalMemorySize; + maxTaskOutputCount = in_struct->maxTaskOutputCount; + maxMeshWorkGroupInvocations = in_struct->maxMeshWorkGroupInvocations; + maxMeshTotalMemorySize = in_struct->maxMeshTotalMemorySize; + maxMeshOutputVertices = in_struct->maxMeshOutputVertices; + maxMeshOutputPrimitives = in_struct->maxMeshOutputPrimitives; + maxMeshMultiviewViewCount = in_struct->maxMeshMultiviewViewCount; + meshOutputPerVertexGranularity = in_struct->meshOutputPerVertexGranularity; + meshOutputPerPrimitiveGranularity = in_struct->meshOutputPerPrimitiveGranularity; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < 3; ++i) { + maxTaskWorkGroupSize[i] = in_struct->maxTaskWorkGroupSize[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxMeshWorkGroupSize[i] = in_struct->maxMeshWorkGroupSize[i]; + } +} + +void safe_VkPhysicalDeviceMeshShaderPropertiesNV::initialize(const safe_VkPhysicalDeviceMeshShaderPropertiesNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxDrawMeshTasksCount = copy_src->maxDrawMeshTasksCount; + maxTaskWorkGroupInvocations = copy_src->maxTaskWorkGroupInvocations; + maxTaskTotalMemorySize = copy_src->maxTaskTotalMemorySize; + maxTaskOutputCount = copy_src->maxTaskOutputCount; + maxMeshWorkGroupInvocations = copy_src->maxMeshWorkGroupInvocations; + maxMeshTotalMemorySize = copy_src->maxMeshTotalMemorySize; + maxMeshOutputVertices = copy_src->maxMeshOutputVertices; + maxMeshOutputPrimitives = copy_src->maxMeshOutputPrimitives; + maxMeshMultiviewViewCount = copy_src->maxMeshMultiviewViewCount; + meshOutputPerVertexGranularity = copy_src->meshOutputPerVertexGranularity; + meshOutputPerPrimitiveGranularity = copy_src->meshOutputPerPrimitiveGranularity; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < 3; ++i) { + maxTaskWorkGroupSize[i] = copy_src->maxTaskWorkGroupSize[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxMeshWorkGroupSize[i] = copy_src->maxMeshWorkGroupSize[i]; + } +} + +safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV( + const VkPhysicalDeviceShaderImageFootprintFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), imageFootprint(in_struct->imageFootprint) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV), pNext(nullptr), imageFootprint() {} + +safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV( + const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& copy_src) { + sType = copy_src.sType; + imageFootprint = copy_src.imageFootprint; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::operator=( + const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + imageFootprint = copy_src.imageFootprint; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::~safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::initialize( + const VkPhysicalDeviceShaderImageFootprintFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + imageFootprint = in_struct->imageFootprint; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::initialize( + const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + imageFootprint = copy_src->imageFootprint; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV( + const VkPipelineViewportExclusiveScissorStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), exclusiveScissorCount(in_struct->exclusiveScissorCount), pExclusiveScissors(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pExclusiveScissors) { + pExclusiveScissors = new VkRect2D[in_struct->exclusiveScissorCount]; + memcpy((void*)pExclusiveScissors, (void*)in_struct->pExclusiveScissors, + sizeof(VkRect2D) * in_struct->exclusiveScissorCount); + } +} + +safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV), + pNext(nullptr), + exclusiveScissorCount(), + pExclusiveScissors(nullptr) {} + +safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV( + const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& copy_src) { + sType = copy_src.sType; + exclusiveScissorCount = copy_src.exclusiveScissorCount; + pExclusiveScissors = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pExclusiveScissors) { + pExclusiveScissors = new VkRect2D[copy_src.exclusiveScissorCount]; + memcpy((void*)pExclusiveScissors, (void*)copy_src.pExclusiveScissors, sizeof(VkRect2D) * copy_src.exclusiveScissorCount); + } +} + +safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::operator=( + const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pExclusiveScissors) delete[] pExclusiveScissors; + FreePnextChain(pNext); + + sType = copy_src.sType; + exclusiveScissorCount = copy_src.exclusiveScissorCount; + pExclusiveScissors = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pExclusiveScissors) { + pExclusiveScissors = new VkRect2D[copy_src.exclusiveScissorCount]; + memcpy((void*)pExclusiveScissors, (void*)copy_src.pExclusiveScissors, sizeof(VkRect2D) * copy_src.exclusiveScissorCount); + } + + return *this; +} + +safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::~safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV() { + if (pExclusiveScissors) delete[] pExclusiveScissors; + FreePnextChain(pNext); +} + +void safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::initialize( + const VkPipelineViewportExclusiveScissorStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pExclusiveScissors) delete[] pExclusiveScissors; + FreePnextChain(pNext); + sType = in_struct->sType; + exclusiveScissorCount = in_struct->exclusiveScissorCount; + pExclusiveScissors = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pExclusiveScissors) { + pExclusiveScissors = new VkRect2D[in_struct->exclusiveScissorCount]; + memcpy((void*)pExclusiveScissors, (void*)in_struct->pExclusiveScissors, + sizeof(VkRect2D) * in_struct->exclusiveScissorCount); + } +} + +void safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::initialize( + const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + exclusiveScissorCount = copy_src->exclusiveScissorCount; + pExclusiveScissors = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pExclusiveScissors) { + pExclusiveScissors = new VkRect2D[copy_src->exclusiveScissorCount]; + memcpy((void*)pExclusiveScissors, (void*)copy_src->pExclusiveScissors, sizeof(VkRect2D) * copy_src->exclusiveScissorCount); + } +} + +safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::safe_VkPhysicalDeviceExclusiveScissorFeaturesNV( + const VkPhysicalDeviceExclusiveScissorFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), exclusiveScissor(in_struct->exclusiveScissor) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::safe_VkPhysicalDeviceExclusiveScissorFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV), pNext(nullptr), exclusiveScissor() {} + +safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::safe_VkPhysicalDeviceExclusiveScissorFeaturesNV( + const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& copy_src) { + sType = copy_src.sType; + exclusiveScissor = copy_src.exclusiveScissor; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::operator=( + const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + exclusiveScissor = copy_src.exclusiveScissor; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::~safe_VkPhysicalDeviceExclusiveScissorFeaturesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::initialize(const VkPhysicalDeviceExclusiveScissorFeaturesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + exclusiveScissor = in_struct->exclusiveScissor; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::initialize(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + exclusiveScissor = copy_src->exclusiveScissor; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkQueueFamilyCheckpointPropertiesNV::safe_VkQueueFamilyCheckpointPropertiesNV( + const VkQueueFamilyCheckpointPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), checkpointExecutionStageMask(in_struct->checkpointExecutionStageMask) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkQueueFamilyCheckpointPropertiesNV::safe_VkQueueFamilyCheckpointPropertiesNV() + : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV), pNext(nullptr), checkpointExecutionStageMask() {} + +safe_VkQueueFamilyCheckpointPropertiesNV::safe_VkQueueFamilyCheckpointPropertiesNV( + const safe_VkQueueFamilyCheckpointPropertiesNV& copy_src) { + sType = copy_src.sType; + checkpointExecutionStageMask = copy_src.checkpointExecutionStageMask; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkQueueFamilyCheckpointPropertiesNV& safe_VkQueueFamilyCheckpointPropertiesNV::operator=( + const safe_VkQueueFamilyCheckpointPropertiesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + checkpointExecutionStageMask = copy_src.checkpointExecutionStageMask; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkQueueFamilyCheckpointPropertiesNV::~safe_VkQueueFamilyCheckpointPropertiesNV() { FreePnextChain(pNext); } + +void safe_VkQueueFamilyCheckpointPropertiesNV::initialize(const VkQueueFamilyCheckpointPropertiesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + checkpointExecutionStageMask = in_struct->checkpointExecutionStageMask; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkQueueFamilyCheckpointPropertiesNV::initialize(const safe_VkQueueFamilyCheckpointPropertiesNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + checkpointExecutionStageMask = copy_src->checkpointExecutionStageMask; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCheckpointDataNV::safe_VkCheckpointDataNV(const VkCheckpointDataNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), stage(in_struct->stage), pCheckpointMarker(in_struct->pCheckpointMarker) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCheckpointDataNV::safe_VkCheckpointDataNV() + : sType(VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV), pNext(nullptr), stage(), pCheckpointMarker(nullptr) {} + +safe_VkCheckpointDataNV::safe_VkCheckpointDataNV(const safe_VkCheckpointDataNV& copy_src) { + sType = copy_src.sType; + stage = copy_src.stage; + pCheckpointMarker = copy_src.pCheckpointMarker; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCheckpointDataNV& safe_VkCheckpointDataNV::operator=(const safe_VkCheckpointDataNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + stage = copy_src.stage; + pCheckpointMarker = copy_src.pCheckpointMarker; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCheckpointDataNV::~safe_VkCheckpointDataNV() { FreePnextChain(pNext); } + +void safe_VkCheckpointDataNV::initialize(const VkCheckpointDataNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + stage = in_struct->stage; + pCheckpointMarker = in_struct->pCheckpointMarker; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCheckpointDataNV::initialize(const safe_VkCheckpointDataNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stage = copy_src->stage; + pCheckpointMarker = copy_src->pCheckpointMarker; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( + const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), shaderIntegerFunctions2(in_struct->shaderIntegerFunctions2) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL), + pNext(nullptr), + shaderIntegerFunctions2() {} + +safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( + const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& copy_src) { + sType = copy_src.sType; + shaderIntegerFunctions2 = copy_src.shaderIntegerFunctions2; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::operator=( + const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderIntegerFunctions2 = copy_src.shaderIntegerFunctions2; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::~safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::initialize( + const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderIntegerFunctions2 = in_struct->shaderIntegerFunctions2; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::initialize( + const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderIntegerFunctions2 = copy_src->shaderIntegerFunctions2; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPerformanceValueDataINTEL::safe_VkPerformanceValueDataINTEL(const VkPerformanceValueDataINTEL* in_struct, PNextCopyState*) { + initialize(in_struct); +} + +safe_VkPerformanceValueDataINTEL::safe_VkPerformanceValueDataINTEL() : valueString(nullptr) {} + +safe_VkPerformanceValueDataINTEL::safe_VkPerformanceValueDataINTEL(const safe_VkPerformanceValueDataINTEL& copy_src) { + value32 = copy_src.value32; + value64 = copy_src.value64; + valueFloat = copy_src.valueFloat; + valueBool = copy_src.valueBool; + valueString = SafeStringCopy(copy_src.valueString); +} + +safe_VkPerformanceValueDataINTEL& safe_VkPerformanceValueDataINTEL::operator=(const safe_VkPerformanceValueDataINTEL& copy_src) { + if (©_src == this) return *this; + + if (valueString) delete[] valueString; + + value32 = copy_src.value32; + value64 = copy_src.value64; + valueFloat = copy_src.valueFloat; + valueBool = copy_src.valueBool; + valueString = SafeStringCopy(copy_src.valueString); + + return *this; +} + +safe_VkPerformanceValueDataINTEL::~safe_VkPerformanceValueDataINTEL() { + if (valueString) delete[] valueString; +} + +void safe_VkPerformanceValueDataINTEL::initialize(const VkPerformanceValueDataINTEL* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (valueString) delete[] valueString; + value32 = in_struct->value32; + value64 = in_struct->value64; + valueFloat = in_struct->valueFloat; + valueBool = in_struct->valueBool; + valueString = SafeStringCopy(in_struct->valueString); +} + +void safe_VkPerformanceValueDataINTEL::initialize(const safe_VkPerformanceValueDataINTEL* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + value32 = copy_src->value32; + value64 = copy_src->value64; + valueFloat = copy_src->valueFloat; + valueBool = copy_src->valueBool; + valueString = SafeStringCopy(copy_src->valueString); +} + +safe_VkInitializePerformanceApiInfoINTEL::safe_VkInitializePerformanceApiInfoINTEL( + const VkInitializePerformanceApiInfoINTEL* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pUserData(in_struct->pUserData) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkInitializePerformanceApiInfoINTEL::safe_VkInitializePerformanceApiInfoINTEL() + : sType(VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL), pNext(nullptr), pUserData(nullptr) {} + +safe_VkInitializePerformanceApiInfoINTEL::safe_VkInitializePerformanceApiInfoINTEL( + const safe_VkInitializePerformanceApiInfoINTEL& copy_src) { + sType = copy_src.sType; + pUserData = copy_src.pUserData; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkInitializePerformanceApiInfoINTEL& safe_VkInitializePerformanceApiInfoINTEL::operator=( + const safe_VkInitializePerformanceApiInfoINTEL& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pUserData = copy_src.pUserData; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkInitializePerformanceApiInfoINTEL::~safe_VkInitializePerformanceApiInfoINTEL() { FreePnextChain(pNext); } + +void safe_VkInitializePerformanceApiInfoINTEL::initialize(const VkInitializePerformanceApiInfoINTEL* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pUserData = in_struct->pUserData; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkInitializePerformanceApiInfoINTEL::initialize(const safe_VkInitializePerformanceApiInfoINTEL* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pUserData = copy_src->pUserData; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::safe_VkQueryPoolPerformanceQueryCreateInfoINTEL( + const VkQueryPoolPerformanceQueryCreateInfoINTEL* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), performanceCountersSampling(in_struct->performanceCountersSampling) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::safe_VkQueryPoolPerformanceQueryCreateInfoINTEL() + : sType(VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL), pNext(nullptr), performanceCountersSampling() {} + +safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::safe_VkQueryPoolPerformanceQueryCreateInfoINTEL( + const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL& copy_src) { + sType = copy_src.sType; + performanceCountersSampling = copy_src.performanceCountersSampling; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkQueryPoolPerformanceQueryCreateInfoINTEL& safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::operator=( + const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + performanceCountersSampling = copy_src.performanceCountersSampling; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::~safe_VkQueryPoolPerformanceQueryCreateInfoINTEL() { FreePnextChain(pNext); } + +void safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::initialize(const VkQueryPoolPerformanceQueryCreateInfoINTEL* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + performanceCountersSampling = in_struct->performanceCountersSampling; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::initialize(const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + performanceCountersSampling = copy_src->performanceCountersSampling; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPerformanceMarkerInfoINTEL::safe_VkPerformanceMarkerInfoINTEL(const VkPerformanceMarkerInfoINTEL* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), marker(in_struct->marker) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPerformanceMarkerInfoINTEL::safe_VkPerformanceMarkerInfoINTEL() + : sType(VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL), pNext(nullptr), marker() {} + +safe_VkPerformanceMarkerInfoINTEL::safe_VkPerformanceMarkerInfoINTEL(const safe_VkPerformanceMarkerInfoINTEL& copy_src) { + sType = copy_src.sType; + marker = copy_src.marker; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPerformanceMarkerInfoINTEL& safe_VkPerformanceMarkerInfoINTEL::operator=(const safe_VkPerformanceMarkerInfoINTEL& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + marker = copy_src.marker; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPerformanceMarkerInfoINTEL::~safe_VkPerformanceMarkerInfoINTEL() { FreePnextChain(pNext); } + +void safe_VkPerformanceMarkerInfoINTEL::initialize(const VkPerformanceMarkerInfoINTEL* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + marker = in_struct->marker; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPerformanceMarkerInfoINTEL::initialize(const safe_VkPerformanceMarkerInfoINTEL* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + marker = copy_src->marker; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPerformanceStreamMarkerInfoINTEL::safe_VkPerformanceStreamMarkerInfoINTEL( + const VkPerformanceStreamMarkerInfoINTEL* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), marker(in_struct->marker) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPerformanceStreamMarkerInfoINTEL::safe_VkPerformanceStreamMarkerInfoINTEL() + : sType(VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL), pNext(nullptr), marker() {} + +safe_VkPerformanceStreamMarkerInfoINTEL::safe_VkPerformanceStreamMarkerInfoINTEL( + const safe_VkPerformanceStreamMarkerInfoINTEL& copy_src) { + sType = copy_src.sType; + marker = copy_src.marker; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPerformanceStreamMarkerInfoINTEL& safe_VkPerformanceStreamMarkerInfoINTEL::operator=( + const safe_VkPerformanceStreamMarkerInfoINTEL& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + marker = copy_src.marker; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPerformanceStreamMarkerInfoINTEL::~safe_VkPerformanceStreamMarkerInfoINTEL() { FreePnextChain(pNext); } + +void safe_VkPerformanceStreamMarkerInfoINTEL::initialize(const VkPerformanceStreamMarkerInfoINTEL* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + marker = in_struct->marker; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPerformanceStreamMarkerInfoINTEL::initialize(const safe_VkPerformanceStreamMarkerInfoINTEL* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + marker = copy_src->marker; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPerformanceOverrideInfoINTEL::safe_VkPerformanceOverrideInfoINTEL(const VkPerformanceOverrideInfoINTEL* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), type(in_struct->type), enable(in_struct->enable), parameter(in_struct->parameter) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPerformanceOverrideInfoINTEL::safe_VkPerformanceOverrideInfoINTEL() + : sType(VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL), pNext(nullptr), type(), enable(), parameter() {} + +safe_VkPerformanceOverrideInfoINTEL::safe_VkPerformanceOverrideInfoINTEL(const safe_VkPerformanceOverrideInfoINTEL& copy_src) { + sType = copy_src.sType; + type = copy_src.type; + enable = copy_src.enable; + parameter = copy_src.parameter; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPerformanceOverrideInfoINTEL& safe_VkPerformanceOverrideInfoINTEL::operator=( + const safe_VkPerformanceOverrideInfoINTEL& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + type = copy_src.type; + enable = copy_src.enable; + parameter = copy_src.parameter; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPerformanceOverrideInfoINTEL::~safe_VkPerformanceOverrideInfoINTEL() { FreePnextChain(pNext); } + +void safe_VkPerformanceOverrideInfoINTEL::initialize(const VkPerformanceOverrideInfoINTEL* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + type = in_struct->type; + enable = in_struct->enable; + parameter = in_struct->parameter; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPerformanceOverrideInfoINTEL::initialize(const safe_VkPerformanceOverrideInfoINTEL* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + type = copy_src->type; + enable = copy_src->enable; + parameter = copy_src->parameter; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPerformanceConfigurationAcquireInfoINTEL::safe_VkPerformanceConfigurationAcquireInfoINTEL( + const VkPerformanceConfigurationAcquireInfoINTEL* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), type(in_struct->type) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPerformanceConfigurationAcquireInfoINTEL::safe_VkPerformanceConfigurationAcquireInfoINTEL() + : sType(VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL), pNext(nullptr), type() {} + +safe_VkPerformanceConfigurationAcquireInfoINTEL::safe_VkPerformanceConfigurationAcquireInfoINTEL( + const safe_VkPerformanceConfigurationAcquireInfoINTEL& copy_src) { + sType = copy_src.sType; + type = copy_src.type; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPerformanceConfigurationAcquireInfoINTEL& safe_VkPerformanceConfigurationAcquireInfoINTEL::operator=( + const safe_VkPerformanceConfigurationAcquireInfoINTEL& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + type = copy_src.type; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPerformanceConfigurationAcquireInfoINTEL::~safe_VkPerformanceConfigurationAcquireInfoINTEL() { FreePnextChain(pNext); } + +void safe_VkPerformanceConfigurationAcquireInfoINTEL::initialize(const VkPerformanceConfigurationAcquireInfoINTEL* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + type = in_struct->type; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPerformanceConfigurationAcquireInfoINTEL::initialize(const safe_VkPerformanceConfigurationAcquireInfoINTEL* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + type = copy_src->type; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD( + const VkDisplayNativeHdrSurfaceCapabilitiesAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), localDimmingSupport(in_struct->localDimmingSupport) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD() + : sType(VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD), pNext(nullptr), localDimmingSupport() {} + +safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD( + const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& copy_src) { + sType = copy_src.sType; + localDimmingSupport = copy_src.localDimmingSupport; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::operator=( + const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + localDimmingSupport = copy_src.localDimmingSupport; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::~safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD() { FreePnextChain(pNext); } + +void safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::initialize(const VkDisplayNativeHdrSurfaceCapabilitiesAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + localDimmingSupport = in_struct->localDimmingSupport; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::initialize(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + localDimmingSupport = copy_src->localDimmingSupport; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::safe_VkSwapchainDisplayNativeHdrCreateInfoAMD( + const VkSwapchainDisplayNativeHdrCreateInfoAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), localDimmingEnable(in_struct->localDimmingEnable) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::safe_VkSwapchainDisplayNativeHdrCreateInfoAMD() + : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD), pNext(nullptr), localDimmingEnable() {} + +safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::safe_VkSwapchainDisplayNativeHdrCreateInfoAMD( + const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& copy_src) { + sType = copy_src.sType; + localDimmingEnable = copy_src.localDimmingEnable; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::operator=( + const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + localDimmingEnable = copy_src.localDimmingEnable; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::~safe_VkSwapchainDisplayNativeHdrCreateInfoAMD() { FreePnextChain(pNext); } + +void safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::initialize(const VkSwapchainDisplayNativeHdrCreateInfoAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + localDimmingEnable = in_struct->localDimmingEnable; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::initialize(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + localDimmingEnable = copy_src->localDimmingEnable; + pNext = SafePnextCopy(copy_src->pNext); +} +#ifdef VK_USE_PLATFORM_FUCHSIA + +safe_VkImagePipeSurfaceCreateInfoFUCHSIA::safe_VkImagePipeSurfaceCreateInfoFUCHSIA( + const VkImagePipeSurfaceCreateInfoFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), imagePipeHandle(in_struct->imagePipeHandle) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImagePipeSurfaceCreateInfoFUCHSIA::safe_VkImagePipeSurfaceCreateInfoFUCHSIA() + : sType(VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA), pNext(nullptr), flags(), imagePipeHandle() {} + +safe_VkImagePipeSurfaceCreateInfoFUCHSIA::safe_VkImagePipeSurfaceCreateInfoFUCHSIA( + const safe_VkImagePipeSurfaceCreateInfoFUCHSIA& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + imagePipeHandle = copy_src.imagePipeHandle; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImagePipeSurfaceCreateInfoFUCHSIA& safe_VkImagePipeSurfaceCreateInfoFUCHSIA::operator=( + const safe_VkImagePipeSurfaceCreateInfoFUCHSIA& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + imagePipeHandle = copy_src.imagePipeHandle; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImagePipeSurfaceCreateInfoFUCHSIA::~safe_VkImagePipeSurfaceCreateInfoFUCHSIA() { FreePnextChain(pNext); } + +void safe_VkImagePipeSurfaceCreateInfoFUCHSIA::initialize(const VkImagePipeSurfaceCreateInfoFUCHSIA* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + imagePipeHandle = in_struct->imagePipeHandle; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImagePipeSurfaceCreateInfoFUCHSIA::initialize(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + imagePipeHandle = copy_src->imagePipeHandle; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_FUCHSIA + +safe_VkPhysicalDeviceShaderCoreProperties2AMD::safe_VkPhysicalDeviceShaderCoreProperties2AMD( + const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shaderCoreFeatures(in_struct->shaderCoreFeatures), + activeComputeUnitCount(in_struct->activeComputeUnitCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderCoreProperties2AMD::safe_VkPhysicalDeviceShaderCoreProperties2AMD() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD), + pNext(nullptr), + shaderCoreFeatures(), + activeComputeUnitCount() {} + +safe_VkPhysicalDeviceShaderCoreProperties2AMD::safe_VkPhysicalDeviceShaderCoreProperties2AMD( + const safe_VkPhysicalDeviceShaderCoreProperties2AMD& copy_src) { + sType = copy_src.sType; + shaderCoreFeatures = copy_src.shaderCoreFeatures; + activeComputeUnitCount = copy_src.activeComputeUnitCount; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderCoreProperties2AMD& safe_VkPhysicalDeviceShaderCoreProperties2AMD::operator=( + const safe_VkPhysicalDeviceShaderCoreProperties2AMD& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderCoreFeatures = copy_src.shaderCoreFeatures; + activeComputeUnitCount = copy_src.activeComputeUnitCount; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderCoreProperties2AMD::~safe_VkPhysicalDeviceShaderCoreProperties2AMD() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderCoreProperties2AMD::initialize(const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderCoreFeatures = in_struct->shaderCoreFeatures; + activeComputeUnitCount = in_struct->activeComputeUnitCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderCoreProperties2AMD::initialize(const safe_VkPhysicalDeviceShaderCoreProperties2AMD* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderCoreFeatures = copy_src->shaderCoreFeatures; + activeComputeUnitCount = copy_src->activeComputeUnitCount; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD( + const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), deviceCoherentMemory(in_struct->deviceCoherentMemory) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD), pNext(nullptr), deviceCoherentMemory() {} + +safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD( + const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& copy_src) { + sType = copy_src.sType; + deviceCoherentMemory = copy_src.deviceCoherentMemory; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::operator=( + const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + deviceCoherentMemory = copy_src.deviceCoherentMemory; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::~safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::initialize(const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + deviceCoherentMemory = in_struct->deviceCoherentMemory; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::initialize(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + deviceCoherentMemory = copy_src->deviceCoherentMemory; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( + const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), dedicatedAllocationImageAliasing(in_struct->dedicatedAllocationImageAliasing) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV), + pNext(nullptr), + dedicatedAllocationImageAliasing() {} + +safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( + const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& copy_src) { + sType = copy_src.sType; + dedicatedAllocationImageAliasing = copy_src.dedicatedAllocationImageAliasing; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& +safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::operator=( + const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + dedicatedAllocationImageAliasing = copy_src.dedicatedAllocationImageAliasing; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV:: + ~safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::initialize( + const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + dedicatedAllocationImageAliasing = in_struct->dedicatedAllocationImageAliasing; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::initialize( + const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + dedicatedAllocationImageAliasing = copy_src->dedicatedAllocationImageAliasing; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCooperativeMatrixPropertiesNV::safe_VkCooperativeMatrixPropertiesNV(const VkCooperativeMatrixPropertiesNV* 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), + DType(in_struct->DType), + scope(in_struct->scope) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCooperativeMatrixPropertiesNV::safe_VkCooperativeMatrixPropertiesNV() + : sType(VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV), + pNext(nullptr), + MSize(), + NSize(), + KSize(), + AType(), + BType(), + CType(), + DType(), + scope() {} + +safe_VkCooperativeMatrixPropertiesNV::safe_VkCooperativeMatrixPropertiesNV(const safe_VkCooperativeMatrixPropertiesNV& 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; + DType = copy_src.DType; + scope = copy_src.scope; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCooperativeMatrixPropertiesNV& safe_VkCooperativeMatrixPropertiesNV::operator=( + const safe_VkCooperativeMatrixPropertiesNV& 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; + DType = copy_src.DType; + scope = copy_src.scope; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCooperativeMatrixPropertiesNV::~safe_VkCooperativeMatrixPropertiesNV() { FreePnextChain(pNext); } + +void safe_VkCooperativeMatrixPropertiesNV::initialize(const VkCooperativeMatrixPropertiesNV* 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; + DType = in_struct->DType; + scope = in_struct->scope; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCooperativeMatrixPropertiesNV::initialize(const safe_VkCooperativeMatrixPropertiesNV* 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; + DType = copy_src->DType; + scope = copy_src->scope; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV( + const VkPhysicalDeviceCooperativeMatrixFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + cooperativeMatrix(in_struct->cooperativeMatrix), + cooperativeMatrixRobustBufferAccess(in_struct->cooperativeMatrixRobustBufferAccess) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV), + pNext(nullptr), + cooperativeMatrix(), + cooperativeMatrixRobustBufferAccess() {} + +safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV( + const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& copy_src) { + sType = copy_src.sType; + cooperativeMatrix = copy_src.cooperativeMatrix; + cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::operator=( + const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + cooperativeMatrix = copy_src.cooperativeMatrix; + cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::~safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + cooperativeMatrix = in_struct->cooperativeMatrix; + cooperativeMatrixRobustBufferAccess = in_struct->cooperativeMatrixRobustBufferAccess; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::initialize(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + cooperativeMatrix = copy_src->cooperativeMatrix; + cooperativeMatrixRobustBufferAccess = copy_src->cooperativeMatrixRobustBufferAccess; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV( + const VkPhysicalDeviceCooperativeMatrixPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), cooperativeMatrixSupportedStages(in_struct->cooperativeMatrixSupportedStages) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV), + pNext(nullptr), + cooperativeMatrixSupportedStages() {} + +safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV( + const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& copy_src) { + sType = copy_src.sType; + cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::operator=( + const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::~safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::initialize(const VkPhysicalDeviceCooperativeMatrixPropertiesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + cooperativeMatrixSupportedStages = in_struct->cooperativeMatrixSupportedStages; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::initialize( + const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + cooperativeMatrixSupportedStages = copy_src->cooperativeMatrixSupportedStages; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV( + const VkPhysicalDeviceCoverageReductionModeFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), coverageReductionMode(in_struct->coverageReductionMode) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV), pNext(nullptr), coverageReductionMode() {} + +safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV( + const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& copy_src) { + sType = copy_src.sType; + coverageReductionMode = copy_src.coverageReductionMode; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::operator=( + const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + coverageReductionMode = copy_src.coverageReductionMode; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::~safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::initialize( + const VkPhysicalDeviceCoverageReductionModeFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + coverageReductionMode = in_struct->coverageReductionMode; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::initialize( + const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + coverageReductionMode = copy_src->coverageReductionMode; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineCoverageReductionStateCreateInfoNV::safe_VkPipelineCoverageReductionStateCreateInfoNV( + const VkPipelineCoverageReductionStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), coverageReductionMode(in_struct->coverageReductionMode) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineCoverageReductionStateCreateInfoNV::safe_VkPipelineCoverageReductionStateCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV), pNext(nullptr), flags(), coverageReductionMode() {} + +safe_VkPipelineCoverageReductionStateCreateInfoNV::safe_VkPipelineCoverageReductionStateCreateInfoNV( + const safe_VkPipelineCoverageReductionStateCreateInfoNV& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + coverageReductionMode = copy_src.coverageReductionMode; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineCoverageReductionStateCreateInfoNV& safe_VkPipelineCoverageReductionStateCreateInfoNV::operator=( + const safe_VkPipelineCoverageReductionStateCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + coverageReductionMode = copy_src.coverageReductionMode; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineCoverageReductionStateCreateInfoNV::~safe_VkPipelineCoverageReductionStateCreateInfoNV() { FreePnextChain(pNext); } + +void safe_VkPipelineCoverageReductionStateCreateInfoNV::initialize(const VkPipelineCoverageReductionStateCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + coverageReductionMode = in_struct->coverageReductionMode; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineCoverageReductionStateCreateInfoNV::initialize( + const safe_VkPipelineCoverageReductionStateCreateInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + coverageReductionMode = copy_src->coverageReductionMode; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkFramebufferMixedSamplesCombinationNV::safe_VkFramebufferMixedSamplesCombinationNV( + const VkFramebufferMixedSamplesCombinationNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + coverageReductionMode(in_struct->coverageReductionMode), + rasterizationSamples(in_struct->rasterizationSamples), + depthStencilSamples(in_struct->depthStencilSamples), + colorSamples(in_struct->colorSamples) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkFramebufferMixedSamplesCombinationNV::safe_VkFramebufferMixedSamplesCombinationNV() + : sType(VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV), + pNext(nullptr), + coverageReductionMode(), + rasterizationSamples(), + depthStencilSamples(), + colorSamples() {} + +safe_VkFramebufferMixedSamplesCombinationNV::safe_VkFramebufferMixedSamplesCombinationNV( + const safe_VkFramebufferMixedSamplesCombinationNV& copy_src) { + sType = copy_src.sType; + coverageReductionMode = copy_src.coverageReductionMode; + rasterizationSamples = copy_src.rasterizationSamples; + depthStencilSamples = copy_src.depthStencilSamples; + colorSamples = copy_src.colorSamples; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkFramebufferMixedSamplesCombinationNV& safe_VkFramebufferMixedSamplesCombinationNV::operator=( + const safe_VkFramebufferMixedSamplesCombinationNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + coverageReductionMode = copy_src.coverageReductionMode; + rasterizationSamples = copy_src.rasterizationSamples; + depthStencilSamples = copy_src.depthStencilSamples; + colorSamples = copy_src.colorSamples; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkFramebufferMixedSamplesCombinationNV::~safe_VkFramebufferMixedSamplesCombinationNV() { FreePnextChain(pNext); } + +void safe_VkFramebufferMixedSamplesCombinationNV::initialize(const VkFramebufferMixedSamplesCombinationNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + coverageReductionMode = in_struct->coverageReductionMode; + rasterizationSamples = in_struct->rasterizationSamples; + depthStencilSamples = in_struct->depthStencilSamples; + colorSamples = in_struct->colorSamples; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkFramebufferMixedSamplesCombinationNV::initialize(const safe_VkFramebufferMixedSamplesCombinationNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + coverageReductionMode = copy_src->coverageReductionMode; + rasterizationSamples = copy_src->rasterizationSamples; + depthStencilSamples = copy_src->depthStencilSamples; + colorSamples = copy_src->colorSamples; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV( + const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + maxGraphicsShaderGroupCount(in_struct->maxGraphicsShaderGroupCount), + maxIndirectSequenceCount(in_struct->maxIndirectSequenceCount), + maxIndirectCommandsTokenCount(in_struct->maxIndirectCommandsTokenCount), + maxIndirectCommandsStreamCount(in_struct->maxIndirectCommandsStreamCount), + maxIndirectCommandsTokenOffset(in_struct->maxIndirectCommandsTokenOffset), + maxIndirectCommandsStreamStride(in_struct->maxIndirectCommandsStreamStride), + minSequencesCountBufferOffsetAlignment(in_struct->minSequencesCountBufferOffsetAlignment), + minSequencesIndexBufferOffsetAlignment(in_struct->minSequencesIndexBufferOffsetAlignment), + minIndirectCommandsBufferOffsetAlignment(in_struct->minIndirectCommandsBufferOffsetAlignment) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV), + pNext(nullptr), + maxGraphicsShaderGroupCount(), + maxIndirectSequenceCount(), + maxIndirectCommandsTokenCount(), + maxIndirectCommandsStreamCount(), + maxIndirectCommandsTokenOffset(), + maxIndirectCommandsStreamStride(), + minSequencesCountBufferOffsetAlignment(), + minSequencesIndexBufferOffsetAlignment(), + minIndirectCommandsBufferOffsetAlignment() {} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& copy_src) { + sType = copy_src.sType; + maxGraphicsShaderGroupCount = copy_src.maxGraphicsShaderGroupCount; + maxIndirectSequenceCount = copy_src.maxIndirectSequenceCount; + maxIndirectCommandsTokenCount = copy_src.maxIndirectCommandsTokenCount; + maxIndirectCommandsStreamCount = copy_src.maxIndirectCommandsStreamCount; + maxIndirectCommandsTokenOffset = copy_src.maxIndirectCommandsTokenOffset; + maxIndirectCommandsStreamStride = copy_src.maxIndirectCommandsStreamStride; + minSequencesCountBufferOffsetAlignment = copy_src.minSequencesCountBufferOffsetAlignment; + minSequencesIndexBufferOffsetAlignment = copy_src.minSequencesIndexBufferOffsetAlignment; + minIndirectCommandsBufferOffsetAlignment = copy_src.minIndirectCommandsBufferOffsetAlignment; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::operator=( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxGraphicsShaderGroupCount = copy_src.maxGraphicsShaderGroupCount; + maxIndirectSequenceCount = copy_src.maxIndirectSequenceCount; + maxIndirectCommandsTokenCount = copy_src.maxIndirectCommandsTokenCount; + maxIndirectCommandsStreamCount = copy_src.maxIndirectCommandsStreamCount; + maxIndirectCommandsTokenOffset = copy_src.maxIndirectCommandsTokenOffset; + maxIndirectCommandsStreamStride = copy_src.maxIndirectCommandsStreamStride; + minSequencesCountBufferOffsetAlignment = copy_src.minSequencesCountBufferOffsetAlignment; + minSequencesIndexBufferOffsetAlignment = copy_src.minSequencesIndexBufferOffsetAlignment; + minIndirectCommandsBufferOffsetAlignment = copy_src.minIndirectCommandsBufferOffsetAlignment; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::~safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::initialize( + const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxGraphicsShaderGroupCount = in_struct->maxGraphicsShaderGroupCount; + maxIndirectSequenceCount = in_struct->maxIndirectSequenceCount; + maxIndirectCommandsTokenCount = in_struct->maxIndirectCommandsTokenCount; + maxIndirectCommandsStreamCount = in_struct->maxIndirectCommandsStreamCount; + maxIndirectCommandsTokenOffset = in_struct->maxIndirectCommandsTokenOffset; + maxIndirectCommandsStreamStride = in_struct->maxIndirectCommandsStreamStride; + minSequencesCountBufferOffsetAlignment = in_struct->minSequencesCountBufferOffsetAlignment; + minSequencesIndexBufferOffsetAlignment = in_struct->minSequencesIndexBufferOffsetAlignment; + minIndirectCommandsBufferOffsetAlignment = in_struct->minIndirectCommandsBufferOffsetAlignment; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::initialize( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxGraphicsShaderGroupCount = copy_src->maxGraphicsShaderGroupCount; + maxIndirectSequenceCount = copy_src->maxIndirectSequenceCount; + maxIndirectCommandsTokenCount = copy_src->maxIndirectCommandsTokenCount; + maxIndirectCommandsStreamCount = copy_src->maxIndirectCommandsStreamCount; + maxIndirectCommandsTokenOffset = copy_src->maxIndirectCommandsTokenOffset; + maxIndirectCommandsStreamStride = copy_src->maxIndirectCommandsStreamStride; + minSequencesCountBufferOffsetAlignment = copy_src->minSequencesCountBufferOffsetAlignment; + minSequencesIndexBufferOffsetAlignment = copy_src->minSequencesIndexBufferOffsetAlignment; + minIndirectCommandsBufferOffsetAlignment = copy_src->minIndirectCommandsBufferOffsetAlignment; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV( + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), deviceGeneratedCommands(in_struct->deviceGeneratedCommands) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV), pNext(nullptr), deviceGeneratedCommands() {} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& copy_src) { + sType = copy_src.sType; + deviceGeneratedCommands = copy_src.deviceGeneratedCommands; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::operator=( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + deviceGeneratedCommands = copy_src.deviceGeneratedCommands; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::~safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::initialize( + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + deviceGeneratedCommands = in_struct->deviceGeneratedCommands; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::initialize( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + deviceGeneratedCommands = copy_src->deviceGeneratedCommands; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkGraphicsShaderGroupCreateInfoNV::safe_VkGraphicsShaderGroupCreateInfoNV(const VkGraphicsShaderGroupCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + stageCount(in_struct->stageCount), + pStages(nullptr), + pVertexInputState(nullptr), + pTessellationState(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (stageCount && in_struct->pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(&in_struct->pStages[i]); + } + } + if (in_struct->pVertexInputState) + pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(in_struct->pVertexInputState); + if (in_struct->pTessellationState) + pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState); +} + +safe_VkGraphicsShaderGroupCreateInfoNV::safe_VkGraphicsShaderGroupCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV), + pNext(nullptr), + stageCount(), + pStages(nullptr), + pVertexInputState(nullptr), + pTessellationState(nullptr) {} + +safe_VkGraphicsShaderGroupCreateInfoNV::safe_VkGraphicsShaderGroupCreateInfoNV( + const safe_VkGraphicsShaderGroupCreateInfoNV& copy_src) { + sType = copy_src.sType; + stageCount = copy_src.stageCount; + pStages = nullptr; + pVertexInputState = nullptr; + pTessellationState = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (stageCount && copy_src.pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(©_src.pStages[i]); + } + } + if (copy_src.pVertexInputState) pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*copy_src.pVertexInputState); + if (copy_src.pTessellationState) + pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*copy_src.pTessellationState); +} + +safe_VkGraphicsShaderGroupCreateInfoNV& safe_VkGraphicsShaderGroupCreateInfoNV::operator=( + const safe_VkGraphicsShaderGroupCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pStages) delete[] pStages; + if (pVertexInputState) delete pVertexInputState; + if (pTessellationState) delete pTessellationState; + FreePnextChain(pNext); + + sType = copy_src.sType; + stageCount = copy_src.stageCount; + pStages = nullptr; + pVertexInputState = nullptr; + pTessellationState = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (stageCount && copy_src.pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(©_src.pStages[i]); + } + } + if (copy_src.pVertexInputState) pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*copy_src.pVertexInputState); + if (copy_src.pTessellationState) + pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*copy_src.pTessellationState); + + return *this; +} + +safe_VkGraphicsShaderGroupCreateInfoNV::~safe_VkGraphicsShaderGroupCreateInfoNV() { + if (pStages) delete[] pStages; + if (pVertexInputState) delete pVertexInputState; + if (pTessellationState) delete pTessellationState; + FreePnextChain(pNext); +} + +void safe_VkGraphicsShaderGroupCreateInfoNV::initialize(const VkGraphicsShaderGroupCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStages) delete[] pStages; + if (pVertexInputState) delete pVertexInputState; + if (pTessellationState) delete pTessellationState; + FreePnextChain(pNext); + sType = in_struct->sType; + stageCount = in_struct->stageCount; + pStages = nullptr; + pVertexInputState = nullptr; + pTessellationState = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (stageCount && in_struct->pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(&in_struct->pStages[i]); + } + } + if (in_struct->pVertexInputState) + pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(in_struct->pVertexInputState); + if (in_struct->pTessellationState) + pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState); +} + +void safe_VkGraphicsShaderGroupCreateInfoNV::initialize(const safe_VkGraphicsShaderGroupCreateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stageCount = copy_src->stageCount; + pStages = nullptr; + pVertexInputState = nullptr; + pTessellationState = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (stageCount && copy_src->pStages) { + pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount]; + for (uint32_t i = 0; i < stageCount; ++i) { + pStages[i].initialize(©_src->pStages[i]); + } + } + if (copy_src->pVertexInputState) + pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*copy_src->pVertexInputState); + if (copy_src->pTessellationState) + pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*copy_src->pTessellationState); +} + +safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::safe_VkGraphicsPipelineShaderGroupsCreateInfoNV( + const VkGraphicsPipelineShaderGroupsCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + groupCount(in_struct->groupCount), + pGroups(nullptr), + pipelineCount(in_struct->pipelineCount), + pPipelines(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (groupCount && in_struct->pGroups) { + pGroups = new safe_VkGraphicsShaderGroupCreateInfoNV[groupCount]; + for (uint32_t i = 0; i < groupCount; ++i) { + pGroups[i].initialize(&in_struct->pGroups[i]); + } + } + if (pipelineCount && in_struct->pPipelines) { + pPipelines = new VkPipeline[pipelineCount]; + for (uint32_t i = 0; i < pipelineCount; ++i) { + pPipelines[i] = in_struct->pPipelines[i]; + } + } +} + +safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::safe_VkGraphicsPipelineShaderGroupsCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV), + pNext(nullptr), + groupCount(), + pGroups(nullptr), + pipelineCount(), + pPipelines(nullptr) {} + +safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::safe_VkGraphicsPipelineShaderGroupsCreateInfoNV( + const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV& copy_src) { + sType = copy_src.sType; + groupCount = copy_src.groupCount; + pGroups = nullptr; + pipelineCount = copy_src.pipelineCount; + pPipelines = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (groupCount && copy_src.pGroups) { + pGroups = new safe_VkGraphicsShaderGroupCreateInfoNV[groupCount]; + for (uint32_t i = 0; i < groupCount; ++i) { + pGroups[i].initialize(©_src.pGroups[i]); + } + } + if (pipelineCount && copy_src.pPipelines) { + pPipelines = new VkPipeline[pipelineCount]; + for (uint32_t i = 0; i < pipelineCount; ++i) { + pPipelines[i] = copy_src.pPipelines[i]; + } + } +} + +safe_VkGraphicsPipelineShaderGroupsCreateInfoNV& safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::operator=( + const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pGroups) delete[] pGroups; + if (pPipelines) delete[] pPipelines; + FreePnextChain(pNext); + + sType = copy_src.sType; + groupCount = copy_src.groupCount; + pGroups = nullptr; + pipelineCount = copy_src.pipelineCount; + pPipelines = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (groupCount && copy_src.pGroups) { + pGroups = new safe_VkGraphicsShaderGroupCreateInfoNV[groupCount]; + for (uint32_t i = 0; i < groupCount; ++i) { + pGroups[i].initialize(©_src.pGroups[i]); + } + } + if (pipelineCount && copy_src.pPipelines) { + pPipelines = new VkPipeline[pipelineCount]; + for (uint32_t i = 0; i < pipelineCount; ++i) { + pPipelines[i] = copy_src.pPipelines[i]; + } + } + + return *this; +} + +safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::~safe_VkGraphicsPipelineShaderGroupsCreateInfoNV() { + if (pGroups) delete[] pGroups; + if (pPipelines) delete[] pPipelines; + FreePnextChain(pNext); +} + +void safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::initialize(const VkGraphicsPipelineShaderGroupsCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pGroups) delete[] pGroups; + if (pPipelines) delete[] pPipelines; + FreePnextChain(pNext); + sType = in_struct->sType; + groupCount = in_struct->groupCount; + pGroups = nullptr; + pipelineCount = in_struct->pipelineCount; + pPipelines = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (groupCount && in_struct->pGroups) { + pGroups = new safe_VkGraphicsShaderGroupCreateInfoNV[groupCount]; + for (uint32_t i = 0; i < groupCount; ++i) { + pGroups[i].initialize(&in_struct->pGroups[i]); + } + } + if (pipelineCount && in_struct->pPipelines) { + pPipelines = new VkPipeline[pipelineCount]; + for (uint32_t i = 0; i < pipelineCount; ++i) { + pPipelines[i] = in_struct->pPipelines[i]; + } + } +} + +void safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::initialize(const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + groupCount = copy_src->groupCount; + pGroups = nullptr; + pipelineCount = copy_src->pipelineCount; + pPipelines = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (groupCount && copy_src->pGroups) { + pGroups = new safe_VkGraphicsShaderGroupCreateInfoNV[groupCount]; + for (uint32_t i = 0; i < groupCount; ++i) { + pGroups[i].initialize(©_src->pGroups[i]); + } + } + if (pipelineCount && copy_src->pPipelines) { + pPipelines = new VkPipeline[pipelineCount]; + for (uint32_t i = 0; i < pipelineCount; ++i) { + pPipelines[i] = copy_src->pPipelines[i]; + } + } +} + +safe_VkIndirectCommandsLayoutTokenNV::safe_VkIndirectCommandsLayoutTokenNV(const VkIndirectCommandsLayoutTokenNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + tokenType(in_struct->tokenType), + stream(in_struct->stream), + offset(in_struct->offset), + vertexBindingUnit(in_struct->vertexBindingUnit), + vertexDynamicStride(in_struct->vertexDynamicStride), + pushconstantPipelineLayout(in_struct->pushconstantPipelineLayout), + pushconstantShaderStageFlags(in_struct->pushconstantShaderStageFlags), + pushconstantOffset(in_struct->pushconstantOffset), + pushconstantSize(in_struct->pushconstantSize), + indirectStateFlags(in_struct->indirectStateFlags), + indexTypeCount(in_struct->indexTypeCount), + pIndexTypes(nullptr), + pIndexTypeValues(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pIndexTypes) { + pIndexTypes = new VkIndexType[in_struct->indexTypeCount]; + memcpy((void*)pIndexTypes, (void*)in_struct->pIndexTypes, sizeof(VkIndexType) * in_struct->indexTypeCount); + } + + if (in_struct->pIndexTypeValues) { + pIndexTypeValues = new uint32_t[in_struct->indexTypeCount]; + memcpy((void*)pIndexTypeValues, (void*)in_struct->pIndexTypeValues, sizeof(uint32_t) * in_struct->indexTypeCount); + } +} + +safe_VkIndirectCommandsLayoutTokenNV::safe_VkIndirectCommandsLayoutTokenNV() + : sType(VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV), + pNext(nullptr), + tokenType(), + stream(), + offset(), + vertexBindingUnit(), + vertexDynamicStride(), + pushconstantPipelineLayout(), + pushconstantShaderStageFlags(), + pushconstantOffset(), + pushconstantSize(), + indirectStateFlags(), + indexTypeCount(), + pIndexTypes(nullptr), + pIndexTypeValues(nullptr) {} + +safe_VkIndirectCommandsLayoutTokenNV::safe_VkIndirectCommandsLayoutTokenNV(const safe_VkIndirectCommandsLayoutTokenNV& copy_src) { + sType = copy_src.sType; + tokenType = copy_src.tokenType; + stream = copy_src.stream; + offset = copy_src.offset; + vertexBindingUnit = copy_src.vertexBindingUnit; + vertexDynamicStride = copy_src.vertexDynamicStride; + pushconstantPipelineLayout = copy_src.pushconstantPipelineLayout; + pushconstantShaderStageFlags = copy_src.pushconstantShaderStageFlags; + pushconstantOffset = copy_src.pushconstantOffset; + pushconstantSize = copy_src.pushconstantSize; + indirectStateFlags = copy_src.indirectStateFlags; + indexTypeCount = copy_src.indexTypeCount; + pIndexTypes = nullptr; + pIndexTypeValues = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pIndexTypes) { + pIndexTypes = new VkIndexType[copy_src.indexTypeCount]; + memcpy((void*)pIndexTypes, (void*)copy_src.pIndexTypes, sizeof(VkIndexType) * copy_src.indexTypeCount); + } + + if (copy_src.pIndexTypeValues) { + pIndexTypeValues = new uint32_t[copy_src.indexTypeCount]; + memcpy((void*)pIndexTypeValues, (void*)copy_src.pIndexTypeValues, sizeof(uint32_t) * copy_src.indexTypeCount); + } +} + +safe_VkIndirectCommandsLayoutTokenNV& safe_VkIndirectCommandsLayoutTokenNV::operator=( + const safe_VkIndirectCommandsLayoutTokenNV& copy_src) { + if (©_src == this) return *this; + + if (pIndexTypes) delete[] pIndexTypes; + if (pIndexTypeValues) delete[] pIndexTypeValues; + FreePnextChain(pNext); + + sType = copy_src.sType; + tokenType = copy_src.tokenType; + stream = copy_src.stream; + offset = copy_src.offset; + vertexBindingUnit = copy_src.vertexBindingUnit; + vertexDynamicStride = copy_src.vertexDynamicStride; + pushconstantPipelineLayout = copy_src.pushconstantPipelineLayout; + pushconstantShaderStageFlags = copy_src.pushconstantShaderStageFlags; + pushconstantOffset = copy_src.pushconstantOffset; + pushconstantSize = copy_src.pushconstantSize; + indirectStateFlags = copy_src.indirectStateFlags; + indexTypeCount = copy_src.indexTypeCount; + pIndexTypes = nullptr; + pIndexTypeValues = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pIndexTypes) { + pIndexTypes = new VkIndexType[copy_src.indexTypeCount]; + memcpy((void*)pIndexTypes, (void*)copy_src.pIndexTypes, sizeof(VkIndexType) * copy_src.indexTypeCount); + } + + if (copy_src.pIndexTypeValues) { + pIndexTypeValues = new uint32_t[copy_src.indexTypeCount]; + memcpy((void*)pIndexTypeValues, (void*)copy_src.pIndexTypeValues, sizeof(uint32_t) * copy_src.indexTypeCount); + } + + return *this; +} + +safe_VkIndirectCommandsLayoutTokenNV::~safe_VkIndirectCommandsLayoutTokenNV() { + if (pIndexTypes) delete[] pIndexTypes; + if (pIndexTypeValues) delete[] pIndexTypeValues; + FreePnextChain(pNext); +} + +void safe_VkIndirectCommandsLayoutTokenNV::initialize(const VkIndirectCommandsLayoutTokenNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pIndexTypes) delete[] pIndexTypes; + if (pIndexTypeValues) delete[] pIndexTypeValues; + FreePnextChain(pNext); + sType = in_struct->sType; + tokenType = in_struct->tokenType; + stream = in_struct->stream; + offset = in_struct->offset; + vertexBindingUnit = in_struct->vertexBindingUnit; + vertexDynamicStride = in_struct->vertexDynamicStride; + pushconstantPipelineLayout = in_struct->pushconstantPipelineLayout; + pushconstantShaderStageFlags = in_struct->pushconstantShaderStageFlags; + pushconstantOffset = in_struct->pushconstantOffset; + pushconstantSize = in_struct->pushconstantSize; + indirectStateFlags = in_struct->indirectStateFlags; + indexTypeCount = in_struct->indexTypeCount; + pIndexTypes = nullptr; + pIndexTypeValues = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pIndexTypes) { + pIndexTypes = new VkIndexType[in_struct->indexTypeCount]; + memcpy((void*)pIndexTypes, (void*)in_struct->pIndexTypes, sizeof(VkIndexType) * in_struct->indexTypeCount); + } + + if (in_struct->pIndexTypeValues) { + pIndexTypeValues = new uint32_t[in_struct->indexTypeCount]; + memcpy((void*)pIndexTypeValues, (void*)in_struct->pIndexTypeValues, sizeof(uint32_t) * in_struct->indexTypeCount); + } +} + +void safe_VkIndirectCommandsLayoutTokenNV::initialize(const safe_VkIndirectCommandsLayoutTokenNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + tokenType = copy_src->tokenType; + stream = copy_src->stream; + offset = copy_src->offset; + vertexBindingUnit = copy_src->vertexBindingUnit; + vertexDynamicStride = copy_src->vertexDynamicStride; + pushconstantPipelineLayout = copy_src->pushconstantPipelineLayout; + pushconstantShaderStageFlags = copy_src->pushconstantShaderStageFlags; + pushconstantOffset = copy_src->pushconstantOffset; + pushconstantSize = copy_src->pushconstantSize; + indirectStateFlags = copy_src->indirectStateFlags; + indexTypeCount = copy_src->indexTypeCount; + pIndexTypes = nullptr; + pIndexTypeValues = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pIndexTypes) { + pIndexTypes = new VkIndexType[copy_src->indexTypeCount]; + memcpy((void*)pIndexTypes, (void*)copy_src->pIndexTypes, sizeof(VkIndexType) * copy_src->indexTypeCount); + } + + if (copy_src->pIndexTypeValues) { + pIndexTypeValues = new uint32_t[copy_src->indexTypeCount]; + memcpy((void*)pIndexTypeValues, (void*)copy_src->pIndexTypeValues, sizeof(uint32_t) * copy_src->indexTypeCount); + } +} + +safe_VkIndirectCommandsLayoutCreateInfoNV::safe_VkIndirectCommandsLayoutCreateInfoNV( + const VkIndirectCommandsLayoutCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + flags(in_struct->flags), + pipelineBindPoint(in_struct->pipelineBindPoint), + tokenCount(in_struct->tokenCount), + pTokens(nullptr), + streamCount(in_struct->streamCount), + pStreamStrides(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (tokenCount && in_struct->pTokens) { + pTokens = new safe_VkIndirectCommandsLayoutTokenNV[tokenCount]; + for (uint32_t i = 0; i < tokenCount; ++i) { + pTokens[i].initialize(&in_struct->pTokens[i]); + } + } + + if (in_struct->pStreamStrides) { + pStreamStrides = new uint32_t[in_struct->streamCount]; + memcpy((void*)pStreamStrides, (void*)in_struct->pStreamStrides, sizeof(uint32_t) * in_struct->streamCount); + } +} + +safe_VkIndirectCommandsLayoutCreateInfoNV::safe_VkIndirectCommandsLayoutCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV), + pNext(nullptr), + flags(), + pipelineBindPoint(), + tokenCount(), + pTokens(nullptr), + streamCount(), + pStreamStrides(nullptr) {} + +safe_VkIndirectCommandsLayoutCreateInfoNV::safe_VkIndirectCommandsLayoutCreateInfoNV( + const safe_VkIndirectCommandsLayoutCreateInfoNV& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pipelineBindPoint = copy_src.pipelineBindPoint; + tokenCount = copy_src.tokenCount; + pTokens = nullptr; + streamCount = copy_src.streamCount; + pStreamStrides = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (tokenCount && copy_src.pTokens) { + pTokens = new safe_VkIndirectCommandsLayoutTokenNV[tokenCount]; + for (uint32_t i = 0; i < tokenCount; ++i) { + pTokens[i].initialize(©_src.pTokens[i]); + } + } + + if (copy_src.pStreamStrides) { + pStreamStrides = new uint32_t[copy_src.streamCount]; + memcpy((void*)pStreamStrides, (void*)copy_src.pStreamStrides, sizeof(uint32_t) * copy_src.streamCount); + } +} + +safe_VkIndirectCommandsLayoutCreateInfoNV& safe_VkIndirectCommandsLayoutCreateInfoNV::operator=( + const safe_VkIndirectCommandsLayoutCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pTokens) delete[] pTokens; + if (pStreamStrides) delete[] pStreamStrides; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pipelineBindPoint = copy_src.pipelineBindPoint; + tokenCount = copy_src.tokenCount; + pTokens = nullptr; + streamCount = copy_src.streamCount; + pStreamStrides = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (tokenCount && copy_src.pTokens) { + pTokens = new safe_VkIndirectCommandsLayoutTokenNV[tokenCount]; + for (uint32_t i = 0; i < tokenCount; ++i) { + pTokens[i].initialize(©_src.pTokens[i]); + } + } + + if (copy_src.pStreamStrides) { + pStreamStrides = new uint32_t[copy_src.streamCount]; + memcpy((void*)pStreamStrides, (void*)copy_src.pStreamStrides, sizeof(uint32_t) * copy_src.streamCount); + } + + return *this; +} + +safe_VkIndirectCommandsLayoutCreateInfoNV::~safe_VkIndirectCommandsLayoutCreateInfoNV() { + if (pTokens) delete[] pTokens; + if (pStreamStrides) delete[] pStreamStrides; + FreePnextChain(pNext); +} + +void safe_VkIndirectCommandsLayoutCreateInfoNV::initialize(const VkIndirectCommandsLayoutCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pTokens) delete[] pTokens; + if (pStreamStrides) delete[] pStreamStrides; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pipelineBindPoint = in_struct->pipelineBindPoint; + tokenCount = in_struct->tokenCount; + pTokens = nullptr; + streamCount = in_struct->streamCount; + pStreamStrides = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (tokenCount && in_struct->pTokens) { + pTokens = new safe_VkIndirectCommandsLayoutTokenNV[tokenCount]; + for (uint32_t i = 0; i < tokenCount; ++i) { + pTokens[i].initialize(&in_struct->pTokens[i]); + } + } + + if (in_struct->pStreamStrides) { + pStreamStrides = new uint32_t[in_struct->streamCount]; + memcpy((void*)pStreamStrides, (void*)in_struct->pStreamStrides, sizeof(uint32_t) * in_struct->streamCount); + } +} + +void safe_VkIndirectCommandsLayoutCreateInfoNV::initialize(const safe_VkIndirectCommandsLayoutCreateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pipelineBindPoint = copy_src->pipelineBindPoint; + tokenCount = copy_src->tokenCount; + pTokens = nullptr; + streamCount = copy_src->streamCount; + pStreamStrides = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (tokenCount && copy_src->pTokens) { + pTokens = new safe_VkIndirectCommandsLayoutTokenNV[tokenCount]; + for (uint32_t i = 0; i < tokenCount; ++i) { + pTokens[i].initialize(©_src->pTokens[i]); + } + } + + if (copy_src->pStreamStrides) { + pStreamStrides = new uint32_t[copy_src->streamCount]; + memcpy((void*)pStreamStrides, (void*)copy_src->pStreamStrides, sizeof(uint32_t) * copy_src->streamCount); + } +} + +safe_VkGeneratedCommandsInfoNV::safe_VkGeneratedCommandsInfoNV(const VkGeneratedCommandsInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + pipelineBindPoint(in_struct->pipelineBindPoint), + pipeline(in_struct->pipeline), + indirectCommandsLayout(in_struct->indirectCommandsLayout), + streamCount(in_struct->streamCount), + pStreams(nullptr), + sequencesCount(in_struct->sequencesCount), + preprocessBuffer(in_struct->preprocessBuffer), + preprocessOffset(in_struct->preprocessOffset), + preprocessSize(in_struct->preprocessSize), + sequencesCountBuffer(in_struct->sequencesCountBuffer), + sequencesCountOffset(in_struct->sequencesCountOffset), + sequencesIndexBuffer(in_struct->sequencesIndexBuffer), + sequencesIndexOffset(in_struct->sequencesIndexOffset) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (streamCount && in_struct->pStreams) { + pStreams = new VkIndirectCommandsStreamNV[streamCount]; + for (uint32_t i = 0; i < streamCount; ++i) { + pStreams[i] = in_struct->pStreams[i]; + } + } +} + +safe_VkGeneratedCommandsInfoNV::safe_VkGeneratedCommandsInfoNV() + : sType(VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV), + pNext(nullptr), + pipelineBindPoint(), + pipeline(), + indirectCommandsLayout(), + streamCount(), + pStreams(nullptr), + sequencesCount(), + preprocessBuffer(), + preprocessOffset(), + preprocessSize(), + sequencesCountBuffer(), + sequencesCountOffset(), + sequencesIndexBuffer(), + sequencesIndexOffset() {} + +safe_VkGeneratedCommandsInfoNV::safe_VkGeneratedCommandsInfoNV(const safe_VkGeneratedCommandsInfoNV& copy_src) { + sType = copy_src.sType; + pipelineBindPoint = copy_src.pipelineBindPoint; + pipeline = copy_src.pipeline; + indirectCommandsLayout = copy_src.indirectCommandsLayout; + streamCount = copy_src.streamCount; + pStreams = nullptr; + sequencesCount = copy_src.sequencesCount; + preprocessBuffer = copy_src.preprocessBuffer; + preprocessOffset = copy_src.preprocessOffset; + preprocessSize = copy_src.preprocessSize; + sequencesCountBuffer = copy_src.sequencesCountBuffer; + sequencesCountOffset = copy_src.sequencesCountOffset; + sequencesIndexBuffer = copy_src.sequencesIndexBuffer; + sequencesIndexOffset = copy_src.sequencesIndexOffset; + pNext = SafePnextCopy(copy_src.pNext); + if (streamCount && copy_src.pStreams) { + pStreams = new VkIndirectCommandsStreamNV[streamCount]; + for (uint32_t i = 0; i < streamCount; ++i) { + pStreams[i] = copy_src.pStreams[i]; + } + } +} + +safe_VkGeneratedCommandsInfoNV& safe_VkGeneratedCommandsInfoNV::operator=(const safe_VkGeneratedCommandsInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pStreams) delete[] pStreams; + FreePnextChain(pNext); + + sType = copy_src.sType; + pipelineBindPoint = copy_src.pipelineBindPoint; + pipeline = copy_src.pipeline; + indirectCommandsLayout = copy_src.indirectCommandsLayout; + streamCount = copy_src.streamCount; + pStreams = nullptr; + sequencesCount = copy_src.sequencesCount; + preprocessBuffer = copy_src.preprocessBuffer; + preprocessOffset = copy_src.preprocessOffset; + preprocessSize = copy_src.preprocessSize; + sequencesCountBuffer = copy_src.sequencesCountBuffer; + sequencesCountOffset = copy_src.sequencesCountOffset; + sequencesIndexBuffer = copy_src.sequencesIndexBuffer; + sequencesIndexOffset = copy_src.sequencesIndexOffset; + pNext = SafePnextCopy(copy_src.pNext); + if (streamCount && copy_src.pStreams) { + pStreams = new VkIndirectCommandsStreamNV[streamCount]; + for (uint32_t i = 0; i < streamCount; ++i) { + pStreams[i] = copy_src.pStreams[i]; + } + } + + return *this; +} + +safe_VkGeneratedCommandsInfoNV::~safe_VkGeneratedCommandsInfoNV() { + if (pStreams) delete[] pStreams; + FreePnextChain(pNext); +} + +void safe_VkGeneratedCommandsInfoNV::initialize(const VkGeneratedCommandsInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStreams) delete[] pStreams; + FreePnextChain(pNext); + sType = in_struct->sType; + pipelineBindPoint = in_struct->pipelineBindPoint; + pipeline = in_struct->pipeline; + indirectCommandsLayout = in_struct->indirectCommandsLayout; + streamCount = in_struct->streamCount; + pStreams = nullptr; + sequencesCount = in_struct->sequencesCount; + preprocessBuffer = in_struct->preprocessBuffer; + preprocessOffset = in_struct->preprocessOffset; + preprocessSize = in_struct->preprocessSize; + sequencesCountBuffer = in_struct->sequencesCountBuffer; + sequencesCountOffset = in_struct->sequencesCountOffset; + sequencesIndexBuffer = in_struct->sequencesIndexBuffer; + sequencesIndexOffset = in_struct->sequencesIndexOffset; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (streamCount && in_struct->pStreams) { + pStreams = new VkIndirectCommandsStreamNV[streamCount]; + for (uint32_t i = 0; i < streamCount; ++i) { + pStreams[i] = in_struct->pStreams[i]; + } + } +} + +void safe_VkGeneratedCommandsInfoNV::initialize(const safe_VkGeneratedCommandsInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipelineBindPoint = copy_src->pipelineBindPoint; + pipeline = copy_src->pipeline; + indirectCommandsLayout = copy_src->indirectCommandsLayout; + streamCount = copy_src->streamCount; + pStreams = nullptr; + sequencesCount = copy_src->sequencesCount; + preprocessBuffer = copy_src->preprocessBuffer; + preprocessOffset = copy_src->preprocessOffset; + preprocessSize = copy_src->preprocessSize; + sequencesCountBuffer = copy_src->sequencesCountBuffer; + sequencesCountOffset = copy_src->sequencesCountOffset; + sequencesIndexBuffer = copy_src->sequencesIndexBuffer; + sequencesIndexOffset = copy_src->sequencesIndexOffset; + pNext = SafePnextCopy(copy_src->pNext); + if (streamCount && copy_src->pStreams) { + pStreams = new VkIndirectCommandsStreamNV[streamCount]; + for (uint32_t i = 0; i < streamCount; ++i) { + pStreams[i] = copy_src->pStreams[i]; + } + } +} + +safe_VkGeneratedCommandsMemoryRequirementsInfoNV::safe_VkGeneratedCommandsMemoryRequirementsInfoNV( + const VkGeneratedCommandsMemoryRequirementsInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + pipelineBindPoint(in_struct->pipelineBindPoint), + pipeline(in_struct->pipeline), + indirectCommandsLayout(in_struct->indirectCommandsLayout), + maxSequencesCount(in_struct->maxSequencesCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkGeneratedCommandsMemoryRequirementsInfoNV::safe_VkGeneratedCommandsMemoryRequirementsInfoNV() + : sType(VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV), + pNext(nullptr), + pipelineBindPoint(), + pipeline(), + indirectCommandsLayout(), + maxSequencesCount() {} + +safe_VkGeneratedCommandsMemoryRequirementsInfoNV::safe_VkGeneratedCommandsMemoryRequirementsInfoNV( + const safe_VkGeneratedCommandsMemoryRequirementsInfoNV& copy_src) { + sType = copy_src.sType; + pipelineBindPoint = copy_src.pipelineBindPoint; + pipeline = copy_src.pipeline; + indirectCommandsLayout = copy_src.indirectCommandsLayout; + maxSequencesCount = copy_src.maxSequencesCount; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkGeneratedCommandsMemoryRequirementsInfoNV& safe_VkGeneratedCommandsMemoryRequirementsInfoNV::operator=( + const safe_VkGeneratedCommandsMemoryRequirementsInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pipelineBindPoint = copy_src.pipelineBindPoint; + pipeline = copy_src.pipeline; + indirectCommandsLayout = copy_src.indirectCommandsLayout; + maxSequencesCount = copy_src.maxSequencesCount; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkGeneratedCommandsMemoryRequirementsInfoNV::~safe_VkGeneratedCommandsMemoryRequirementsInfoNV() { FreePnextChain(pNext); } + +void safe_VkGeneratedCommandsMemoryRequirementsInfoNV::initialize(const VkGeneratedCommandsMemoryRequirementsInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pipelineBindPoint = in_struct->pipelineBindPoint; + pipeline = in_struct->pipeline; + indirectCommandsLayout = in_struct->indirectCommandsLayout; + maxSequencesCount = in_struct->maxSequencesCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkGeneratedCommandsMemoryRequirementsInfoNV::initialize(const safe_VkGeneratedCommandsMemoryRequirementsInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipelineBindPoint = copy_src->pipelineBindPoint; + pipeline = copy_src->pipeline; + indirectCommandsLayout = copy_src->indirectCommandsLayout; + maxSequencesCount = copy_src->maxSequencesCount; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV( + const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), inheritedViewportScissor2D(in_struct->inheritedViewportScissor2D) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV), + pNext(nullptr), + inheritedViewportScissor2D() {} + +safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV( + const safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV& copy_src) { + sType = copy_src.sType; + inheritedViewportScissor2D = copy_src.inheritedViewportScissor2D; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV& safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::operator=( + const safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + inheritedViewportScissor2D = copy_src.inheritedViewportScissor2D; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::~safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::initialize( + const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + inheritedViewportScissor2D = in_struct->inheritedViewportScissor2D; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::initialize( + const safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + inheritedViewportScissor2D = copy_src->inheritedViewportScissor2D; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCommandBufferInheritanceViewportScissorInfoNV::safe_VkCommandBufferInheritanceViewportScissorInfoNV( + const VkCommandBufferInheritanceViewportScissorInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + viewportScissor2D(in_struct->viewportScissor2D), + viewportDepthCount(in_struct->viewportDepthCount), + pViewportDepths(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pViewportDepths) { + pViewportDepths = new VkViewport(*in_struct->pViewportDepths); + } +} + +safe_VkCommandBufferInheritanceViewportScissorInfoNV::safe_VkCommandBufferInheritanceViewportScissorInfoNV() + : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV), + pNext(nullptr), + viewportScissor2D(), + viewportDepthCount(), + pViewportDepths(nullptr) {} + +safe_VkCommandBufferInheritanceViewportScissorInfoNV::safe_VkCommandBufferInheritanceViewportScissorInfoNV( + const safe_VkCommandBufferInheritanceViewportScissorInfoNV& copy_src) { + sType = copy_src.sType; + viewportScissor2D = copy_src.viewportScissor2D; + viewportDepthCount = copy_src.viewportDepthCount; + pViewportDepths = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pViewportDepths) { + pViewportDepths = new VkViewport(*copy_src.pViewportDepths); + } +} + +safe_VkCommandBufferInheritanceViewportScissorInfoNV& safe_VkCommandBufferInheritanceViewportScissorInfoNV::operator=( + const safe_VkCommandBufferInheritanceViewportScissorInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pViewportDepths) delete pViewportDepths; + FreePnextChain(pNext); + + sType = copy_src.sType; + viewportScissor2D = copy_src.viewportScissor2D; + viewportDepthCount = copy_src.viewportDepthCount; + pViewportDepths = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pViewportDepths) { + pViewportDepths = new VkViewport(*copy_src.pViewportDepths); + } + + return *this; +} + +safe_VkCommandBufferInheritanceViewportScissorInfoNV::~safe_VkCommandBufferInheritanceViewportScissorInfoNV() { + if (pViewportDepths) delete pViewportDepths; + FreePnextChain(pNext); +} + +void safe_VkCommandBufferInheritanceViewportScissorInfoNV::initialize( + const VkCommandBufferInheritanceViewportScissorInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pViewportDepths) delete pViewportDepths; + FreePnextChain(pNext); + sType = in_struct->sType; + viewportScissor2D = in_struct->viewportScissor2D; + viewportDepthCount = in_struct->viewportDepthCount; + pViewportDepths = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pViewportDepths) { + pViewportDepths = new VkViewport(*in_struct->pViewportDepths); + } +} + +void safe_VkCommandBufferInheritanceViewportScissorInfoNV::initialize( + const safe_VkCommandBufferInheritanceViewportScissorInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + viewportScissor2D = copy_src->viewportScissor2D; + viewportDepthCount = copy_src->viewportDepthCount; + pViewportDepths = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pViewportDepths) { + pViewportDepths = new VkViewport(*copy_src->pViewportDepths); + } +} + +safe_VkRenderPassTransformBeginInfoQCOM::safe_VkRenderPassTransformBeginInfoQCOM( + const VkRenderPassTransformBeginInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), transform(in_struct->transform) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkRenderPassTransformBeginInfoQCOM::safe_VkRenderPassTransformBeginInfoQCOM() + : sType(VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM), pNext(nullptr), transform() {} + +safe_VkRenderPassTransformBeginInfoQCOM::safe_VkRenderPassTransformBeginInfoQCOM( + const safe_VkRenderPassTransformBeginInfoQCOM& copy_src) { + sType = copy_src.sType; + transform = copy_src.transform; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkRenderPassTransformBeginInfoQCOM& safe_VkRenderPassTransformBeginInfoQCOM::operator=( + const safe_VkRenderPassTransformBeginInfoQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + transform = copy_src.transform; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkRenderPassTransformBeginInfoQCOM::~safe_VkRenderPassTransformBeginInfoQCOM() { FreePnextChain(pNext); } + +void safe_VkRenderPassTransformBeginInfoQCOM::initialize(const VkRenderPassTransformBeginInfoQCOM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + transform = in_struct->transform; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkRenderPassTransformBeginInfoQCOM::initialize(const safe_VkRenderPassTransformBeginInfoQCOM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + transform = copy_src->transform; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM( + const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), transform(in_struct->transform), renderArea(in_struct->renderArea) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM() + : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM), + pNext(nullptr), + transform(), + renderArea() {} + +safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM( + const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM& copy_src) { + sType = copy_src.sType; + transform = copy_src.transform; + renderArea = copy_src.renderArea; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM& safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::operator=( + const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + transform = copy_src.transform; + renderArea = copy_src.renderArea; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::~safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM() { + FreePnextChain(pNext); +} + +void safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::initialize( + const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + transform = in_struct->transform; + renderArea = in_struct->renderArea; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::initialize( + const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + transform = copy_src->transform; + renderArea = copy_src->renderArea; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDevicePresentBarrierFeaturesNV::safe_VkPhysicalDevicePresentBarrierFeaturesNV( + const VkPhysicalDevicePresentBarrierFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), presentBarrier(in_struct->presentBarrier) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDevicePresentBarrierFeaturesNV::safe_VkPhysicalDevicePresentBarrierFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV), pNext(nullptr), presentBarrier() {} + +safe_VkPhysicalDevicePresentBarrierFeaturesNV::safe_VkPhysicalDevicePresentBarrierFeaturesNV( + const safe_VkPhysicalDevicePresentBarrierFeaturesNV& copy_src) { + sType = copy_src.sType; + presentBarrier = copy_src.presentBarrier; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDevicePresentBarrierFeaturesNV& safe_VkPhysicalDevicePresentBarrierFeaturesNV::operator=( + const safe_VkPhysicalDevicePresentBarrierFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + presentBarrier = copy_src.presentBarrier; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDevicePresentBarrierFeaturesNV::~safe_VkPhysicalDevicePresentBarrierFeaturesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDevicePresentBarrierFeaturesNV::initialize(const VkPhysicalDevicePresentBarrierFeaturesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + presentBarrier = in_struct->presentBarrier; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDevicePresentBarrierFeaturesNV::initialize(const safe_VkPhysicalDevicePresentBarrierFeaturesNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentBarrier = copy_src->presentBarrier; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSurfaceCapabilitiesPresentBarrierNV::safe_VkSurfaceCapabilitiesPresentBarrierNV( + const VkSurfaceCapabilitiesPresentBarrierNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), presentBarrierSupported(in_struct->presentBarrierSupported) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSurfaceCapabilitiesPresentBarrierNV::safe_VkSurfaceCapabilitiesPresentBarrierNV() + : sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV), pNext(nullptr), presentBarrierSupported() {} + +safe_VkSurfaceCapabilitiesPresentBarrierNV::safe_VkSurfaceCapabilitiesPresentBarrierNV( + const safe_VkSurfaceCapabilitiesPresentBarrierNV& copy_src) { + sType = copy_src.sType; + presentBarrierSupported = copy_src.presentBarrierSupported; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSurfaceCapabilitiesPresentBarrierNV& safe_VkSurfaceCapabilitiesPresentBarrierNV::operator=( + const safe_VkSurfaceCapabilitiesPresentBarrierNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + presentBarrierSupported = copy_src.presentBarrierSupported; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSurfaceCapabilitiesPresentBarrierNV::~safe_VkSurfaceCapabilitiesPresentBarrierNV() { FreePnextChain(pNext); } + +void safe_VkSurfaceCapabilitiesPresentBarrierNV::initialize(const VkSurfaceCapabilitiesPresentBarrierNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + presentBarrierSupported = in_struct->presentBarrierSupported; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSurfaceCapabilitiesPresentBarrierNV::initialize(const safe_VkSurfaceCapabilitiesPresentBarrierNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentBarrierSupported = copy_src->presentBarrierSupported; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSwapchainPresentBarrierCreateInfoNV::safe_VkSwapchainPresentBarrierCreateInfoNV( + const VkSwapchainPresentBarrierCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), presentBarrierEnable(in_struct->presentBarrierEnable) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSwapchainPresentBarrierCreateInfoNV::safe_VkSwapchainPresentBarrierCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV), pNext(nullptr), presentBarrierEnable() {} + +safe_VkSwapchainPresentBarrierCreateInfoNV::safe_VkSwapchainPresentBarrierCreateInfoNV( + const safe_VkSwapchainPresentBarrierCreateInfoNV& copy_src) { + sType = copy_src.sType; + presentBarrierEnable = copy_src.presentBarrierEnable; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSwapchainPresentBarrierCreateInfoNV& safe_VkSwapchainPresentBarrierCreateInfoNV::operator=( + const safe_VkSwapchainPresentBarrierCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + presentBarrierEnable = copy_src.presentBarrierEnable; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSwapchainPresentBarrierCreateInfoNV::~safe_VkSwapchainPresentBarrierCreateInfoNV() { FreePnextChain(pNext); } + +void safe_VkSwapchainPresentBarrierCreateInfoNV::initialize(const VkSwapchainPresentBarrierCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + presentBarrierEnable = in_struct->presentBarrierEnable; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSwapchainPresentBarrierCreateInfoNV::initialize(const safe_VkSwapchainPresentBarrierCreateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentBarrierEnable = copy_src->presentBarrierEnable; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV( + const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), diagnosticsConfig(in_struct->diagnosticsConfig) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV), pNext(nullptr), diagnosticsConfig() {} + +safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV( + const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV& copy_src) { + sType = copy_src.sType; + diagnosticsConfig = copy_src.diagnosticsConfig; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV& safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::operator=( + const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + diagnosticsConfig = copy_src.diagnosticsConfig; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::~safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::initialize(const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + diagnosticsConfig = in_struct->diagnosticsConfig; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::initialize(const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + diagnosticsConfig = copy_src->diagnosticsConfig; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDeviceDiagnosticsConfigCreateInfoNV::safe_VkDeviceDiagnosticsConfigCreateInfoNV( + const VkDeviceDiagnosticsConfigCreateInfoNV* 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_VkDeviceDiagnosticsConfigCreateInfoNV::safe_VkDeviceDiagnosticsConfigCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV), pNext(nullptr), flags() {} + +safe_VkDeviceDiagnosticsConfigCreateInfoNV::safe_VkDeviceDiagnosticsConfigCreateInfoNV( + const safe_VkDeviceDiagnosticsConfigCreateInfoNV& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDeviceDiagnosticsConfigCreateInfoNV& safe_VkDeviceDiagnosticsConfigCreateInfoNV::operator=( + const safe_VkDeviceDiagnosticsConfigCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDeviceDiagnosticsConfigCreateInfoNV::~safe_VkDeviceDiagnosticsConfigCreateInfoNV() { FreePnextChain(pNext); } + +void safe_VkDeviceDiagnosticsConfigCreateInfoNV::initialize(const VkDeviceDiagnosticsConfigCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDeviceDiagnosticsConfigCreateInfoNV::initialize(const safe_VkDeviceDiagnosticsConfigCreateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCudaModuleCreateInfoNV::safe_VkCudaModuleCreateInfoNV(const VkCudaModuleCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), dataSize(in_struct->dataSize), pData(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + 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_VkCudaModuleCreateInfoNV::safe_VkCudaModuleCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV), pNext(nullptr), dataSize(), pData(nullptr) {} + +safe_VkCudaModuleCreateInfoNV::safe_VkCudaModuleCreateInfoNV(const safe_VkCudaModuleCreateInfoNV& copy_src) { + sType = copy_src.sType; + dataSize = copy_src.dataSize; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pData != nullptr) { + auto temp = new std::byte[copy_src.dataSize]; + std::memcpy(temp, copy_src.pData, copy_src.dataSize); + pData = temp; + } +} + +safe_VkCudaModuleCreateInfoNV& safe_VkCudaModuleCreateInfoNV::operator=(const safe_VkCudaModuleCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + FreePnextChain(pNext); + + sType = copy_src.sType; + dataSize = copy_src.dataSize; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pData != nullptr) { + auto temp = new std::byte[copy_src.dataSize]; + std::memcpy(temp, copy_src.pData, copy_src.dataSize); + pData = temp; + } + + return *this; +} + +safe_VkCudaModuleCreateInfoNV::~safe_VkCudaModuleCreateInfoNV() { + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + FreePnextChain(pNext); +} + +void safe_VkCudaModuleCreateInfoNV::initialize(const VkCudaModuleCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pData != nullptr) { + auto temp = reinterpret_cast(pData); + delete[] temp; + } + FreePnextChain(pNext); + sType = in_struct->sType; + dataSize = in_struct->dataSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + 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_VkCudaModuleCreateInfoNV::initialize(const safe_VkCudaModuleCreateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + dataSize = copy_src->dataSize; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pData != nullptr) { + auto temp = new std::byte[copy_src->dataSize]; + std::memcpy(temp, copy_src->pData, copy_src->dataSize); + pData = temp; + } +} + +safe_VkCudaFunctionCreateInfoNV::safe_VkCudaFunctionCreateInfoNV(const VkCudaFunctionCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), module(in_struct->module) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + pName = SafeStringCopy(in_struct->pName); +} + +safe_VkCudaFunctionCreateInfoNV::safe_VkCudaFunctionCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV), pNext(nullptr), module(), pName(nullptr) {} + +safe_VkCudaFunctionCreateInfoNV::safe_VkCudaFunctionCreateInfoNV(const safe_VkCudaFunctionCreateInfoNV& copy_src) { + sType = copy_src.sType; + module = copy_src.module; + pNext = SafePnextCopy(copy_src.pNext); + pName = SafeStringCopy(copy_src.pName); +} + +safe_VkCudaFunctionCreateInfoNV& safe_VkCudaFunctionCreateInfoNV::operator=(const safe_VkCudaFunctionCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pName) delete[] pName; + FreePnextChain(pNext); + + sType = copy_src.sType; + module = copy_src.module; + pNext = SafePnextCopy(copy_src.pNext); + pName = SafeStringCopy(copy_src.pName); + + return *this; +} + +safe_VkCudaFunctionCreateInfoNV::~safe_VkCudaFunctionCreateInfoNV() { + if (pName) delete[] pName; + FreePnextChain(pNext); +} + +void safe_VkCudaFunctionCreateInfoNV::initialize(const VkCudaFunctionCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pName) delete[] pName; + FreePnextChain(pNext); + sType = in_struct->sType; + module = in_struct->module; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + pName = SafeStringCopy(in_struct->pName); +} + +void safe_VkCudaFunctionCreateInfoNV::initialize(const safe_VkCudaFunctionCreateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + module = copy_src->module; + pNext = SafePnextCopy(copy_src->pNext); + pName = SafeStringCopy(copy_src->pName); +} + +safe_VkCudaLaunchInfoNV::safe_VkCudaLaunchInfoNV(const VkCudaLaunchInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + function(in_struct->function), + gridDimX(in_struct->gridDimX), + gridDimY(in_struct->gridDimY), + gridDimZ(in_struct->gridDimZ), + blockDimX(in_struct->blockDimX), + blockDimY(in_struct->blockDimY), + blockDimZ(in_struct->blockDimZ), + sharedMemBytes(in_struct->sharedMemBytes), + paramCount(in_struct->paramCount), + pParams(in_struct->pParams), + extraCount(in_struct->extraCount), + pExtras(in_struct->pExtras) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCudaLaunchInfoNV::safe_VkCudaLaunchInfoNV() + : sType(VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV), + pNext(nullptr), + function(), + gridDimX(), + gridDimY(), + gridDimZ(), + blockDimX(), + blockDimY(), + blockDimZ(), + sharedMemBytes(), + paramCount(), + pParams(nullptr), + extraCount(), + pExtras(nullptr) {} + +safe_VkCudaLaunchInfoNV::safe_VkCudaLaunchInfoNV(const safe_VkCudaLaunchInfoNV& copy_src) { + sType = copy_src.sType; + function = copy_src.function; + gridDimX = copy_src.gridDimX; + gridDimY = copy_src.gridDimY; + gridDimZ = copy_src.gridDimZ; + blockDimX = copy_src.blockDimX; + blockDimY = copy_src.blockDimY; + blockDimZ = copy_src.blockDimZ; + sharedMemBytes = copy_src.sharedMemBytes; + paramCount = copy_src.paramCount; + pParams = copy_src.pParams; + extraCount = copy_src.extraCount; + pExtras = copy_src.pExtras; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCudaLaunchInfoNV& safe_VkCudaLaunchInfoNV::operator=(const safe_VkCudaLaunchInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + function = copy_src.function; + gridDimX = copy_src.gridDimX; + gridDimY = copy_src.gridDimY; + gridDimZ = copy_src.gridDimZ; + blockDimX = copy_src.blockDimX; + blockDimY = copy_src.blockDimY; + blockDimZ = copy_src.blockDimZ; + sharedMemBytes = copy_src.sharedMemBytes; + paramCount = copy_src.paramCount; + pParams = copy_src.pParams; + extraCount = copy_src.extraCount; + pExtras = copy_src.pExtras; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCudaLaunchInfoNV::~safe_VkCudaLaunchInfoNV() { FreePnextChain(pNext); } + +void safe_VkCudaLaunchInfoNV::initialize(const VkCudaLaunchInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + function = in_struct->function; + gridDimX = in_struct->gridDimX; + gridDimY = in_struct->gridDimY; + gridDimZ = in_struct->gridDimZ; + blockDimX = in_struct->blockDimX; + blockDimY = in_struct->blockDimY; + blockDimZ = in_struct->blockDimZ; + sharedMemBytes = in_struct->sharedMemBytes; + paramCount = in_struct->paramCount; + pParams = in_struct->pParams; + extraCount = in_struct->extraCount; + pExtras = in_struct->pExtras; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCudaLaunchInfoNV::initialize(const safe_VkCudaLaunchInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + function = copy_src->function; + gridDimX = copy_src->gridDimX; + gridDimY = copy_src->gridDimY; + gridDimZ = copy_src->gridDimZ; + blockDimX = copy_src->blockDimX; + blockDimY = copy_src->blockDimY; + blockDimZ = copy_src->blockDimZ; + sharedMemBytes = copy_src->sharedMemBytes; + paramCount = copy_src->paramCount; + pParams = copy_src->pParams; + extraCount = copy_src->extraCount; + pExtras = copy_src->pExtras; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV::safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV( + const VkPhysicalDeviceCudaKernelLaunchFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), cudaKernelLaunchFeatures(in_struct->cudaKernelLaunchFeatures) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV::safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV), pNext(nullptr), cudaKernelLaunchFeatures() {} + +safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV::safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV( + const safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV& copy_src) { + sType = copy_src.sType; + cudaKernelLaunchFeatures = copy_src.cudaKernelLaunchFeatures; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV& safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV::operator=( + const safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + cudaKernelLaunchFeatures = copy_src.cudaKernelLaunchFeatures; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV::~safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV::initialize(const VkPhysicalDeviceCudaKernelLaunchFeaturesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + cudaKernelLaunchFeatures = in_struct->cudaKernelLaunchFeatures; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV::initialize(const safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + cudaKernelLaunchFeatures = copy_src->cudaKernelLaunchFeatures; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV::safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV( + const VkPhysicalDeviceCudaKernelLaunchPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + computeCapabilityMinor(in_struct->computeCapabilityMinor), + computeCapabilityMajor(in_struct->computeCapabilityMajor) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV::safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV), + pNext(nullptr), + computeCapabilityMinor(), + computeCapabilityMajor() {} + +safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV::safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV( + const safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV& copy_src) { + sType = copy_src.sType; + computeCapabilityMinor = copy_src.computeCapabilityMinor; + computeCapabilityMajor = copy_src.computeCapabilityMajor; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV& safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV::operator=( + const safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + computeCapabilityMinor = copy_src.computeCapabilityMinor; + computeCapabilityMajor = copy_src.computeCapabilityMajor; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV::~safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV::initialize(const VkPhysicalDeviceCudaKernelLaunchPropertiesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + computeCapabilityMinor = in_struct->computeCapabilityMinor; + computeCapabilityMajor = in_struct->computeCapabilityMajor; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV::initialize( + const safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + computeCapabilityMinor = copy_src->computeCapabilityMinor; + computeCapabilityMajor = copy_src->computeCapabilityMajor; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkQueryLowLatencySupportNV::safe_VkQueryLowLatencySupportNV(const VkQueryLowLatencySupportNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pQueriedLowLatencyData(in_struct->pQueriedLowLatencyData) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkQueryLowLatencySupportNV::safe_VkQueryLowLatencySupportNV() + : sType(VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV), pNext(nullptr), pQueriedLowLatencyData(nullptr) {} + +safe_VkQueryLowLatencySupportNV::safe_VkQueryLowLatencySupportNV(const safe_VkQueryLowLatencySupportNV& copy_src) { + sType = copy_src.sType; + pQueriedLowLatencyData = copy_src.pQueriedLowLatencyData; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkQueryLowLatencySupportNV& safe_VkQueryLowLatencySupportNV::operator=(const safe_VkQueryLowLatencySupportNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pQueriedLowLatencyData = copy_src.pQueriedLowLatencyData; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkQueryLowLatencySupportNV::~safe_VkQueryLowLatencySupportNV() { FreePnextChain(pNext); } + +void safe_VkQueryLowLatencySupportNV::initialize(const VkQueryLowLatencySupportNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pQueriedLowLatencyData = in_struct->pQueriedLowLatencyData; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkQueryLowLatencySupportNV::initialize(const safe_VkQueryLowLatencySupportNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pQueriedLowLatencyData = copy_src->pQueriedLowLatencyData; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD( + const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), shaderEarlyAndLateFragmentTests(in_struct->shaderEarlyAndLateFragmentTests) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD), + pNext(nullptr), + shaderEarlyAndLateFragmentTests() {} + +safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD( + const safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& copy_src) { + sType = copy_src.sType; + shaderEarlyAndLateFragmentTests = copy_src.shaderEarlyAndLateFragmentTests; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& +safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::operator=( + const safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderEarlyAndLateFragmentTests = copy_src.shaderEarlyAndLateFragmentTests; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD:: + ~safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::initialize( + const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderEarlyAndLateFragmentTests = in_struct->shaderEarlyAndLateFragmentTests; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::initialize( + const safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderEarlyAndLateFragmentTests = copy_src->shaderEarlyAndLateFragmentTests; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV( + const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + fragmentShadingRateEnums(in_struct->fragmentShadingRateEnums), + supersampleFragmentShadingRates(in_struct->supersampleFragmentShadingRates), + noInvocationFragmentShadingRates(in_struct->noInvocationFragmentShadingRates) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV), + pNext(nullptr), + fragmentShadingRateEnums(), + supersampleFragmentShadingRates(), + noInvocationFragmentShadingRates() {} + +safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV( + const safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& copy_src) { + sType = copy_src.sType; + fragmentShadingRateEnums = copy_src.fragmentShadingRateEnums; + supersampleFragmentShadingRates = copy_src.supersampleFragmentShadingRates; + noInvocationFragmentShadingRates = copy_src.noInvocationFragmentShadingRates; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::operator=( + const safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + fragmentShadingRateEnums = copy_src.fragmentShadingRateEnums; + supersampleFragmentShadingRates = copy_src.supersampleFragmentShadingRates; + noInvocationFragmentShadingRates = copy_src.noInvocationFragmentShadingRates; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::~safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::initialize( + const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + fragmentShadingRateEnums = in_struct->fragmentShadingRateEnums; + supersampleFragmentShadingRates = in_struct->supersampleFragmentShadingRates; + noInvocationFragmentShadingRates = in_struct->noInvocationFragmentShadingRates; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::initialize( + const safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + fragmentShadingRateEnums = copy_src->fragmentShadingRateEnums; + supersampleFragmentShadingRates = copy_src->supersampleFragmentShadingRates; + noInvocationFragmentShadingRates = copy_src->noInvocationFragmentShadingRates; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV( + const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), maxFragmentShadingRateInvocationCount(in_struct->maxFragmentShadingRateInvocationCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV), + pNext(nullptr), + maxFragmentShadingRateInvocationCount() {} + +safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV( + const safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& copy_src) { + sType = copy_src.sType; + maxFragmentShadingRateInvocationCount = copy_src.maxFragmentShadingRateInvocationCount; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::operator=( + const safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxFragmentShadingRateInvocationCount = copy_src.maxFragmentShadingRateInvocationCount; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::~safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::initialize( + const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxFragmentShadingRateInvocationCount = in_struct->maxFragmentShadingRateInvocationCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::initialize( + const safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxFragmentShadingRateInvocationCount = copy_src->maxFragmentShadingRateInvocationCount; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV( + const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), shadingRateType(in_struct->shadingRateType), shadingRate(in_struct->shadingRate) { + 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_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV), + pNext(nullptr), + shadingRateType(), + shadingRate() {} + +safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV( + const safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV& copy_src) { + sType = copy_src.sType; + shadingRateType = copy_src.shadingRateType; + shadingRate = copy_src.shadingRate; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < 2; ++i) { + combinerOps[i] = copy_src.combinerOps[i]; + } +} + +safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV& safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::operator=( + const safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shadingRateType = copy_src.shadingRateType; + shadingRate = copy_src.shadingRate; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < 2; ++i) { + combinerOps[i] = copy_src.combinerOps[i]; + } + + return *this; +} + +safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::~safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV() { + FreePnextChain(pNext); +} + +void safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::initialize( + const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shadingRateType = in_struct->shadingRateType; + shadingRate = in_struct->shadingRate; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < 2; ++i) { + combinerOps[i] = in_struct->combinerOps[i]; + } +} + +void safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::initialize( + const safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shadingRateType = copy_src->shadingRateType; + shadingRate = copy_src->shadingRate; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < 2; ++i) { + combinerOps[i] = copy_src->combinerOps[i]; + } +} + +safe_VkAccelerationStructureGeometryMotionTrianglesDataNV::safe_VkAccelerationStructureGeometryMotionTrianglesDataNV( + const VkAccelerationStructureGeometryMotionTrianglesDataNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), vertexData(&in_struct->vertexData) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAccelerationStructureGeometryMotionTrianglesDataNV::safe_VkAccelerationStructureGeometryMotionTrianglesDataNV() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV), pNext(nullptr) {} + +safe_VkAccelerationStructureGeometryMotionTrianglesDataNV::safe_VkAccelerationStructureGeometryMotionTrianglesDataNV( + const safe_VkAccelerationStructureGeometryMotionTrianglesDataNV& copy_src) { + sType = copy_src.sType; + vertexData.initialize(©_src.vertexData); + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAccelerationStructureGeometryMotionTrianglesDataNV& safe_VkAccelerationStructureGeometryMotionTrianglesDataNV::operator=( + const safe_VkAccelerationStructureGeometryMotionTrianglesDataNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + vertexData.initialize(©_src.vertexData); + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAccelerationStructureGeometryMotionTrianglesDataNV::~safe_VkAccelerationStructureGeometryMotionTrianglesDataNV() { + FreePnextChain(pNext); +} + +void safe_VkAccelerationStructureGeometryMotionTrianglesDataNV::initialize( + const VkAccelerationStructureGeometryMotionTrianglesDataNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + vertexData.initialize(&in_struct->vertexData); + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAccelerationStructureGeometryMotionTrianglesDataNV::initialize( + const safe_VkAccelerationStructureGeometryMotionTrianglesDataNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + vertexData.initialize(©_src->vertexData); + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAccelerationStructureMotionInfoNV::safe_VkAccelerationStructureMotionInfoNV( + const VkAccelerationStructureMotionInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), maxInstances(in_struct->maxInstances), flags(in_struct->flags) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAccelerationStructureMotionInfoNV::safe_VkAccelerationStructureMotionInfoNV() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV), pNext(nullptr), maxInstances(), flags() {} + +safe_VkAccelerationStructureMotionInfoNV::safe_VkAccelerationStructureMotionInfoNV( + const safe_VkAccelerationStructureMotionInfoNV& copy_src) { + sType = copy_src.sType; + maxInstances = copy_src.maxInstances; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAccelerationStructureMotionInfoNV& safe_VkAccelerationStructureMotionInfoNV::operator=( + const safe_VkAccelerationStructureMotionInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxInstances = copy_src.maxInstances; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAccelerationStructureMotionInfoNV::~safe_VkAccelerationStructureMotionInfoNV() { FreePnextChain(pNext); } + +void safe_VkAccelerationStructureMotionInfoNV::initialize(const VkAccelerationStructureMotionInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxInstances = in_struct->maxInstances; + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAccelerationStructureMotionInfoNV::initialize(const safe_VkAccelerationStructureMotionInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxInstances = copy_src->maxInstances; + flags = copy_src->flags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV::safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV( + const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + rayTracingMotionBlur(in_struct->rayTracingMotionBlur), + rayTracingMotionBlurPipelineTraceRaysIndirect(in_struct->rayTracingMotionBlurPipelineTraceRaysIndirect) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV::safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV), + pNext(nullptr), + rayTracingMotionBlur(), + rayTracingMotionBlurPipelineTraceRaysIndirect() {} + +safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV::safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV( + const safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& copy_src) { + sType = copy_src.sType; + rayTracingMotionBlur = copy_src.rayTracingMotionBlur; + rayTracingMotionBlurPipelineTraceRaysIndirect = copy_src.rayTracingMotionBlurPipelineTraceRaysIndirect; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV::operator=( + const safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + rayTracingMotionBlur = copy_src.rayTracingMotionBlur; + rayTracingMotionBlurPipelineTraceRaysIndirect = copy_src.rayTracingMotionBlurPipelineTraceRaysIndirect; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV::~safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV::initialize( + const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + rayTracingMotionBlur = in_struct->rayTracingMotionBlur; + rayTracingMotionBlurPipelineTraceRaysIndirect = in_struct->rayTracingMotionBlurPipelineTraceRaysIndirect; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV::initialize( + const safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + rayTracingMotionBlur = copy_src->rayTracingMotionBlur; + rayTracingMotionBlurPipelineTraceRaysIndirect = copy_src->rayTracingMotionBlurPipelineTraceRaysIndirect; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCopyCommandTransformInfoQCOM::safe_VkCopyCommandTransformInfoQCOM(const VkCopyCommandTransformInfoQCOM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), transform(in_struct->transform) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCopyCommandTransformInfoQCOM::safe_VkCopyCommandTransformInfoQCOM() + : sType(VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM), pNext(nullptr), transform() {} + +safe_VkCopyCommandTransformInfoQCOM::safe_VkCopyCommandTransformInfoQCOM(const safe_VkCopyCommandTransformInfoQCOM& copy_src) { + sType = copy_src.sType; + transform = copy_src.transform; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCopyCommandTransformInfoQCOM& safe_VkCopyCommandTransformInfoQCOM::operator=( + const safe_VkCopyCommandTransformInfoQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + transform = copy_src.transform; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCopyCommandTransformInfoQCOM::~safe_VkCopyCommandTransformInfoQCOM() { FreePnextChain(pNext); } + +void safe_VkCopyCommandTransformInfoQCOM::initialize(const VkCopyCommandTransformInfoQCOM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + transform = in_struct->transform; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCopyCommandTransformInfoQCOM::initialize(const safe_VkCopyCommandTransformInfoQCOM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + transform = copy_src->transform; + pNext = SafePnextCopy(copy_src->pNext); +} +#ifdef VK_USE_PLATFORM_FUCHSIA + +safe_VkImportMemoryZirconHandleInfoFUCHSIA::safe_VkImportMemoryZirconHandleInfoFUCHSIA( + const VkImportMemoryZirconHandleInfoFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), handleType(in_struct->handleType), handle(in_struct->handle) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImportMemoryZirconHandleInfoFUCHSIA::safe_VkImportMemoryZirconHandleInfoFUCHSIA() + : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA), pNext(nullptr), handleType(), handle() {} + +safe_VkImportMemoryZirconHandleInfoFUCHSIA::safe_VkImportMemoryZirconHandleInfoFUCHSIA( + const safe_VkImportMemoryZirconHandleInfoFUCHSIA& copy_src) { + sType = copy_src.sType; + handleType = copy_src.handleType; + handle = copy_src.handle; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImportMemoryZirconHandleInfoFUCHSIA& safe_VkImportMemoryZirconHandleInfoFUCHSIA::operator=( + const safe_VkImportMemoryZirconHandleInfoFUCHSIA& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + handleType = copy_src.handleType; + handle = copy_src.handle; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImportMemoryZirconHandleInfoFUCHSIA::~safe_VkImportMemoryZirconHandleInfoFUCHSIA() { FreePnextChain(pNext); } + +void safe_VkImportMemoryZirconHandleInfoFUCHSIA::initialize(const VkImportMemoryZirconHandleInfoFUCHSIA* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + handleType = in_struct->handleType; + handle = in_struct->handle; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImportMemoryZirconHandleInfoFUCHSIA::initialize(const safe_VkImportMemoryZirconHandleInfoFUCHSIA* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + handleType = copy_src->handleType; + handle = copy_src->handle; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMemoryZirconHandlePropertiesFUCHSIA::safe_VkMemoryZirconHandlePropertiesFUCHSIA( + const VkMemoryZirconHandlePropertiesFUCHSIA* 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_VkMemoryZirconHandlePropertiesFUCHSIA::safe_VkMemoryZirconHandlePropertiesFUCHSIA() + : sType(VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA), pNext(nullptr), memoryTypeBits() {} + +safe_VkMemoryZirconHandlePropertiesFUCHSIA::safe_VkMemoryZirconHandlePropertiesFUCHSIA( + const safe_VkMemoryZirconHandlePropertiesFUCHSIA& copy_src) { + sType = copy_src.sType; + memoryTypeBits = copy_src.memoryTypeBits; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryZirconHandlePropertiesFUCHSIA& safe_VkMemoryZirconHandlePropertiesFUCHSIA::operator=( + const safe_VkMemoryZirconHandlePropertiesFUCHSIA& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memoryTypeBits = copy_src.memoryTypeBits; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryZirconHandlePropertiesFUCHSIA::~safe_VkMemoryZirconHandlePropertiesFUCHSIA() { FreePnextChain(pNext); } + +void safe_VkMemoryZirconHandlePropertiesFUCHSIA::initialize(const VkMemoryZirconHandlePropertiesFUCHSIA* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memoryTypeBits = in_struct->memoryTypeBits; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryZirconHandlePropertiesFUCHSIA::initialize(const safe_VkMemoryZirconHandlePropertiesFUCHSIA* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memoryTypeBits = copy_src->memoryTypeBits; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMemoryGetZirconHandleInfoFUCHSIA::safe_VkMemoryGetZirconHandleInfoFUCHSIA( + const VkMemoryGetZirconHandleInfoFUCHSIA* 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_VkMemoryGetZirconHandleInfoFUCHSIA::safe_VkMemoryGetZirconHandleInfoFUCHSIA() + : sType(VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA), pNext(nullptr), memory(), handleType() {} + +safe_VkMemoryGetZirconHandleInfoFUCHSIA::safe_VkMemoryGetZirconHandleInfoFUCHSIA( + const safe_VkMemoryGetZirconHandleInfoFUCHSIA& copy_src) { + sType = copy_src.sType; + memory = copy_src.memory; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryGetZirconHandleInfoFUCHSIA& safe_VkMemoryGetZirconHandleInfoFUCHSIA::operator=( + const safe_VkMemoryGetZirconHandleInfoFUCHSIA& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memory = copy_src.memory; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryGetZirconHandleInfoFUCHSIA::~safe_VkMemoryGetZirconHandleInfoFUCHSIA() { FreePnextChain(pNext); } + +void safe_VkMemoryGetZirconHandleInfoFUCHSIA::initialize(const VkMemoryGetZirconHandleInfoFUCHSIA* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memory = in_struct->memory; + handleType = in_struct->handleType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryGetZirconHandleInfoFUCHSIA::initialize(const safe_VkMemoryGetZirconHandleInfoFUCHSIA* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memory = copy_src->memory; + handleType = copy_src->handleType; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::safe_VkImportSemaphoreZirconHandleInfoFUCHSIA( + const VkImportSemaphoreZirconHandleInfoFUCHSIA* 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), + zirconHandle(in_struct->zirconHandle) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::safe_VkImportSemaphoreZirconHandleInfoFUCHSIA() + : sType(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA), + pNext(nullptr), + semaphore(), + flags(), + handleType(), + zirconHandle() {} + +safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::safe_VkImportSemaphoreZirconHandleInfoFUCHSIA( + const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& copy_src) { + sType = copy_src.sType; + semaphore = copy_src.semaphore; + flags = copy_src.flags; + handleType = copy_src.handleType; + zirconHandle = copy_src.zirconHandle; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::operator=( + const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + semaphore = copy_src.semaphore; + flags = copy_src.flags; + handleType = copy_src.handleType; + zirconHandle = copy_src.zirconHandle; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::~safe_VkImportSemaphoreZirconHandleInfoFUCHSIA() { FreePnextChain(pNext); } + +void safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::initialize(const VkImportSemaphoreZirconHandleInfoFUCHSIA* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + semaphore = in_struct->semaphore; + flags = in_struct->flags; + handleType = in_struct->handleType; + zirconHandle = in_struct->zirconHandle; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::initialize(const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + semaphore = copy_src->semaphore; + flags = copy_src->flags; + handleType = copy_src->handleType; + zirconHandle = copy_src->zirconHandle; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::safe_VkSemaphoreGetZirconHandleInfoFUCHSIA( + const VkSemaphoreGetZirconHandleInfoFUCHSIA* 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_VkSemaphoreGetZirconHandleInfoFUCHSIA::safe_VkSemaphoreGetZirconHandleInfoFUCHSIA() + : sType(VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA), pNext(nullptr), semaphore(), handleType() {} + +safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::safe_VkSemaphoreGetZirconHandleInfoFUCHSIA( + const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& copy_src) { + sType = copy_src.sType; + semaphore = copy_src.semaphore; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::operator=( + const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + semaphore = copy_src.semaphore; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::~safe_VkSemaphoreGetZirconHandleInfoFUCHSIA() { FreePnextChain(pNext); } + +void safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::initialize(const VkSemaphoreGetZirconHandleInfoFUCHSIA* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + semaphore = in_struct->semaphore; + handleType = in_struct->handleType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::initialize(const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + semaphore = copy_src->semaphore; + handleType = copy_src->handleType; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBufferCollectionCreateInfoFUCHSIA::safe_VkBufferCollectionCreateInfoFUCHSIA( + const VkBufferCollectionCreateInfoFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), collectionToken(in_struct->collectionToken) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBufferCollectionCreateInfoFUCHSIA::safe_VkBufferCollectionCreateInfoFUCHSIA() + : sType(VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA), pNext(nullptr), collectionToken() {} + +safe_VkBufferCollectionCreateInfoFUCHSIA::safe_VkBufferCollectionCreateInfoFUCHSIA( + const safe_VkBufferCollectionCreateInfoFUCHSIA& copy_src) { + sType = copy_src.sType; + collectionToken = copy_src.collectionToken; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBufferCollectionCreateInfoFUCHSIA& safe_VkBufferCollectionCreateInfoFUCHSIA::operator=( + const safe_VkBufferCollectionCreateInfoFUCHSIA& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + collectionToken = copy_src.collectionToken; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBufferCollectionCreateInfoFUCHSIA::~safe_VkBufferCollectionCreateInfoFUCHSIA() { FreePnextChain(pNext); } + +void safe_VkBufferCollectionCreateInfoFUCHSIA::initialize(const VkBufferCollectionCreateInfoFUCHSIA* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + collectionToken = in_struct->collectionToken; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBufferCollectionCreateInfoFUCHSIA::initialize(const safe_VkBufferCollectionCreateInfoFUCHSIA* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + collectionToken = copy_src->collectionToken; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImportMemoryBufferCollectionFUCHSIA::safe_VkImportMemoryBufferCollectionFUCHSIA( + const VkImportMemoryBufferCollectionFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), collection(in_struct->collection), index(in_struct->index) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImportMemoryBufferCollectionFUCHSIA::safe_VkImportMemoryBufferCollectionFUCHSIA() + : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA), pNext(nullptr), collection(), index() {} + +safe_VkImportMemoryBufferCollectionFUCHSIA::safe_VkImportMemoryBufferCollectionFUCHSIA( + const safe_VkImportMemoryBufferCollectionFUCHSIA& copy_src) { + sType = copy_src.sType; + collection = copy_src.collection; + index = copy_src.index; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImportMemoryBufferCollectionFUCHSIA& safe_VkImportMemoryBufferCollectionFUCHSIA::operator=( + const safe_VkImportMemoryBufferCollectionFUCHSIA& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + collection = copy_src.collection; + index = copy_src.index; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImportMemoryBufferCollectionFUCHSIA::~safe_VkImportMemoryBufferCollectionFUCHSIA() { FreePnextChain(pNext); } + +void safe_VkImportMemoryBufferCollectionFUCHSIA::initialize(const VkImportMemoryBufferCollectionFUCHSIA* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + collection = in_struct->collection; + index = in_struct->index; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImportMemoryBufferCollectionFUCHSIA::initialize(const safe_VkImportMemoryBufferCollectionFUCHSIA* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + collection = copy_src->collection; + index = copy_src->index; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBufferCollectionImageCreateInfoFUCHSIA::safe_VkBufferCollectionImageCreateInfoFUCHSIA( + const VkBufferCollectionImageCreateInfoFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), collection(in_struct->collection), index(in_struct->index) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBufferCollectionImageCreateInfoFUCHSIA::safe_VkBufferCollectionImageCreateInfoFUCHSIA() + : sType(VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA), pNext(nullptr), collection(), index() {} + +safe_VkBufferCollectionImageCreateInfoFUCHSIA::safe_VkBufferCollectionImageCreateInfoFUCHSIA( + const safe_VkBufferCollectionImageCreateInfoFUCHSIA& copy_src) { + sType = copy_src.sType; + collection = copy_src.collection; + index = copy_src.index; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBufferCollectionImageCreateInfoFUCHSIA& safe_VkBufferCollectionImageCreateInfoFUCHSIA::operator=( + const safe_VkBufferCollectionImageCreateInfoFUCHSIA& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + collection = copy_src.collection; + index = copy_src.index; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBufferCollectionImageCreateInfoFUCHSIA::~safe_VkBufferCollectionImageCreateInfoFUCHSIA() { FreePnextChain(pNext); } + +void safe_VkBufferCollectionImageCreateInfoFUCHSIA::initialize(const VkBufferCollectionImageCreateInfoFUCHSIA* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + collection = in_struct->collection; + index = in_struct->index; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBufferCollectionImageCreateInfoFUCHSIA::initialize(const safe_VkBufferCollectionImageCreateInfoFUCHSIA* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + collection = copy_src->collection; + index = copy_src->index; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBufferCollectionConstraintsInfoFUCHSIA::safe_VkBufferCollectionConstraintsInfoFUCHSIA( + const VkBufferCollectionConstraintsInfoFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + minBufferCount(in_struct->minBufferCount), + maxBufferCount(in_struct->maxBufferCount), + minBufferCountForCamping(in_struct->minBufferCountForCamping), + minBufferCountForDedicatedSlack(in_struct->minBufferCountForDedicatedSlack), + minBufferCountForSharedSlack(in_struct->minBufferCountForSharedSlack) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBufferCollectionConstraintsInfoFUCHSIA::safe_VkBufferCollectionConstraintsInfoFUCHSIA() + : sType(VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA), + pNext(nullptr), + minBufferCount(), + maxBufferCount(), + minBufferCountForCamping(), + minBufferCountForDedicatedSlack(), + minBufferCountForSharedSlack() {} + +safe_VkBufferCollectionConstraintsInfoFUCHSIA::safe_VkBufferCollectionConstraintsInfoFUCHSIA( + const safe_VkBufferCollectionConstraintsInfoFUCHSIA& copy_src) { + sType = copy_src.sType; + minBufferCount = copy_src.minBufferCount; + maxBufferCount = copy_src.maxBufferCount; + minBufferCountForCamping = copy_src.minBufferCountForCamping; + minBufferCountForDedicatedSlack = copy_src.minBufferCountForDedicatedSlack; + minBufferCountForSharedSlack = copy_src.minBufferCountForSharedSlack; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBufferCollectionConstraintsInfoFUCHSIA& safe_VkBufferCollectionConstraintsInfoFUCHSIA::operator=( + const safe_VkBufferCollectionConstraintsInfoFUCHSIA& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + minBufferCount = copy_src.minBufferCount; + maxBufferCount = copy_src.maxBufferCount; + minBufferCountForCamping = copy_src.minBufferCountForCamping; + minBufferCountForDedicatedSlack = copy_src.minBufferCountForDedicatedSlack; + minBufferCountForSharedSlack = copy_src.minBufferCountForSharedSlack; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBufferCollectionConstraintsInfoFUCHSIA::~safe_VkBufferCollectionConstraintsInfoFUCHSIA() { FreePnextChain(pNext); } + +void safe_VkBufferCollectionConstraintsInfoFUCHSIA::initialize(const VkBufferCollectionConstraintsInfoFUCHSIA* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + minBufferCount = in_struct->minBufferCount; + maxBufferCount = in_struct->maxBufferCount; + minBufferCountForCamping = in_struct->minBufferCountForCamping; + minBufferCountForDedicatedSlack = in_struct->minBufferCountForDedicatedSlack; + minBufferCountForSharedSlack = in_struct->minBufferCountForSharedSlack; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBufferCollectionConstraintsInfoFUCHSIA::initialize(const safe_VkBufferCollectionConstraintsInfoFUCHSIA* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + minBufferCount = copy_src->minBufferCount; + maxBufferCount = copy_src->maxBufferCount; + minBufferCountForCamping = copy_src->minBufferCountForCamping; + minBufferCountForDedicatedSlack = copy_src->minBufferCountForDedicatedSlack; + minBufferCountForSharedSlack = copy_src->minBufferCountForSharedSlack; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBufferConstraintsInfoFUCHSIA::safe_VkBufferConstraintsInfoFUCHSIA(const VkBufferConstraintsInfoFUCHSIA* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + createInfo(&in_struct->createInfo), + requiredFormatFeatures(in_struct->requiredFormatFeatures), + bufferCollectionConstraints(&in_struct->bufferCollectionConstraints) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBufferConstraintsInfoFUCHSIA::safe_VkBufferConstraintsInfoFUCHSIA() + : sType(VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA), pNext(nullptr), requiredFormatFeatures() {} + +safe_VkBufferConstraintsInfoFUCHSIA::safe_VkBufferConstraintsInfoFUCHSIA(const safe_VkBufferConstraintsInfoFUCHSIA& copy_src) { + sType = copy_src.sType; + createInfo.initialize(©_src.createInfo); + requiredFormatFeatures = copy_src.requiredFormatFeatures; + bufferCollectionConstraints.initialize(©_src.bufferCollectionConstraints); + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBufferConstraintsInfoFUCHSIA& safe_VkBufferConstraintsInfoFUCHSIA::operator=( + const safe_VkBufferConstraintsInfoFUCHSIA& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + createInfo.initialize(©_src.createInfo); + requiredFormatFeatures = copy_src.requiredFormatFeatures; + bufferCollectionConstraints.initialize(©_src.bufferCollectionConstraints); + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBufferConstraintsInfoFUCHSIA::~safe_VkBufferConstraintsInfoFUCHSIA() { FreePnextChain(pNext); } + +void safe_VkBufferConstraintsInfoFUCHSIA::initialize(const VkBufferConstraintsInfoFUCHSIA* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + createInfo.initialize(&in_struct->createInfo); + requiredFormatFeatures = in_struct->requiredFormatFeatures; + bufferCollectionConstraints.initialize(&in_struct->bufferCollectionConstraints); + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBufferConstraintsInfoFUCHSIA::initialize(const safe_VkBufferConstraintsInfoFUCHSIA* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + createInfo.initialize(©_src->createInfo); + requiredFormatFeatures = copy_src->requiredFormatFeatures; + bufferCollectionConstraints.initialize(©_src->bufferCollectionConstraints); + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBufferCollectionBufferCreateInfoFUCHSIA::safe_VkBufferCollectionBufferCreateInfoFUCHSIA( + const VkBufferCollectionBufferCreateInfoFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), collection(in_struct->collection), index(in_struct->index) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBufferCollectionBufferCreateInfoFUCHSIA::safe_VkBufferCollectionBufferCreateInfoFUCHSIA() + : sType(VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA), pNext(nullptr), collection(), index() {} + +safe_VkBufferCollectionBufferCreateInfoFUCHSIA::safe_VkBufferCollectionBufferCreateInfoFUCHSIA( + const safe_VkBufferCollectionBufferCreateInfoFUCHSIA& copy_src) { + sType = copy_src.sType; + collection = copy_src.collection; + index = copy_src.index; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBufferCollectionBufferCreateInfoFUCHSIA& safe_VkBufferCollectionBufferCreateInfoFUCHSIA::operator=( + const safe_VkBufferCollectionBufferCreateInfoFUCHSIA& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + collection = copy_src.collection; + index = copy_src.index; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBufferCollectionBufferCreateInfoFUCHSIA::~safe_VkBufferCollectionBufferCreateInfoFUCHSIA() { FreePnextChain(pNext); } + +void safe_VkBufferCollectionBufferCreateInfoFUCHSIA::initialize(const VkBufferCollectionBufferCreateInfoFUCHSIA* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + collection = in_struct->collection; + index = in_struct->index; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBufferCollectionBufferCreateInfoFUCHSIA::initialize(const safe_VkBufferCollectionBufferCreateInfoFUCHSIA* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + collection = copy_src->collection; + index = copy_src->index; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSysmemColorSpaceFUCHSIA::safe_VkSysmemColorSpaceFUCHSIA(const VkSysmemColorSpaceFUCHSIA* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), colorSpace(in_struct->colorSpace) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSysmemColorSpaceFUCHSIA::safe_VkSysmemColorSpaceFUCHSIA() + : sType(VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA), pNext(nullptr), colorSpace() {} + +safe_VkSysmemColorSpaceFUCHSIA::safe_VkSysmemColorSpaceFUCHSIA(const safe_VkSysmemColorSpaceFUCHSIA& copy_src) { + sType = copy_src.sType; + colorSpace = copy_src.colorSpace; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSysmemColorSpaceFUCHSIA& safe_VkSysmemColorSpaceFUCHSIA::operator=(const safe_VkSysmemColorSpaceFUCHSIA& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + colorSpace = copy_src.colorSpace; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSysmemColorSpaceFUCHSIA::~safe_VkSysmemColorSpaceFUCHSIA() { FreePnextChain(pNext); } + +void safe_VkSysmemColorSpaceFUCHSIA::initialize(const VkSysmemColorSpaceFUCHSIA* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + colorSpace = in_struct->colorSpace; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSysmemColorSpaceFUCHSIA::initialize(const safe_VkSysmemColorSpaceFUCHSIA* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + colorSpace = copy_src->colorSpace; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBufferCollectionPropertiesFUCHSIA::safe_VkBufferCollectionPropertiesFUCHSIA( + const VkBufferCollectionPropertiesFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + memoryTypeBits(in_struct->memoryTypeBits), + bufferCount(in_struct->bufferCount), + createInfoIndex(in_struct->createInfoIndex), + sysmemPixelFormat(in_struct->sysmemPixelFormat), + formatFeatures(in_struct->formatFeatures), + sysmemColorSpaceIndex(&in_struct->sysmemColorSpaceIndex), + samplerYcbcrConversionComponents(in_struct->samplerYcbcrConversionComponents), + suggestedYcbcrModel(in_struct->suggestedYcbcrModel), + suggestedYcbcrRange(in_struct->suggestedYcbcrRange), + suggestedXChromaOffset(in_struct->suggestedXChromaOffset), + suggestedYChromaOffset(in_struct->suggestedYChromaOffset) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBufferCollectionPropertiesFUCHSIA::safe_VkBufferCollectionPropertiesFUCHSIA() + : sType(VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA), + pNext(nullptr), + memoryTypeBits(), + bufferCount(), + createInfoIndex(), + sysmemPixelFormat(), + formatFeatures(), + samplerYcbcrConversionComponents(), + suggestedYcbcrModel(), + suggestedYcbcrRange(), + suggestedXChromaOffset(), + suggestedYChromaOffset() {} + +safe_VkBufferCollectionPropertiesFUCHSIA::safe_VkBufferCollectionPropertiesFUCHSIA( + const safe_VkBufferCollectionPropertiesFUCHSIA& copy_src) { + sType = copy_src.sType; + memoryTypeBits = copy_src.memoryTypeBits; + bufferCount = copy_src.bufferCount; + createInfoIndex = copy_src.createInfoIndex; + sysmemPixelFormat = copy_src.sysmemPixelFormat; + formatFeatures = copy_src.formatFeatures; + sysmemColorSpaceIndex.initialize(©_src.sysmemColorSpaceIndex); + samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents; + suggestedYcbcrModel = copy_src.suggestedYcbcrModel; + suggestedYcbcrRange = copy_src.suggestedYcbcrRange; + suggestedXChromaOffset = copy_src.suggestedXChromaOffset; + suggestedYChromaOffset = copy_src.suggestedYChromaOffset; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBufferCollectionPropertiesFUCHSIA& safe_VkBufferCollectionPropertiesFUCHSIA::operator=( + const safe_VkBufferCollectionPropertiesFUCHSIA& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memoryTypeBits = copy_src.memoryTypeBits; + bufferCount = copy_src.bufferCount; + createInfoIndex = copy_src.createInfoIndex; + sysmemPixelFormat = copy_src.sysmemPixelFormat; + formatFeatures = copy_src.formatFeatures; + sysmemColorSpaceIndex.initialize(©_src.sysmemColorSpaceIndex); + samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents; + suggestedYcbcrModel = copy_src.suggestedYcbcrModel; + suggestedYcbcrRange = copy_src.suggestedYcbcrRange; + suggestedXChromaOffset = copy_src.suggestedXChromaOffset; + suggestedYChromaOffset = copy_src.suggestedYChromaOffset; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBufferCollectionPropertiesFUCHSIA::~safe_VkBufferCollectionPropertiesFUCHSIA() { FreePnextChain(pNext); } + +void safe_VkBufferCollectionPropertiesFUCHSIA::initialize(const VkBufferCollectionPropertiesFUCHSIA* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memoryTypeBits = in_struct->memoryTypeBits; + bufferCount = in_struct->bufferCount; + createInfoIndex = in_struct->createInfoIndex; + sysmemPixelFormat = in_struct->sysmemPixelFormat; + formatFeatures = in_struct->formatFeatures; + sysmemColorSpaceIndex.initialize(&in_struct->sysmemColorSpaceIndex); + samplerYcbcrConversionComponents = in_struct->samplerYcbcrConversionComponents; + suggestedYcbcrModel = in_struct->suggestedYcbcrModel; + suggestedYcbcrRange = in_struct->suggestedYcbcrRange; + suggestedXChromaOffset = in_struct->suggestedXChromaOffset; + suggestedYChromaOffset = in_struct->suggestedYChromaOffset; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBufferCollectionPropertiesFUCHSIA::initialize(const safe_VkBufferCollectionPropertiesFUCHSIA* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memoryTypeBits = copy_src->memoryTypeBits; + bufferCount = copy_src->bufferCount; + createInfoIndex = copy_src->createInfoIndex; + sysmemPixelFormat = copy_src->sysmemPixelFormat; + formatFeatures = copy_src->formatFeatures; + sysmemColorSpaceIndex.initialize(©_src->sysmemColorSpaceIndex); + samplerYcbcrConversionComponents = copy_src->samplerYcbcrConversionComponents; + suggestedYcbcrModel = copy_src->suggestedYcbcrModel; + suggestedYcbcrRange = copy_src->suggestedYcbcrRange; + suggestedXChromaOffset = copy_src->suggestedXChromaOffset; + suggestedYChromaOffset = copy_src->suggestedYChromaOffset; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImageFormatConstraintsInfoFUCHSIA::safe_VkImageFormatConstraintsInfoFUCHSIA( + const VkImageFormatConstraintsInfoFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + imageCreateInfo(&in_struct->imageCreateInfo), + requiredFormatFeatures(in_struct->requiredFormatFeatures), + flags(in_struct->flags), + sysmemPixelFormat(in_struct->sysmemPixelFormat), + colorSpaceCount(in_struct->colorSpaceCount), + pColorSpaces(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (colorSpaceCount && in_struct->pColorSpaces) { + pColorSpaces = new safe_VkSysmemColorSpaceFUCHSIA[colorSpaceCount]; + for (uint32_t i = 0; i < colorSpaceCount; ++i) { + pColorSpaces[i].initialize(&in_struct->pColorSpaces[i]); + } + } +} + +safe_VkImageFormatConstraintsInfoFUCHSIA::safe_VkImageFormatConstraintsInfoFUCHSIA() + : sType(VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA), + pNext(nullptr), + requiredFormatFeatures(), + flags(), + sysmemPixelFormat(), + colorSpaceCount(), + pColorSpaces(nullptr) {} + +safe_VkImageFormatConstraintsInfoFUCHSIA::safe_VkImageFormatConstraintsInfoFUCHSIA( + const safe_VkImageFormatConstraintsInfoFUCHSIA& copy_src) { + sType = copy_src.sType; + imageCreateInfo.initialize(©_src.imageCreateInfo); + requiredFormatFeatures = copy_src.requiredFormatFeatures; + flags = copy_src.flags; + sysmemPixelFormat = copy_src.sysmemPixelFormat; + colorSpaceCount = copy_src.colorSpaceCount; + pColorSpaces = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (colorSpaceCount && copy_src.pColorSpaces) { + pColorSpaces = new safe_VkSysmemColorSpaceFUCHSIA[colorSpaceCount]; + for (uint32_t i = 0; i < colorSpaceCount; ++i) { + pColorSpaces[i].initialize(©_src.pColorSpaces[i]); + } + } +} + +safe_VkImageFormatConstraintsInfoFUCHSIA& safe_VkImageFormatConstraintsInfoFUCHSIA::operator=( + const safe_VkImageFormatConstraintsInfoFUCHSIA& copy_src) { + if (©_src == this) return *this; + + if (pColorSpaces) delete[] pColorSpaces; + FreePnextChain(pNext); + + sType = copy_src.sType; + imageCreateInfo.initialize(©_src.imageCreateInfo); + requiredFormatFeatures = copy_src.requiredFormatFeatures; + flags = copy_src.flags; + sysmemPixelFormat = copy_src.sysmemPixelFormat; + colorSpaceCount = copy_src.colorSpaceCount; + pColorSpaces = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (colorSpaceCount && copy_src.pColorSpaces) { + pColorSpaces = new safe_VkSysmemColorSpaceFUCHSIA[colorSpaceCount]; + for (uint32_t i = 0; i < colorSpaceCount; ++i) { + pColorSpaces[i].initialize(©_src.pColorSpaces[i]); + } + } + + return *this; +} + +safe_VkImageFormatConstraintsInfoFUCHSIA::~safe_VkImageFormatConstraintsInfoFUCHSIA() { + if (pColorSpaces) delete[] pColorSpaces; + FreePnextChain(pNext); +} + +void safe_VkImageFormatConstraintsInfoFUCHSIA::initialize(const VkImageFormatConstraintsInfoFUCHSIA* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pColorSpaces) delete[] pColorSpaces; + FreePnextChain(pNext); + sType = in_struct->sType; + imageCreateInfo.initialize(&in_struct->imageCreateInfo); + requiredFormatFeatures = in_struct->requiredFormatFeatures; + flags = in_struct->flags; + sysmemPixelFormat = in_struct->sysmemPixelFormat; + colorSpaceCount = in_struct->colorSpaceCount; + pColorSpaces = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (colorSpaceCount && in_struct->pColorSpaces) { + pColorSpaces = new safe_VkSysmemColorSpaceFUCHSIA[colorSpaceCount]; + for (uint32_t i = 0; i < colorSpaceCount; ++i) { + pColorSpaces[i].initialize(&in_struct->pColorSpaces[i]); + } + } +} + +void safe_VkImageFormatConstraintsInfoFUCHSIA::initialize(const safe_VkImageFormatConstraintsInfoFUCHSIA* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + imageCreateInfo.initialize(©_src->imageCreateInfo); + requiredFormatFeatures = copy_src->requiredFormatFeatures; + flags = copy_src->flags; + sysmemPixelFormat = copy_src->sysmemPixelFormat; + colorSpaceCount = copy_src->colorSpaceCount; + pColorSpaces = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (colorSpaceCount && copy_src->pColorSpaces) { + pColorSpaces = new safe_VkSysmemColorSpaceFUCHSIA[colorSpaceCount]; + for (uint32_t i = 0; i < colorSpaceCount; ++i) { + pColorSpaces[i].initialize(©_src->pColorSpaces[i]); + } + } +} + +safe_VkImageConstraintsInfoFUCHSIA::safe_VkImageConstraintsInfoFUCHSIA(const VkImageConstraintsInfoFUCHSIA* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + formatConstraintsCount(in_struct->formatConstraintsCount), + pFormatConstraints(nullptr), + bufferCollectionConstraints(&in_struct->bufferCollectionConstraints), + flags(in_struct->flags) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (formatConstraintsCount && in_struct->pFormatConstraints) { + pFormatConstraints = new safe_VkImageFormatConstraintsInfoFUCHSIA[formatConstraintsCount]; + for (uint32_t i = 0; i < formatConstraintsCount; ++i) { + pFormatConstraints[i].initialize(&in_struct->pFormatConstraints[i]); + } + } +} + +safe_VkImageConstraintsInfoFUCHSIA::safe_VkImageConstraintsInfoFUCHSIA() + : sType(VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA), + pNext(nullptr), + formatConstraintsCount(), + pFormatConstraints(nullptr), + flags() {} + +safe_VkImageConstraintsInfoFUCHSIA::safe_VkImageConstraintsInfoFUCHSIA(const safe_VkImageConstraintsInfoFUCHSIA& copy_src) { + sType = copy_src.sType; + formatConstraintsCount = copy_src.formatConstraintsCount; + pFormatConstraints = nullptr; + bufferCollectionConstraints.initialize(©_src.bufferCollectionConstraints); + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + if (formatConstraintsCount && copy_src.pFormatConstraints) { + pFormatConstraints = new safe_VkImageFormatConstraintsInfoFUCHSIA[formatConstraintsCount]; + for (uint32_t i = 0; i < formatConstraintsCount; ++i) { + pFormatConstraints[i].initialize(©_src.pFormatConstraints[i]); + } + } +} + +safe_VkImageConstraintsInfoFUCHSIA& safe_VkImageConstraintsInfoFUCHSIA::operator=( + const safe_VkImageConstraintsInfoFUCHSIA& copy_src) { + if (©_src == this) return *this; + + if (pFormatConstraints) delete[] pFormatConstraints; + FreePnextChain(pNext); + + sType = copy_src.sType; + formatConstraintsCount = copy_src.formatConstraintsCount; + pFormatConstraints = nullptr; + bufferCollectionConstraints.initialize(©_src.bufferCollectionConstraints); + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + if (formatConstraintsCount && copy_src.pFormatConstraints) { + pFormatConstraints = new safe_VkImageFormatConstraintsInfoFUCHSIA[formatConstraintsCount]; + for (uint32_t i = 0; i < formatConstraintsCount; ++i) { + pFormatConstraints[i].initialize(©_src.pFormatConstraints[i]); + } + } + + return *this; +} + +safe_VkImageConstraintsInfoFUCHSIA::~safe_VkImageConstraintsInfoFUCHSIA() { + if (pFormatConstraints) delete[] pFormatConstraints; + FreePnextChain(pNext); +} + +void safe_VkImageConstraintsInfoFUCHSIA::initialize(const VkImageConstraintsInfoFUCHSIA* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pFormatConstraints) delete[] pFormatConstraints; + FreePnextChain(pNext); + sType = in_struct->sType; + formatConstraintsCount = in_struct->formatConstraintsCount; + pFormatConstraints = nullptr; + bufferCollectionConstraints.initialize(&in_struct->bufferCollectionConstraints); + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (formatConstraintsCount && in_struct->pFormatConstraints) { + pFormatConstraints = new safe_VkImageFormatConstraintsInfoFUCHSIA[formatConstraintsCount]; + for (uint32_t i = 0; i < formatConstraintsCount; ++i) { + pFormatConstraints[i].initialize(&in_struct->pFormatConstraints[i]); + } + } +} + +void safe_VkImageConstraintsInfoFUCHSIA::initialize(const safe_VkImageConstraintsInfoFUCHSIA* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + formatConstraintsCount = copy_src->formatConstraintsCount; + pFormatConstraints = nullptr; + bufferCollectionConstraints.initialize(©_src->bufferCollectionConstraints); + flags = copy_src->flags; + pNext = SafePnextCopy(copy_src->pNext); + if (formatConstraintsCount && copy_src->pFormatConstraints) { + pFormatConstraints = new safe_VkImageFormatConstraintsInfoFUCHSIA[formatConstraintsCount]; + for (uint32_t i = 0; i < formatConstraintsCount; ++i) { + pFormatConstraints[i].initialize(©_src->pFormatConstraints[i]); + } + } +} +#endif // VK_USE_PLATFORM_FUCHSIA + +safe_VkSubpassShadingPipelineCreateInfoHUAWEI::safe_VkSubpassShadingPipelineCreateInfoHUAWEI( + const VkSubpassShadingPipelineCreateInfoHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), renderPass(in_struct->renderPass), subpass(in_struct->subpass) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSubpassShadingPipelineCreateInfoHUAWEI::safe_VkSubpassShadingPipelineCreateInfoHUAWEI() + : sType(VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI), pNext(nullptr), renderPass(), subpass() {} + +safe_VkSubpassShadingPipelineCreateInfoHUAWEI::safe_VkSubpassShadingPipelineCreateInfoHUAWEI( + const safe_VkSubpassShadingPipelineCreateInfoHUAWEI& copy_src) { + sType = copy_src.sType; + renderPass = copy_src.renderPass; + subpass = copy_src.subpass; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSubpassShadingPipelineCreateInfoHUAWEI& safe_VkSubpassShadingPipelineCreateInfoHUAWEI::operator=( + const safe_VkSubpassShadingPipelineCreateInfoHUAWEI& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + renderPass = copy_src.renderPass; + subpass = copy_src.subpass; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSubpassShadingPipelineCreateInfoHUAWEI::~safe_VkSubpassShadingPipelineCreateInfoHUAWEI() { FreePnextChain(pNext); } + +void safe_VkSubpassShadingPipelineCreateInfoHUAWEI::initialize(const VkSubpassShadingPipelineCreateInfoHUAWEI* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + renderPass = in_struct->renderPass; + subpass = in_struct->subpass; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSubpassShadingPipelineCreateInfoHUAWEI::initialize(const safe_VkSubpassShadingPipelineCreateInfoHUAWEI* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + renderPass = copy_src->renderPass; + subpass = copy_src->subpass; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI::safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI( + const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), subpassShading(in_struct->subpassShading) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI::safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI), pNext(nullptr), subpassShading() {} + +safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI::safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI( + const safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& copy_src) { + sType = copy_src.sType; + subpassShading = copy_src.subpassShading; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI::operator=( + const safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + subpassShading = copy_src.subpassShading; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI::~safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI::initialize(const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + subpassShading = in_struct->subpassShading; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI::initialize( + const safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + subpassShading = copy_src->subpassShading; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI::safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI( + const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), maxSubpassShadingWorkgroupSizeAspectRatio(in_struct->maxSubpassShadingWorkgroupSizeAspectRatio) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI::safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI), + pNext(nullptr), + maxSubpassShadingWorkgroupSizeAspectRatio() {} + +safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI::safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI( + const safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& copy_src) { + sType = copy_src.sType; + maxSubpassShadingWorkgroupSizeAspectRatio = copy_src.maxSubpassShadingWorkgroupSizeAspectRatio; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI::operator=( + const safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxSubpassShadingWorkgroupSizeAspectRatio = copy_src.maxSubpassShadingWorkgroupSizeAspectRatio; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI::~safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI::initialize( + const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxSubpassShadingWorkgroupSizeAspectRatio = in_struct->maxSubpassShadingWorkgroupSizeAspectRatio; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI::initialize( + const safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxSubpassShadingWorkgroupSizeAspectRatio = copy_src->maxSubpassShadingWorkgroupSizeAspectRatio; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI::safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI( + const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), invocationMask(in_struct->invocationMask) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI::safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI), pNext(nullptr), invocationMask() {} + +safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI::safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI( + const safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& copy_src) { + sType = copy_src.sType; + invocationMask = copy_src.invocationMask; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI::operator=( + const safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + invocationMask = copy_src.invocationMask; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI::~safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI::initialize(const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + invocationMask = in_struct->invocationMask; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI::initialize( + const safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + invocationMask = copy_src->invocationMask; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMemoryGetRemoteAddressInfoNV::safe_VkMemoryGetRemoteAddressInfoNV(const VkMemoryGetRemoteAddressInfoNV* 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_VkMemoryGetRemoteAddressInfoNV::safe_VkMemoryGetRemoteAddressInfoNV() + : sType(VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV), pNext(nullptr), memory(), handleType() {} + +safe_VkMemoryGetRemoteAddressInfoNV::safe_VkMemoryGetRemoteAddressInfoNV(const safe_VkMemoryGetRemoteAddressInfoNV& copy_src) { + sType = copy_src.sType; + memory = copy_src.memory; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkMemoryGetRemoteAddressInfoNV& safe_VkMemoryGetRemoteAddressInfoNV::operator=( + const safe_VkMemoryGetRemoteAddressInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memory = copy_src.memory; + handleType = copy_src.handleType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkMemoryGetRemoteAddressInfoNV::~safe_VkMemoryGetRemoteAddressInfoNV() { FreePnextChain(pNext); } + +void safe_VkMemoryGetRemoteAddressInfoNV::initialize(const VkMemoryGetRemoteAddressInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memory = in_struct->memory; + handleType = in_struct->handleType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkMemoryGetRemoteAddressInfoNV::initialize(const safe_VkMemoryGetRemoteAddressInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memory = copy_src->memory; + handleType = copy_src->handleType; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV::safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV( + const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), externalMemoryRDMA(in_struct->externalMemoryRDMA) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV::safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV), pNext(nullptr), externalMemoryRDMA() {} + +safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV::safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV( + const safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& copy_src) { + sType = copy_src.sType; + externalMemoryRDMA = copy_src.externalMemoryRDMA; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV::operator=( + const safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + externalMemoryRDMA = copy_src.externalMemoryRDMA; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV::~safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV::initialize(const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + externalMemoryRDMA = in_struct->externalMemoryRDMA; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV::initialize( + const safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + externalMemoryRDMA = copy_src->externalMemoryRDMA; + pNext = SafePnextCopy(copy_src->pNext); +} +#ifdef VK_USE_PLATFORM_SCREEN_QNX + +safe_VkScreenSurfaceCreateInfoQNX::safe_VkScreenSurfaceCreateInfoQNX(const VkScreenSurfaceCreateInfoQNX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), context(nullptr), window(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->context) { + context = new _screen_context(*in_struct->context); + } + + if (in_struct->window) { + window = new _screen_window(*in_struct->window); + } +} + +safe_VkScreenSurfaceCreateInfoQNX::safe_VkScreenSurfaceCreateInfoQNX() + : sType(VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX), pNext(nullptr), flags(), context(nullptr), window(nullptr) {} + +safe_VkScreenSurfaceCreateInfoQNX::safe_VkScreenSurfaceCreateInfoQNX(const safe_VkScreenSurfaceCreateInfoQNX& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + context = nullptr; + window = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.context) { + context = new _screen_context(*copy_src.context); + } + + if (copy_src.window) { + window = new _screen_window(*copy_src.window); + } +} + +safe_VkScreenSurfaceCreateInfoQNX& safe_VkScreenSurfaceCreateInfoQNX::operator=(const safe_VkScreenSurfaceCreateInfoQNX& copy_src) { + if (©_src == this) return *this; + + if (context) delete context; + if (window) delete window; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + context = nullptr; + window = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.context) { + context = new _screen_context(*copy_src.context); + } + + if (copy_src.window) { + window = new _screen_window(*copy_src.window); + } + + return *this; +} + +safe_VkScreenSurfaceCreateInfoQNX::~safe_VkScreenSurfaceCreateInfoQNX() { + if (context) delete context; + if (window) delete window; + FreePnextChain(pNext); +} + +void safe_VkScreenSurfaceCreateInfoQNX::initialize(const VkScreenSurfaceCreateInfoQNX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (context) delete context; + if (window) delete window; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + context = nullptr; + window = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->context) { + context = new _screen_context(*in_struct->context); + } + + if (in_struct->window) { + window = new _screen_window(*in_struct->window); + } +} + +void safe_VkScreenSurfaceCreateInfoQNX::initialize(const safe_VkScreenSurfaceCreateInfoQNX* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + context = nullptr; + window = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->context) { + context = new _screen_context(*copy_src->context); + } + + if (copy_src->window) { + window = new _screen_window(*copy_src->window); + } +} +#endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_ENABLE_BETA_EXTENSIONS + +safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV::safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV( + const VkPhysicalDeviceDisplacementMicromapFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), displacementMicromap(in_struct->displacementMicromap) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV::safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV), pNext(nullptr), displacementMicromap() {} + +safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV::safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV( + const safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV& copy_src) { + sType = copy_src.sType; + displacementMicromap = copy_src.displacementMicromap; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV& safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV::operator=( + const safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + displacementMicromap = copy_src.displacementMicromap; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV::~safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV::initialize( + const VkPhysicalDeviceDisplacementMicromapFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + displacementMicromap = in_struct->displacementMicromap; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV::initialize( + const safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + displacementMicromap = copy_src->displacementMicromap; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV::safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV( + const VkPhysicalDeviceDisplacementMicromapPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), maxDisplacementMicromapSubdivisionLevel(in_struct->maxDisplacementMicromapSubdivisionLevel) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV::safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV), + pNext(nullptr), + maxDisplacementMicromapSubdivisionLevel() {} + +safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV::safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV( + const safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV& copy_src) { + sType = copy_src.sType; + maxDisplacementMicromapSubdivisionLevel = copy_src.maxDisplacementMicromapSubdivisionLevel; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV& safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV::operator=( + const safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxDisplacementMicromapSubdivisionLevel = copy_src.maxDisplacementMicromapSubdivisionLevel; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV::~safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV::initialize( + const VkPhysicalDeviceDisplacementMicromapPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxDisplacementMicromapSubdivisionLevel = in_struct->maxDisplacementMicromapSubdivisionLevel; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV::initialize( + const safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxDisplacementMicromapSubdivisionLevel = copy_src->maxDisplacementMicromapSubdivisionLevel; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_ENABLE_BETA_EXTENSIONS + +safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI::safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI( + const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + clustercullingShader(in_struct->clustercullingShader), + multiviewClusterCullingShader(in_struct->multiviewClusterCullingShader) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI::safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI), + pNext(nullptr), + clustercullingShader(), + multiviewClusterCullingShader() {} + +safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI::safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI( + const safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI& copy_src) { + sType = copy_src.sType; + clustercullingShader = copy_src.clustercullingShader; + multiviewClusterCullingShader = copy_src.multiviewClusterCullingShader; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI& safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI::operator=( + const safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + clustercullingShader = copy_src.clustercullingShader; + multiviewClusterCullingShader = copy_src.multiviewClusterCullingShader; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI::~safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI::initialize( + const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + clustercullingShader = in_struct->clustercullingShader; + multiviewClusterCullingShader = in_struct->multiviewClusterCullingShader; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI::initialize( + const safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + clustercullingShader = copy_src->clustercullingShader; + multiviewClusterCullingShader = copy_src->multiviewClusterCullingShader; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI::safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI( + const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + maxOutputClusterCount(in_struct->maxOutputClusterCount), + indirectBufferOffsetAlignment(in_struct->indirectBufferOffsetAlignment) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + for (uint32_t i = 0; i < 3; ++i) { + maxWorkGroupCount[i] = in_struct->maxWorkGroupCount[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxWorkGroupSize[i] = in_struct->maxWorkGroupSize[i]; + } +} + +safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI::safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI), + pNext(nullptr), + maxOutputClusterCount(), + indirectBufferOffsetAlignment() {} + +safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI::safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI( + const safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI& copy_src) { + sType = copy_src.sType; + maxOutputClusterCount = copy_src.maxOutputClusterCount; + indirectBufferOffsetAlignment = copy_src.indirectBufferOffsetAlignment; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < 3; ++i) { + maxWorkGroupCount[i] = copy_src.maxWorkGroupCount[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxWorkGroupSize[i] = copy_src.maxWorkGroupSize[i]; + } +} + +safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI& safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI::operator=( + const safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxOutputClusterCount = copy_src.maxOutputClusterCount; + indirectBufferOffsetAlignment = copy_src.indirectBufferOffsetAlignment; + pNext = SafePnextCopy(copy_src.pNext); + + for (uint32_t i = 0; i < 3; ++i) { + maxWorkGroupCount[i] = copy_src.maxWorkGroupCount[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxWorkGroupSize[i] = copy_src.maxWorkGroupSize[i]; + } + + return *this; +} + +safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI::~safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI::initialize( + const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxOutputClusterCount = in_struct->maxOutputClusterCount; + indirectBufferOffsetAlignment = in_struct->indirectBufferOffsetAlignment; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + for (uint32_t i = 0; i < 3; ++i) { + maxWorkGroupCount[i] = in_struct->maxWorkGroupCount[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxWorkGroupSize[i] = in_struct->maxWorkGroupSize[i]; + } +} + +void safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI::initialize( + const safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxOutputClusterCount = copy_src->maxOutputClusterCount; + indirectBufferOffsetAlignment = copy_src->indirectBufferOffsetAlignment; + pNext = SafePnextCopy(copy_src->pNext); + + for (uint32_t i = 0; i < 3; ++i) { + maxWorkGroupCount[i] = copy_src->maxWorkGroupCount[i]; + } + + for (uint32_t i = 0; i < 3; ++i) { + maxWorkGroupSize[i] = copy_src->maxWorkGroupSize[i]; + } +} + +safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI( + const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), clusterShadingRate(in_struct->clusterShadingRate) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI), pNext(nullptr), clusterShadingRate() {} + +safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI( + const safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& copy_src) { + sType = copy_src.sType; + clusterShadingRate = copy_src.clusterShadingRate; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::operator=( + const safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + clusterShadingRate = copy_src.clusterShadingRate; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::~safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::initialize( + const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + clusterShadingRate = in_struct->clusterShadingRate; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::initialize( + const safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + clusterShadingRate = copy_src->clusterShadingRate; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderCorePropertiesARM::safe_VkPhysicalDeviceShaderCorePropertiesARM( + const VkPhysicalDeviceShaderCorePropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pixelRate(in_struct->pixelRate), texelRate(in_struct->texelRate), fmaRate(in_struct->fmaRate) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderCorePropertiesARM::safe_VkPhysicalDeviceShaderCorePropertiesARM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM), pNext(nullptr), pixelRate(), texelRate(), fmaRate() {} + +safe_VkPhysicalDeviceShaderCorePropertiesARM::safe_VkPhysicalDeviceShaderCorePropertiesARM( + const safe_VkPhysicalDeviceShaderCorePropertiesARM& copy_src) { + sType = copy_src.sType; + pixelRate = copy_src.pixelRate; + texelRate = copy_src.texelRate; + fmaRate = copy_src.fmaRate; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderCorePropertiesARM& safe_VkPhysicalDeviceShaderCorePropertiesARM::operator=( + const safe_VkPhysicalDeviceShaderCorePropertiesARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pixelRate = copy_src.pixelRate; + texelRate = copy_src.texelRate; + fmaRate = copy_src.fmaRate; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderCorePropertiesARM::~safe_VkPhysicalDeviceShaderCorePropertiesARM() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderCorePropertiesARM::initialize(const VkPhysicalDeviceShaderCorePropertiesARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pixelRate = in_struct->pixelRate; + texelRate = in_struct->texelRate; + fmaRate = in_struct->fmaRate; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderCorePropertiesARM::initialize(const safe_VkPhysicalDeviceShaderCorePropertiesARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pixelRate = copy_src->pixelRate; + texelRate = copy_src->texelRate; + fmaRate = copy_src->fmaRate; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDeviceQueueShaderCoreControlCreateInfoARM::safe_VkDeviceQueueShaderCoreControlCreateInfoARM( + const VkDeviceQueueShaderCoreControlCreateInfoARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), shaderCoreCount(in_struct->shaderCoreCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDeviceQueueShaderCoreControlCreateInfoARM::safe_VkDeviceQueueShaderCoreControlCreateInfoARM() + : sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM), pNext(nullptr), shaderCoreCount() {} + +safe_VkDeviceQueueShaderCoreControlCreateInfoARM::safe_VkDeviceQueueShaderCoreControlCreateInfoARM( + const safe_VkDeviceQueueShaderCoreControlCreateInfoARM& copy_src) { + sType = copy_src.sType; + shaderCoreCount = copy_src.shaderCoreCount; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDeviceQueueShaderCoreControlCreateInfoARM& safe_VkDeviceQueueShaderCoreControlCreateInfoARM::operator=( + const safe_VkDeviceQueueShaderCoreControlCreateInfoARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderCoreCount = copy_src.shaderCoreCount; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDeviceQueueShaderCoreControlCreateInfoARM::~safe_VkDeviceQueueShaderCoreControlCreateInfoARM() { FreePnextChain(pNext); } + +void safe_VkDeviceQueueShaderCoreControlCreateInfoARM::initialize(const VkDeviceQueueShaderCoreControlCreateInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderCoreCount = in_struct->shaderCoreCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDeviceQueueShaderCoreControlCreateInfoARM::initialize(const safe_VkDeviceQueueShaderCoreControlCreateInfoARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderCoreCount = copy_src->shaderCoreCount; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceSchedulingControlsFeaturesARM::safe_VkPhysicalDeviceSchedulingControlsFeaturesARM( + const VkPhysicalDeviceSchedulingControlsFeaturesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), schedulingControls(in_struct->schedulingControls) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceSchedulingControlsFeaturesARM::safe_VkPhysicalDeviceSchedulingControlsFeaturesARM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM), pNext(nullptr), schedulingControls() {} + +safe_VkPhysicalDeviceSchedulingControlsFeaturesARM::safe_VkPhysicalDeviceSchedulingControlsFeaturesARM( + const safe_VkPhysicalDeviceSchedulingControlsFeaturesARM& copy_src) { + sType = copy_src.sType; + schedulingControls = copy_src.schedulingControls; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceSchedulingControlsFeaturesARM& safe_VkPhysicalDeviceSchedulingControlsFeaturesARM::operator=( + const safe_VkPhysicalDeviceSchedulingControlsFeaturesARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + schedulingControls = copy_src.schedulingControls; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceSchedulingControlsFeaturesARM::~safe_VkPhysicalDeviceSchedulingControlsFeaturesARM() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceSchedulingControlsFeaturesARM::initialize(const VkPhysicalDeviceSchedulingControlsFeaturesARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + schedulingControls = in_struct->schedulingControls; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceSchedulingControlsFeaturesARM::initialize( + const safe_VkPhysicalDeviceSchedulingControlsFeaturesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + schedulingControls = copy_src->schedulingControls; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceSchedulingControlsPropertiesARM::safe_VkPhysicalDeviceSchedulingControlsPropertiesARM( + const VkPhysicalDeviceSchedulingControlsPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), schedulingControlsFlags(in_struct->schedulingControlsFlags) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceSchedulingControlsPropertiesARM::safe_VkPhysicalDeviceSchedulingControlsPropertiesARM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM), pNext(nullptr), schedulingControlsFlags() {} + +safe_VkPhysicalDeviceSchedulingControlsPropertiesARM::safe_VkPhysicalDeviceSchedulingControlsPropertiesARM( + const safe_VkPhysicalDeviceSchedulingControlsPropertiesARM& copy_src) { + sType = copy_src.sType; + schedulingControlsFlags = copy_src.schedulingControlsFlags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceSchedulingControlsPropertiesARM& safe_VkPhysicalDeviceSchedulingControlsPropertiesARM::operator=( + const safe_VkPhysicalDeviceSchedulingControlsPropertiesARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + schedulingControlsFlags = copy_src.schedulingControlsFlags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceSchedulingControlsPropertiesARM::~safe_VkPhysicalDeviceSchedulingControlsPropertiesARM() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceSchedulingControlsPropertiesARM::initialize( + const VkPhysicalDeviceSchedulingControlsPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + schedulingControlsFlags = in_struct->schedulingControlsFlags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceSchedulingControlsPropertiesARM::initialize( + const safe_VkPhysicalDeviceSchedulingControlsPropertiesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + schedulingControlsFlags = copy_src->schedulingControlsFlags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE( + const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), descriptorSetHostMapping(in_struct->descriptorSetHostMapping) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE), + pNext(nullptr), + descriptorSetHostMapping() {} + +safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE( + const safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& copy_src) { + sType = copy_src.sType; + descriptorSetHostMapping = copy_src.descriptorSetHostMapping; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::operator=( + const safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + descriptorSetHostMapping = copy_src.descriptorSetHostMapping; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::~safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::initialize( + const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + descriptorSetHostMapping = in_struct->descriptorSetHostMapping; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::initialize( + const safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + descriptorSetHostMapping = copy_src->descriptorSetHostMapping; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDescriptorSetBindingReferenceVALVE::safe_VkDescriptorSetBindingReferenceVALVE( + const VkDescriptorSetBindingReferenceVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), descriptorSetLayout(in_struct->descriptorSetLayout), binding(in_struct->binding) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDescriptorSetBindingReferenceVALVE::safe_VkDescriptorSetBindingReferenceVALVE() + : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE), pNext(nullptr), descriptorSetLayout(), binding() {} + +safe_VkDescriptorSetBindingReferenceVALVE::safe_VkDescriptorSetBindingReferenceVALVE( + const safe_VkDescriptorSetBindingReferenceVALVE& copy_src) { + sType = copy_src.sType; + descriptorSetLayout = copy_src.descriptorSetLayout; + binding = copy_src.binding; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDescriptorSetBindingReferenceVALVE& safe_VkDescriptorSetBindingReferenceVALVE::operator=( + const safe_VkDescriptorSetBindingReferenceVALVE& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + descriptorSetLayout = copy_src.descriptorSetLayout; + binding = copy_src.binding; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDescriptorSetBindingReferenceVALVE::~safe_VkDescriptorSetBindingReferenceVALVE() { FreePnextChain(pNext); } + +void safe_VkDescriptorSetBindingReferenceVALVE::initialize(const VkDescriptorSetBindingReferenceVALVE* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + descriptorSetLayout = in_struct->descriptorSetLayout; + binding = in_struct->binding; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDescriptorSetBindingReferenceVALVE::initialize(const safe_VkDescriptorSetBindingReferenceVALVE* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + descriptorSetLayout = copy_src->descriptorSetLayout; + binding = copy_src->binding; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDescriptorSetLayoutHostMappingInfoVALVE::safe_VkDescriptorSetLayoutHostMappingInfoVALVE( + const VkDescriptorSetLayoutHostMappingInfoVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), descriptorOffset(in_struct->descriptorOffset), descriptorSize(in_struct->descriptorSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDescriptorSetLayoutHostMappingInfoVALVE::safe_VkDescriptorSetLayoutHostMappingInfoVALVE() + : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE), + pNext(nullptr), + descriptorOffset(), + descriptorSize() {} + +safe_VkDescriptorSetLayoutHostMappingInfoVALVE::safe_VkDescriptorSetLayoutHostMappingInfoVALVE( + const safe_VkDescriptorSetLayoutHostMappingInfoVALVE& copy_src) { + sType = copy_src.sType; + descriptorOffset = copy_src.descriptorOffset; + descriptorSize = copy_src.descriptorSize; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDescriptorSetLayoutHostMappingInfoVALVE& safe_VkDescriptorSetLayoutHostMappingInfoVALVE::operator=( + const safe_VkDescriptorSetLayoutHostMappingInfoVALVE& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + descriptorOffset = copy_src.descriptorOffset; + descriptorSize = copy_src.descriptorSize; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDescriptorSetLayoutHostMappingInfoVALVE::~safe_VkDescriptorSetLayoutHostMappingInfoVALVE() { FreePnextChain(pNext); } + +void safe_VkDescriptorSetLayoutHostMappingInfoVALVE::initialize(const VkDescriptorSetLayoutHostMappingInfoVALVE* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + descriptorOffset = in_struct->descriptorOffset; + descriptorSize = in_struct->descriptorSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDescriptorSetLayoutHostMappingInfoVALVE::initialize(const safe_VkDescriptorSetLayoutHostMappingInfoVALVE* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + descriptorOffset = copy_src->descriptorOffset; + descriptorSize = copy_src->descriptorSize; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceRenderPassStripedFeaturesARM::safe_VkPhysicalDeviceRenderPassStripedFeaturesARM( + const VkPhysicalDeviceRenderPassStripedFeaturesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), renderPassStriped(in_struct->renderPassStriped) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceRenderPassStripedFeaturesARM::safe_VkPhysicalDeviceRenderPassStripedFeaturesARM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM), pNext(nullptr), renderPassStriped() {} + +safe_VkPhysicalDeviceRenderPassStripedFeaturesARM::safe_VkPhysicalDeviceRenderPassStripedFeaturesARM( + const safe_VkPhysicalDeviceRenderPassStripedFeaturesARM& copy_src) { + sType = copy_src.sType; + renderPassStriped = copy_src.renderPassStriped; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceRenderPassStripedFeaturesARM& safe_VkPhysicalDeviceRenderPassStripedFeaturesARM::operator=( + const safe_VkPhysicalDeviceRenderPassStripedFeaturesARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + renderPassStriped = copy_src.renderPassStriped; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceRenderPassStripedFeaturesARM::~safe_VkPhysicalDeviceRenderPassStripedFeaturesARM() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceRenderPassStripedFeaturesARM::initialize(const VkPhysicalDeviceRenderPassStripedFeaturesARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + renderPassStriped = in_struct->renderPassStriped; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceRenderPassStripedFeaturesARM::initialize( + const safe_VkPhysicalDeviceRenderPassStripedFeaturesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + renderPassStriped = copy_src->renderPassStriped; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceRenderPassStripedPropertiesARM::safe_VkPhysicalDeviceRenderPassStripedPropertiesARM( + const VkPhysicalDeviceRenderPassStripedPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + renderPassStripeGranularity(in_struct->renderPassStripeGranularity), + maxRenderPassStripes(in_struct->maxRenderPassStripes) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceRenderPassStripedPropertiesARM::safe_VkPhysicalDeviceRenderPassStripedPropertiesARM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM), + pNext(nullptr), + renderPassStripeGranularity(), + maxRenderPassStripes() {} + +safe_VkPhysicalDeviceRenderPassStripedPropertiesARM::safe_VkPhysicalDeviceRenderPassStripedPropertiesARM( + const safe_VkPhysicalDeviceRenderPassStripedPropertiesARM& copy_src) { + sType = copy_src.sType; + renderPassStripeGranularity = copy_src.renderPassStripeGranularity; + maxRenderPassStripes = copy_src.maxRenderPassStripes; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceRenderPassStripedPropertiesARM& safe_VkPhysicalDeviceRenderPassStripedPropertiesARM::operator=( + const safe_VkPhysicalDeviceRenderPassStripedPropertiesARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + renderPassStripeGranularity = copy_src.renderPassStripeGranularity; + maxRenderPassStripes = copy_src.maxRenderPassStripes; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceRenderPassStripedPropertiesARM::~safe_VkPhysicalDeviceRenderPassStripedPropertiesARM() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceRenderPassStripedPropertiesARM::initialize( + const VkPhysicalDeviceRenderPassStripedPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + renderPassStripeGranularity = in_struct->renderPassStripeGranularity; + maxRenderPassStripes = in_struct->maxRenderPassStripes; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceRenderPassStripedPropertiesARM::initialize( + const safe_VkPhysicalDeviceRenderPassStripedPropertiesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + renderPassStripeGranularity = copy_src->renderPassStripeGranularity; + maxRenderPassStripes = copy_src->maxRenderPassStripes; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkRenderPassStripeInfoARM::safe_VkRenderPassStripeInfoARM(const VkRenderPassStripeInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), stripeArea(in_struct->stripeArea) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkRenderPassStripeInfoARM::safe_VkRenderPassStripeInfoARM() + : sType(VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM), pNext(nullptr), stripeArea() {} + +safe_VkRenderPassStripeInfoARM::safe_VkRenderPassStripeInfoARM(const safe_VkRenderPassStripeInfoARM& copy_src) { + sType = copy_src.sType; + stripeArea = copy_src.stripeArea; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkRenderPassStripeInfoARM& safe_VkRenderPassStripeInfoARM::operator=(const safe_VkRenderPassStripeInfoARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + stripeArea = copy_src.stripeArea; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkRenderPassStripeInfoARM::~safe_VkRenderPassStripeInfoARM() { FreePnextChain(pNext); } + +void safe_VkRenderPassStripeInfoARM::initialize(const VkRenderPassStripeInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + stripeArea = in_struct->stripeArea; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkRenderPassStripeInfoARM::initialize(const safe_VkRenderPassStripeInfoARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stripeArea = copy_src->stripeArea; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkRenderPassStripeBeginInfoARM::safe_VkRenderPassStripeBeginInfoARM(const VkRenderPassStripeBeginInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), stripeInfoCount(in_struct->stripeInfoCount), pStripeInfos(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (stripeInfoCount && in_struct->pStripeInfos) { + pStripeInfos = new safe_VkRenderPassStripeInfoARM[stripeInfoCount]; + for (uint32_t i = 0; i < stripeInfoCount; ++i) { + pStripeInfos[i].initialize(&in_struct->pStripeInfos[i]); + } + } +} + +safe_VkRenderPassStripeBeginInfoARM::safe_VkRenderPassStripeBeginInfoARM() + : sType(VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM), pNext(nullptr), stripeInfoCount(), pStripeInfos(nullptr) {} + +safe_VkRenderPassStripeBeginInfoARM::safe_VkRenderPassStripeBeginInfoARM(const safe_VkRenderPassStripeBeginInfoARM& copy_src) { + sType = copy_src.sType; + stripeInfoCount = copy_src.stripeInfoCount; + pStripeInfos = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (stripeInfoCount && copy_src.pStripeInfos) { + pStripeInfos = new safe_VkRenderPassStripeInfoARM[stripeInfoCount]; + for (uint32_t i = 0; i < stripeInfoCount; ++i) { + pStripeInfos[i].initialize(©_src.pStripeInfos[i]); + } + } +} + +safe_VkRenderPassStripeBeginInfoARM& safe_VkRenderPassStripeBeginInfoARM::operator=( + const safe_VkRenderPassStripeBeginInfoARM& copy_src) { + if (©_src == this) return *this; + + if (pStripeInfos) delete[] pStripeInfos; + FreePnextChain(pNext); + + sType = copy_src.sType; + stripeInfoCount = copy_src.stripeInfoCount; + pStripeInfos = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (stripeInfoCount && copy_src.pStripeInfos) { + pStripeInfos = new safe_VkRenderPassStripeInfoARM[stripeInfoCount]; + for (uint32_t i = 0; i < stripeInfoCount; ++i) { + pStripeInfos[i].initialize(©_src.pStripeInfos[i]); + } + } + + return *this; +} + +safe_VkRenderPassStripeBeginInfoARM::~safe_VkRenderPassStripeBeginInfoARM() { + if (pStripeInfos) delete[] pStripeInfos; + FreePnextChain(pNext); +} + +void safe_VkRenderPassStripeBeginInfoARM::initialize(const VkRenderPassStripeBeginInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStripeInfos) delete[] pStripeInfos; + FreePnextChain(pNext); + sType = in_struct->sType; + stripeInfoCount = in_struct->stripeInfoCount; + pStripeInfos = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (stripeInfoCount && in_struct->pStripeInfos) { + pStripeInfos = new safe_VkRenderPassStripeInfoARM[stripeInfoCount]; + for (uint32_t i = 0; i < stripeInfoCount; ++i) { + pStripeInfos[i].initialize(&in_struct->pStripeInfos[i]); + } + } +} + +void safe_VkRenderPassStripeBeginInfoARM::initialize(const safe_VkRenderPassStripeBeginInfoARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stripeInfoCount = copy_src->stripeInfoCount; + pStripeInfos = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (stripeInfoCount && copy_src->pStripeInfos) { + pStripeInfos = new safe_VkRenderPassStripeInfoARM[stripeInfoCount]; + for (uint32_t i = 0; i < stripeInfoCount; ++i) { + pStripeInfos[i].initialize(©_src->pStripeInfos[i]); + } + } +} + +safe_VkRenderPassStripeSubmitInfoARM::safe_VkRenderPassStripeSubmitInfoARM(const VkRenderPassStripeSubmitInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), stripeSemaphoreInfoCount(in_struct->stripeSemaphoreInfoCount), pStripeSemaphoreInfos(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (stripeSemaphoreInfoCount && in_struct->pStripeSemaphoreInfos) { + pStripeSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[stripeSemaphoreInfoCount]; + for (uint32_t i = 0; i < stripeSemaphoreInfoCount; ++i) { + pStripeSemaphoreInfos[i].initialize(&in_struct->pStripeSemaphoreInfos[i]); + } + } +} + +safe_VkRenderPassStripeSubmitInfoARM::safe_VkRenderPassStripeSubmitInfoARM() + : sType(VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM), + pNext(nullptr), + stripeSemaphoreInfoCount(), + pStripeSemaphoreInfos(nullptr) {} + +safe_VkRenderPassStripeSubmitInfoARM::safe_VkRenderPassStripeSubmitInfoARM(const safe_VkRenderPassStripeSubmitInfoARM& copy_src) { + sType = copy_src.sType; + stripeSemaphoreInfoCount = copy_src.stripeSemaphoreInfoCount; + pStripeSemaphoreInfos = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (stripeSemaphoreInfoCount && copy_src.pStripeSemaphoreInfos) { + pStripeSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[stripeSemaphoreInfoCount]; + for (uint32_t i = 0; i < stripeSemaphoreInfoCount; ++i) { + pStripeSemaphoreInfos[i].initialize(©_src.pStripeSemaphoreInfos[i]); + } + } +} + +safe_VkRenderPassStripeSubmitInfoARM& safe_VkRenderPassStripeSubmitInfoARM::operator=( + const safe_VkRenderPassStripeSubmitInfoARM& copy_src) { + if (©_src == this) return *this; + + if (pStripeSemaphoreInfos) delete[] pStripeSemaphoreInfos; + FreePnextChain(pNext); + + sType = copy_src.sType; + stripeSemaphoreInfoCount = copy_src.stripeSemaphoreInfoCount; + pStripeSemaphoreInfos = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (stripeSemaphoreInfoCount && copy_src.pStripeSemaphoreInfos) { + pStripeSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[stripeSemaphoreInfoCount]; + for (uint32_t i = 0; i < stripeSemaphoreInfoCount; ++i) { + pStripeSemaphoreInfos[i].initialize(©_src.pStripeSemaphoreInfos[i]); + } + } + + return *this; +} + +safe_VkRenderPassStripeSubmitInfoARM::~safe_VkRenderPassStripeSubmitInfoARM() { + if (pStripeSemaphoreInfos) delete[] pStripeSemaphoreInfos; + FreePnextChain(pNext); +} + +void safe_VkRenderPassStripeSubmitInfoARM::initialize(const VkRenderPassStripeSubmitInfoARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pStripeSemaphoreInfos) delete[] pStripeSemaphoreInfos; + FreePnextChain(pNext); + sType = in_struct->sType; + stripeSemaphoreInfoCount = in_struct->stripeSemaphoreInfoCount; + pStripeSemaphoreInfos = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (stripeSemaphoreInfoCount && in_struct->pStripeSemaphoreInfos) { + pStripeSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[stripeSemaphoreInfoCount]; + for (uint32_t i = 0; i < stripeSemaphoreInfoCount; ++i) { + pStripeSemaphoreInfos[i].initialize(&in_struct->pStripeSemaphoreInfos[i]); + } + } +} + +void safe_VkRenderPassStripeSubmitInfoARM::initialize(const safe_VkRenderPassStripeSubmitInfoARM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + stripeSemaphoreInfoCount = copy_src->stripeSemaphoreInfoCount; + pStripeSemaphoreInfos = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (stripeSemaphoreInfoCount && copy_src->pStripeSemaphoreInfos) { + pStripeSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[stripeSemaphoreInfoCount]; + for (uint32_t i = 0; i < stripeSemaphoreInfoCount; ++i) { + pStripeSemaphoreInfos[i].initialize(©_src->pStripeSemaphoreInfos[i]); + } + } +} + +safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM( + const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), fragmentDensityMapOffset(in_struct->fragmentDensityMapOffset) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM), + pNext(nullptr), + fragmentDensityMapOffset() {} + +safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM( + const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& copy_src) { + sType = copy_src.sType; + fragmentDensityMapOffset = copy_src.fragmentDensityMapOffset; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::operator=( + const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + fragmentDensityMapOffset = copy_src.fragmentDensityMapOffset; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::~safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::initialize( + const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + fragmentDensityMapOffset = in_struct->fragmentDensityMapOffset; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::initialize( + const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + fragmentDensityMapOffset = copy_src->fragmentDensityMapOffset; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM( + const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), fragmentDensityOffsetGranularity(in_struct->fragmentDensityOffsetGranularity) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM), + pNext(nullptr), + fragmentDensityOffsetGranularity() {} + +safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM( + const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& copy_src) { + sType = copy_src.sType; + fragmentDensityOffsetGranularity = copy_src.fragmentDensityOffsetGranularity; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::operator=( + const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + fragmentDensityOffsetGranularity = copy_src.fragmentDensityOffsetGranularity; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::~safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::initialize( + const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + fragmentDensityOffsetGranularity = in_struct->fragmentDensityOffsetGranularity; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::initialize( + const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + fragmentDensityOffsetGranularity = copy_src->fragmentDensityOffsetGranularity; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM( + const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), fragmentDensityOffsetCount(in_struct->fragmentDensityOffsetCount), pFragmentDensityOffsets(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pFragmentDensityOffsets) { + pFragmentDensityOffsets = new VkOffset2D[in_struct->fragmentDensityOffsetCount]; + memcpy((void*)pFragmentDensityOffsets, (void*)in_struct->pFragmentDensityOffsets, + sizeof(VkOffset2D) * in_struct->fragmentDensityOffsetCount); + } +} + +safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM() + : sType(VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM), + pNext(nullptr), + fragmentDensityOffsetCount(), + pFragmentDensityOffsets(nullptr) {} + +safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM( + const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM& copy_src) { + sType = copy_src.sType; + fragmentDensityOffsetCount = copy_src.fragmentDensityOffsetCount; + pFragmentDensityOffsets = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pFragmentDensityOffsets) { + pFragmentDensityOffsets = new VkOffset2D[copy_src.fragmentDensityOffsetCount]; + memcpy((void*)pFragmentDensityOffsets, (void*)copy_src.pFragmentDensityOffsets, + sizeof(VkOffset2D) * copy_src.fragmentDensityOffsetCount); + } +} + +safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM& safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::operator=( + const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM& copy_src) { + if (©_src == this) return *this; + + if (pFragmentDensityOffsets) delete[] pFragmentDensityOffsets; + FreePnextChain(pNext); + + sType = copy_src.sType; + fragmentDensityOffsetCount = copy_src.fragmentDensityOffsetCount; + pFragmentDensityOffsets = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pFragmentDensityOffsets) { + pFragmentDensityOffsets = new VkOffset2D[copy_src.fragmentDensityOffsetCount]; + memcpy((void*)pFragmentDensityOffsets, (void*)copy_src.pFragmentDensityOffsets, + sizeof(VkOffset2D) * copy_src.fragmentDensityOffsetCount); + } + + return *this; +} + +safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::~safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM() { + if (pFragmentDensityOffsets) delete[] pFragmentDensityOffsets; + FreePnextChain(pNext); +} + +void safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::initialize(const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pFragmentDensityOffsets) delete[] pFragmentDensityOffsets; + FreePnextChain(pNext); + sType = in_struct->sType; + fragmentDensityOffsetCount = in_struct->fragmentDensityOffsetCount; + pFragmentDensityOffsets = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pFragmentDensityOffsets) { + pFragmentDensityOffsets = new VkOffset2D[in_struct->fragmentDensityOffsetCount]; + memcpy((void*)pFragmentDensityOffsets, (void*)in_struct->pFragmentDensityOffsets, + sizeof(VkOffset2D) * in_struct->fragmentDensityOffsetCount); + } +} + +void safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::initialize( + const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + fragmentDensityOffsetCount = copy_src->fragmentDensityOffsetCount; + pFragmentDensityOffsets = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pFragmentDensityOffsets) { + pFragmentDensityOffsets = new VkOffset2D[copy_src->fragmentDensityOffsetCount]; + memcpy((void*)pFragmentDensityOffsets, (void*)copy_src->pFragmentDensityOffsets, + sizeof(VkOffset2D) * copy_src->fragmentDensityOffsetCount); + } +} + +safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV::safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV( + const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), indirectCopy(in_struct->indirectCopy) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV::safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV), pNext(nullptr), indirectCopy() {} + +safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV::safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV( + const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV& copy_src) { + sType = copy_src.sType; + indirectCopy = copy_src.indirectCopy; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV& safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV::operator=( + const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + indirectCopy = copy_src.indirectCopy; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV::~safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV::initialize(const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + indirectCopy = in_struct->indirectCopy; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV::initialize( + const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + indirectCopy = copy_src->indirectCopy; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV( + const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), supportedQueues(in_struct->supportedQueues) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV), pNext(nullptr), supportedQueues() {} + +safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV( + const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV& copy_src) { + sType = copy_src.sType; + supportedQueues = copy_src.supportedQueues; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV& safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::operator=( + const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + supportedQueues = copy_src.supportedQueues; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::~safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::initialize( + const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + supportedQueues = in_struct->supportedQueues; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::initialize( + const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + supportedQueues = copy_src->supportedQueues; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV::safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV( + const VkPhysicalDeviceMemoryDecompressionFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), memoryDecompression(in_struct->memoryDecompression) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV::safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV), pNext(nullptr), memoryDecompression() {} + +safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV::safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV( + const safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV& copy_src) { + sType = copy_src.sType; + memoryDecompression = copy_src.memoryDecompression; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV& safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV::operator=( + const safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + memoryDecompression = copy_src.memoryDecompression; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV::~safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV::initialize(const VkPhysicalDeviceMemoryDecompressionFeaturesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + memoryDecompression = in_struct->memoryDecompression; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV::initialize( + const safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + memoryDecompression = copy_src->memoryDecompression; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV::safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV( + const VkPhysicalDeviceMemoryDecompressionPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + decompressionMethods(in_struct->decompressionMethods), + maxDecompressionIndirectCount(in_struct->maxDecompressionIndirectCount) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV::safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV), + pNext(nullptr), + decompressionMethods(), + maxDecompressionIndirectCount() {} + +safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV::safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV( + const safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV& copy_src) { + sType = copy_src.sType; + decompressionMethods = copy_src.decompressionMethods; + maxDecompressionIndirectCount = copy_src.maxDecompressionIndirectCount; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV& safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV::operator=( + const safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + decompressionMethods = copy_src.decompressionMethods; + maxDecompressionIndirectCount = copy_src.maxDecompressionIndirectCount; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV::~safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV::initialize( + const VkPhysicalDeviceMemoryDecompressionPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + decompressionMethods = in_struct->decompressionMethods; + maxDecompressionIndirectCount = in_struct->maxDecompressionIndirectCount; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV::initialize( + const safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + decompressionMethods = copy_src->decompressionMethods; + maxDecompressionIndirectCount = copy_src->maxDecompressionIndirectCount; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV( + const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + deviceGeneratedCompute(in_struct->deviceGeneratedCompute), + deviceGeneratedComputePipelines(in_struct->deviceGeneratedComputePipelines), + deviceGeneratedComputeCaptureReplay(in_struct->deviceGeneratedComputeCaptureReplay) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV), + pNext(nullptr), + deviceGeneratedCompute(), + deviceGeneratedComputePipelines(), + deviceGeneratedComputeCaptureReplay() {} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& copy_src) { + sType = copy_src.sType; + deviceGeneratedCompute = copy_src.deviceGeneratedCompute; + deviceGeneratedComputePipelines = copy_src.deviceGeneratedComputePipelines; + deviceGeneratedComputeCaptureReplay = copy_src.deviceGeneratedComputeCaptureReplay; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& +safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::operator=( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + deviceGeneratedCompute = copy_src.deviceGeneratedCompute; + deviceGeneratedComputePipelines = copy_src.deviceGeneratedComputePipelines; + deviceGeneratedComputeCaptureReplay = copy_src.deviceGeneratedComputeCaptureReplay; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::~safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::initialize( + const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + deviceGeneratedCompute = in_struct->deviceGeneratedCompute; + deviceGeneratedComputePipelines = in_struct->deviceGeneratedComputePipelines; + deviceGeneratedComputeCaptureReplay = in_struct->deviceGeneratedComputeCaptureReplay; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::initialize( + const safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + deviceGeneratedCompute = copy_src->deviceGeneratedCompute; + deviceGeneratedComputePipelines = copy_src->deviceGeneratedComputePipelines; + deviceGeneratedComputeCaptureReplay = copy_src->deviceGeneratedComputeCaptureReplay; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkComputePipelineIndirectBufferInfoNV::safe_VkComputePipelineIndirectBufferInfoNV( + const VkComputePipelineIndirectBufferInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + deviceAddress(in_struct->deviceAddress), + size(in_struct->size), + pipelineDeviceAddressCaptureReplay(in_struct->pipelineDeviceAddressCaptureReplay) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkComputePipelineIndirectBufferInfoNV::safe_VkComputePipelineIndirectBufferInfoNV() + : sType(VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV), + pNext(nullptr), + deviceAddress(), + size(), + pipelineDeviceAddressCaptureReplay() {} + +safe_VkComputePipelineIndirectBufferInfoNV::safe_VkComputePipelineIndirectBufferInfoNV( + const safe_VkComputePipelineIndirectBufferInfoNV& copy_src) { + sType = copy_src.sType; + deviceAddress = copy_src.deviceAddress; + size = copy_src.size; + pipelineDeviceAddressCaptureReplay = copy_src.pipelineDeviceAddressCaptureReplay; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkComputePipelineIndirectBufferInfoNV& safe_VkComputePipelineIndirectBufferInfoNV::operator=( + const safe_VkComputePipelineIndirectBufferInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + deviceAddress = copy_src.deviceAddress; + size = copy_src.size; + pipelineDeviceAddressCaptureReplay = copy_src.pipelineDeviceAddressCaptureReplay; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkComputePipelineIndirectBufferInfoNV::~safe_VkComputePipelineIndirectBufferInfoNV() { FreePnextChain(pNext); } + +void safe_VkComputePipelineIndirectBufferInfoNV::initialize(const VkComputePipelineIndirectBufferInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + deviceAddress = in_struct->deviceAddress; + size = in_struct->size; + pipelineDeviceAddressCaptureReplay = in_struct->pipelineDeviceAddressCaptureReplay; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkComputePipelineIndirectBufferInfoNV::initialize(const safe_VkComputePipelineIndirectBufferInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + deviceAddress = copy_src->deviceAddress; + size = copy_src->size; + pipelineDeviceAddressCaptureReplay = copy_src->pipelineDeviceAddressCaptureReplay; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPipelineIndirectDeviceAddressInfoNV::safe_VkPipelineIndirectDeviceAddressInfoNV( + const VkPipelineIndirectDeviceAddressInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), pipelineBindPoint(in_struct->pipelineBindPoint), pipeline(in_struct->pipeline) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPipelineIndirectDeviceAddressInfoNV::safe_VkPipelineIndirectDeviceAddressInfoNV() + : sType(VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV), pNext(nullptr), pipelineBindPoint(), pipeline() {} + +safe_VkPipelineIndirectDeviceAddressInfoNV::safe_VkPipelineIndirectDeviceAddressInfoNV( + const safe_VkPipelineIndirectDeviceAddressInfoNV& copy_src) { + sType = copy_src.sType; + pipelineBindPoint = copy_src.pipelineBindPoint; + pipeline = copy_src.pipeline; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPipelineIndirectDeviceAddressInfoNV& safe_VkPipelineIndirectDeviceAddressInfoNV::operator=( + const safe_VkPipelineIndirectDeviceAddressInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + pipelineBindPoint = copy_src.pipelineBindPoint; + pipeline = copy_src.pipeline; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPipelineIndirectDeviceAddressInfoNV::~safe_VkPipelineIndirectDeviceAddressInfoNV() { FreePnextChain(pNext); } + +void safe_VkPipelineIndirectDeviceAddressInfoNV::initialize(const VkPipelineIndirectDeviceAddressInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + pipelineBindPoint = in_struct->pipelineBindPoint; + pipeline = in_struct->pipeline; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPipelineIndirectDeviceAddressInfoNV::initialize(const safe_VkPipelineIndirectDeviceAddressInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + pipelineBindPoint = copy_src->pipelineBindPoint; + pipeline = copy_src->pipeline; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV::safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV( + const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), linearColorAttachment(in_struct->linearColorAttachment) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV::safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV), pNext(nullptr), linearColorAttachment() {} + +safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV::safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV( + const safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV& copy_src) { + sType = copy_src.sType; + linearColorAttachment = copy_src.linearColorAttachment; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV& safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV::operator=( + const safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + linearColorAttachment = copy_src.linearColorAttachment; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV::~safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV::initialize( + const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + linearColorAttachment = in_struct->linearColorAttachment; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV::initialize( + const safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + linearColorAttachment = copy_src->linearColorAttachment; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImageViewSampleWeightCreateInfoQCOM::safe_VkImageViewSampleWeightCreateInfoQCOM( + const VkImageViewSampleWeightCreateInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + filterCenter(in_struct->filterCenter), + filterSize(in_struct->filterSize), + numPhases(in_struct->numPhases) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkImageViewSampleWeightCreateInfoQCOM::safe_VkImageViewSampleWeightCreateInfoQCOM() + : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM), + pNext(nullptr), + filterCenter(), + filterSize(), + numPhases() {} + +safe_VkImageViewSampleWeightCreateInfoQCOM::safe_VkImageViewSampleWeightCreateInfoQCOM( + const safe_VkImageViewSampleWeightCreateInfoQCOM& copy_src) { + sType = copy_src.sType; + filterCenter = copy_src.filterCenter; + filterSize = copy_src.filterSize; + numPhases = copy_src.numPhases; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkImageViewSampleWeightCreateInfoQCOM& safe_VkImageViewSampleWeightCreateInfoQCOM::operator=( + const safe_VkImageViewSampleWeightCreateInfoQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + filterCenter = copy_src.filterCenter; + filterSize = copy_src.filterSize; + numPhases = copy_src.numPhases; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkImageViewSampleWeightCreateInfoQCOM::~safe_VkImageViewSampleWeightCreateInfoQCOM() { FreePnextChain(pNext); } + +void safe_VkImageViewSampleWeightCreateInfoQCOM::initialize(const VkImageViewSampleWeightCreateInfoQCOM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + filterCenter = in_struct->filterCenter; + filterSize = in_struct->filterSize; + numPhases = in_struct->numPhases; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkImageViewSampleWeightCreateInfoQCOM::initialize(const safe_VkImageViewSampleWeightCreateInfoQCOM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + filterCenter = copy_src->filterCenter; + filterSize = copy_src->filterSize; + numPhases = copy_src->numPhases; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceImageProcessingFeaturesQCOM::safe_VkPhysicalDeviceImageProcessingFeaturesQCOM( + const VkPhysicalDeviceImageProcessingFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + textureSampleWeighted(in_struct->textureSampleWeighted), + textureBoxFilter(in_struct->textureBoxFilter), + textureBlockMatch(in_struct->textureBlockMatch) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceImageProcessingFeaturesQCOM::safe_VkPhysicalDeviceImageProcessingFeaturesQCOM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM), + pNext(nullptr), + textureSampleWeighted(), + textureBoxFilter(), + textureBlockMatch() {} + +safe_VkPhysicalDeviceImageProcessingFeaturesQCOM::safe_VkPhysicalDeviceImageProcessingFeaturesQCOM( + const safe_VkPhysicalDeviceImageProcessingFeaturesQCOM& copy_src) { + sType = copy_src.sType; + textureSampleWeighted = copy_src.textureSampleWeighted; + textureBoxFilter = copy_src.textureBoxFilter; + textureBlockMatch = copy_src.textureBlockMatch; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceImageProcessingFeaturesQCOM& safe_VkPhysicalDeviceImageProcessingFeaturesQCOM::operator=( + const safe_VkPhysicalDeviceImageProcessingFeaturesQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + textureSampleWeighted = copy_src.textureSampleWeighted; + textureBoxFilter = copy_src.textureBoxFilter; + textureBlockMatch = copy_src.textureBlockMatch; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceImageProcessingFeaturesQCOM::~safe_VkPhysicalDeviceImageProcessingFeaturesQCOM() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceImageProcessingFeaturesQCOM::initialize(const VkPhysicalDeviceImageProcessingFeaturesQCOM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + textureSampleWeighted = in_struct->textureSampleWeighted; + textureBoxFilter = in_struct->textureBoxFilter; + textureBlockMatch = in_struct->textureBlockMatch; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceImageProcessingFeaturesQCOM::initialize(const safe_VkPhysicalDeviceImageProcessingFeaturesQCOM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + textureSampleWeighted = copy_src->textureSampleWeighted; + textureBoxFilter = copy_src->textureBoxFilter; + textureBlockMatch = copy_src->textureBlockMatch; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceImageProcessingPropertiesQCOM::safe_VkPhysicalDeviceImageProcessingPropertiesQCOM( + const VkPhysicalDeviceImageProcessingPropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + maxWeightFilterPhases(in_struct->maxWeightFilterPhases), + maxWeightFilterDimension(in_struct->maxWeightFilterDimension), + maxBlockMatchRegion(in_struct->maxBlockMatchRegion), + maxBoxFilterBlockSize(in_struct->maxBoxFilterBlockSize) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceImageProcessingPropertiesQCOM::safe_VkPhysicalDeviceImageProcessingPropertiesQCOM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM), + pNext(nullptr), + maxWeightFilterPhases(), + maxWeightFilterDimension(), + maxBlockMatchRegion(), + maxBoxFilterBlockSize() {} + +safe_VkPhysicalDeviceImageProcessingPropertiesQCOM::safe_VkPhysicalDeviceImageProcessingPropertiesQCOM( + const safe_VkPhysicalDeviceImageProcessingPropertiesQCOM& copy_src) { + sType = copy_src.sType; + maxWeightFilterPhases = copy_src.maxWeightFilterPhases; + maxWeightFilterDimension = copy_src.maxWeightFilterDimension; + maxBlockMatchRegion = copy_src.maxBlockMatchRegion; + maxBoxFilterBlockSize = copy_src.maxBoxFilterBlockSize; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceImageProcessingPropertiesQCOM& safe_VkPhysicalDeviceImageProcessingPropertiesQCOM::operator=( + const safe_VkPhysicalDeviceImageProcessingPropertiesQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxWeightFilterPhases = copy_src.maxWeightFilterPhases; + maxWeightFilterDimension = copy_src.maxWeightFilterDimension; + maxBlockMatchRegion = copy_src.maxBlockMatchRegion; + maxBoxFilterBlockSize = copy_src.maxBoxFilterBlockSize; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceImageProcessingPropertiesQCOM::~safe_VkPhysicalDeviceImageProcessingPropertiesQCOM() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceImageProcessingPropertiesQCOM::initialize(const VkPhysicalDeviceImageProcessingPropertiesQCOM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxWeightFilterPhases = in_struct->maxWeightFilterPhases; + maxWeightFilterDimension = in_struct->maxWeightFilterDimension; + maxBlockMatchRegion = in_struct->maxBlockMatchRegion; + maxBoxFilterBlockSize = in_struct->maxBoxFilterBlockSize; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceImageProcessingPropertiesQCOM::initialize( + const safe_VkPhysicalDeviceImageProcessingPropertiesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxWeightFilterPhases = copy_src->maxWeightFilterPhases; + maxWeightFilterDimension = copy_src->maxWeightFilterDimension; + maxBlockMatchRegion = copy_src->maxBlockMatchRegion; + maxBoxFilterBlockSize = copy_src->maxBoxFilterBlockSize; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDirectDriverLoadingInfoLUNARG::safe_VkDirectDriverLoadingInfoLUNARG(const VkDirectDriverLoadingInfoLUNARG* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), pfnGetInstanceProcAddr(in_struct->pfnGetInstanceProcAddr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkDirectDriverLoadingInfoLUNARG::safe_VkDirectDriverLoadingInfoLUNARG() + : sType(VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG), pNext(nullptr), flags(), pfnGetInstanceProcAddr() {} + +safe_VkDirectDriverLoadingInfoLUNARG::safe_VkDirectDriverLoadingInfoLUNARG(const safe_VkDirectDriverLoadingInfoLUNARG& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + pfnGetInstanceProcAddr = copy_src.pfnGetInstanceProcAddr; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkDirectDriverLoadingInfoLUNARG& safe_VkDirectDriverLoadingInfoLUNARG::operator=( + const safe_VkDirectDriverLoadingInfoLUNARG& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + pfnGetInstanceProcAddr = copy_src.pfnGetInstanceProcAddr; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkDirectDriverLoadingInfoLUNARG::~safe_VkDirectDriverLoadingInfoLUNARG() { FreePnextChain(pNext); } + +void safe_VkDirectDriverLoadingInfoLUNARG::initialize(const VkDirectDriverLoadingInfoLUNARG* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + pfnGetInstanceProcAddr = in_struct->pfnGetInstanceProcAddr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkDirectDriverLoadingInfoLUNARG::initialize(const safe_VkDirectDriverLoadingInfoLUNARG* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + pfnGetInstanceProcAddr = copy_src->pfnGetInstanceProcAddr; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkDirectDriverLoadingListLUNARG::safe_VkDirectDriverLoadingListLUNARG(const VkDirectDriverLoadingListLUNARG* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), mode(in_struct->mode), driverCount(in_struct->driverCount), pDrivers(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (driverCount && in_struct->pDrivers) { + pDrivers = new safe_VkDirectDriverLoadingInfoLUNARG[driverCount]; + for (uint32_t i = 0; i < driverCount; ++i) { + pDrivers[i].initialize(&in_struct->pDrivers[i]); + } + } +} + +safe_VkDirectDriverLoadingListLUNARG::safe_VkDirectDriverLoadingListLUNARG() + : sType(VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG), pNext(nullptr), mode(), driverCount(), pDrivers(nullptr) {} + +safe_VkDirectDriverLoadingListLUNARG::safe_VkDirectDriverLoadingListLUNARG(const safe_VkDirectDriverLoadingListLUNARG& copy_src) { + sType = copy_src.sType; + mode = copy_src.mode; + driverCount = copy_src.driverCount; + pDrivers = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (driverCount && copy_src.pDrivers) { + pDrivers = new safe_VkDirectDriverLoadingInfoLUNARG[driverCount]; + for (uint32_t i = 0; i < driverCount; ++i) { + pDrivers[i].initialize(©_src.pDrivers[i]); + } + } +} + +safe_VkDirectDriverLoadingListLUNARG& safe_VkDirectDriverLoadingListLUNARG::operator=( + const safe_VkDirectDriverLoadingListLUNARG& copy_src) { + if (©_src == this) return *this; + + if (pDrivers) delete[] pDrivers; + FreePnextChain(pNext); + + sType = copy_src.sType; + mode = copy_src.mode; + driverCount = copy_src.driverCount; + pDrivers = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (driverCount && copy_src.pDrivers) { + pDrivers = new safe_VkDirectDriverLoadingInfoLUNARG[driverCount]; + for (uint32_t i = 0; i < driverCount; ++i) { + pDrivers[i].initialize(©_src.pDrivers[i]); + } + } + + return *this; +} + +safe_VkDirectDriverLoadingListLUNARG::~safe_VkDirectDriverLoadingListLUNARG() { + if (pDrivers) delete[] pDrivers; + FreePnextChain(pNext); +} + +void safe_VkDirectDriverLoadingListLUNARG::initialize(const VkDirectDriverLoadingListLUNARG* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pDrivers) delete[] pDrivers; + FreePnextChain(pNext); + sType = in_struct->sType; + mode = in_struct->mode; + driverCount = in_struct->driverCount; + pDrivers = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (driverCount && in_struct->pDrivers) { + pDrivers = new safe_VkDirectDriverLoadingInfoLUNARG[driverCount]; + for (uint32_t i = 0; i < driverCount; ++i) { + pDrivers[i].initialize(&in_struct->pDrivers[i]); + } + } +} + +void safe_VkDirectDriverLoadingListLUNARG::initialize(const safe_VkDirectDriverLoadingListLUNARG* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + mode = copy_src->mode; + driverCount = copy_src->driverCount; + pDrivers = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (driverCount && copy_src->pDrivers) { + pDrivers = new safe_VkDirectDriverLoadingInfoLUNARG[driverCount]; + for (uint32_t i = 0; i < driverCount; ++i) { + pDrivers[i].initialize(©_src->pDrivers[i]); + } + } +} + +safe_VkPhysicalDeviceOpticalFlowFeaturesNV::safe_VkPhysicalDeviceOpticalFlowFeaturesNV( + const VkPhysicalDeviceOpticalFlowFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), opticalFlow(in_struct->opticalFlow) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceOpticalFlowFeaturesNV::safe_VkPhysicalDeviceOpticalFlowFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV), pNext(nullptr), opticalFlow() {} + +safe_VkPhysicalDeviceOpticalFlowFeaturesNV::safe_VkPhysicalDeviceOpticalFlowFeaturesNV( + const safe_VkPhysicalDeviceOpticalFlowFeaturesNV& copy_src) { + sType = copy_src.sType; + opticalFlow = copy_src.opticalFlow; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceOpticalFlowFeaturesNV& safe_VkPhysicalDeviceOpticalFlowFeaturesNV::operator=( + const safe_VkPhysicalDeviceOpticalFlowFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + opticalFlow = copy_src.opticalFlow; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceOpticalFlowFeaturesNV::~safe_VkPhysicalDeviceOpticalFlowFeaturesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceOpticalFlowFeaturesNV::initialize(const VkPhysicalDeviceOpticalFlowFeaturesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + opticalFlow = in_struct->opticalFlow; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceOpticalFlowFeaturesNV::initialize(const safe_VkPhysicalDeviceOpticalFlowFeaturesNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + opticalFlow = copy_src->opticalFlow; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceOpticalFlowPropertiesNV::safe_VkPhysicalDeviceOpticalFlowPropertiesNV( + const VkPhysicalDeviceOpticalFlowPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + supportedOutputGridSizes(in_struct->supportedOutputGridSizes), + supportedHintGridSizes(in_struct->supportedHintGridSizes), + hintSupported(in_struct->hintSupported), + costSupported(in_struct->costSupported), + bidirectionalFlowSupported(in_struct->bidirectionalFlowSupported), + globalFlowSupported(in_struct->globalFlowSupported), + minWidth(in_struct->minWidth), + minHeight(in_struct->minHeight), + maxWidth(in_struct->maxWidth), + maxHeight(in_struct->maxHeight), + maxNumRegionsOfInterest(in_struct->maxNumRegionsOfInterest) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceOpticalFlowPropertiesNV::safe_VkPhysicalDeviceOpticalFlowPropertiesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV), + pNext(nullptr), + supportedOutputGridSizes(), + supportedHintGridSizes(), + hintSupported(), + costSupported(), + bidirectionalFlowSupported(), + globalFlowSupported(), + minWidth(), + minHeight(), + maxWidth(), + maxHeight(), + maxNumRegionsOfInterest() {} + +safe_VkPhysicalDeviceOpticalFlowPropertiesNV::safe_VkPhysicalDeviceOpticalFlowPropertiesNV( + const safe_VkPhysicalDeviceOpticalFlowPropertiesNV& copy_src) { + sType = copy_src.sType; + supportedOutputGridSizes = copy_src.supportedOutputGridSizes; + supportedHintGridSizes = copy_src.supportedHintGridSizes; + hintSupported = copy_src.hintSupported; + costSupported = copy_src.costSupported; + bidirectionalFlowSupported = copy_src.bidirectionalFlowSupported; + globalFlowSupported = copy_src.globalFlowSupported; + minWidth = copy_src.minWidth; + minHeight = copy_src.minHeight; + maxWidth = copy_src.maxWidth; + maxHeight = copy_src.maxHeight; + maxNumRegionsOfInterest = copy_src.maxNumRegionsOfInterest; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceOpticalFlowPropertiesNV& safe_VkPhysicalDeviceOpticalFlowPropertiesNV::operator=( + const safe_VkPhysicalDeviceOpticalFlowPropertiesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + supportedOutputGridSizes = copy_src.supportedOutputGridSizes; + supportedHintGridSizes = copy_src.supportedHintGridSizes; + hintSupported = copy_src.hintSupported; + costSupported = copy_src.costSupported; + bidirectionalFlowSupported = copy_src.bidirectionalFlowSupported; + globalFlowSupported = copy_src.globalFlowSupported; + minWidth = copy_src.minWidth; + minHeight = copy_src.minHeight; + maxWidth = copy_src.maxWidth; + maxHeight = copy_src.maxHeight; + maxNumRegionsOfInterest = copy_src.maxNumRegionsOfInterest; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceOpticalFlowPropertiesNV::~safe_VkPhysicalDeviceOpticalFlowPropertiesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceOpticalFlowPropertiesNV::initialize(const VkPhysicalDeviceOpticalFlowPropertiesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + supportedOutputGridSizes = in_struct->supportedOutputGridSizes; + supportedHintGridSizes = in_struct->supportedHintGridSizes; + hintSupported = in_struct->hintSupported; + costSupported = in_struct->costSupported; + bidirectionalFlowSupported = in_struct->bidirectionalFlowSupported; + globalFlowSupported = in_struct->globalFlowSupported; + minWidth = in_struct->minWidth; + minHeight = in_struct->minHeight; + maxWidth = in_struct->maxWidth; + maxHeight = in_struct->maxHeight; + maxNumRegionsOfInterest = in_struct->maxNumRegionsOfInterest; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceOpticalFlowPropertiesNV::initialize(const safe_VkPhysicalDeviceOpticalFlowPropertiesNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + supportedOutputGridSizes = copy_src->supportedOutputGridSizes; + supportedHintGridSizes = copy_src->supportedHintGridSizes; + hintSupported = copy_src->hintSupported; + costSupported = copy_src->costSupported; + bidirectionalFlowSupported = copy_src->bidirectionalFlowSupported; + globalFlowSupported = copy_src->globalFlowSupported; + minWidth = copy_src->minWidth; + minHeight = copy_src->minHeight; + maxWidth = copy_src->maxWidth; + maxHeight = copy_src->maxHeight; + maxNumRegionsOfInterest = copy_src->maxNumRegionsOfInterest; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkOpticalFlowImageFormatInfoNV::safe_VkOpticalFlowImageFormatInfoNV(const VkOpticalFlowImageFormatInfoNV* 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_VkOpticalFlowImageFormatInfoNV::safe_VkOpticalFlowImageFormatInfoNV() + : sType(VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV), pNext(nullptr), usage() {} + +safe_VkOpticalFlowImageFormatInfoNV::safe_VkOpticalFlowImageFormatInfoNV(const safe_VkOpticalFlowImageFormatInfoNV& copy_src) { + sType = copy_src.sType; + usage = copy_src.usage; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkOpticalFlowImageFormatInfoNV& safe_VkOpticalFlowImageFormatInfoNV::operator=( + const safe_VkOpticalFlowImageFormatInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + usage = copy_src.usage; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkOpticalFlowImageFormatInfoNV::~safe_VkOpticalFlowImageFormatInfoNV() { FreePnextChain(pNext); } + +void safe_VkOpticalFlowImageFormatInfoNV::initialize(const VkOpticalFlowImageFormatInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + usage = in_struct->usage; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkOpticalFlowImageFormatInfoNV::initialize(const safe_VkOpticalFlowImageFormatInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + usage = copy_src->usage; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkOpticalFlowImageFormatPropertiesNV::safe_VkOpticalFlowImageFormatPropertiesNV( + const VkOpticalFlowImageFormatPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), format(in_struct->format) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkOpticalFlowImageFormatPropertiesNV::safe_VkOpticalFlowImageFormatPropertiesNV() + : sType(VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV), pNext(nullptr), format() {} + +safe_VkOpticalFlowImageFormatPropertiesNV::safe_VkOpticalFlowImageFormatPropertiesNV( + const safe_VkOpticalFlowImageFormatPropertiesNV& copy_src) { + sType = copy_src.sType; + format = copy_src.format; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkOpticalFlowImageFormatPropertiesNV& safe_VkOpticalFlowImageFormatPropertiesNV::operator=( + const safe_VkOpticalFlowImageFormatPropertiesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + format = copy_src.format; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkOpticalFlowImageFormatPropertiesNV::~safe_VkOpticalFlowImageFormatPropertiesNV() { FreePnextChain(pNext); } + +void safe_VkOpticalFlowImageFormatPropertiesNV::initialize(const VkOpticalFlowImageFormatPropertiesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + format = in_struct->format; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkOpticalFlowImageFormatPropertiesNV::initialize(const safe_VkOpticalFlowImageFormatPropertiesNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + format = copy_src->format; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkOpticalFlowSessionCreateInfoNV::safe_VkOpticalFlowSessionCreateInfoNV(const VkOpticalFlowSessionCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + width(in_struct->width), + height(in_struct->height), + imageFormat(in_struct->imageFormat), + flowVectorFormat(in_struct->flowVectorFormat), + costFormat(in_struct->costFormat), + outputGridSize(in_struct->outputGridSize), + hintGridSize(in_struct->hintGridSize), + performanceLevel(in_struct->performanceLevel), + flags(in_struct->flags) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkOpticalFlowSessionCreateInfoNV::safe_VkOpticalFlowSessionCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV), + pNext(nullptr), + width(), + height(), + imageFormat(), + flowVectorFormat(), + costFormat(), + outputGridSize(), + hintGridSize(), + performanceLevel(), + flags() {} + +safe_VkOpticalFlowSessionCreateInfoNV::safe_VkOpticalFlowSessionCreateInfoNV( + const safe_VkOpticalFlowSessionCreateInfoNV& copy_src) { + sType = copy_src.sType; + width = copy_src.width; + height = copy_src.height; + imageFormat = copy_src.imageFormat; + flowVectorFormat = copy_src.flowVectorFormat; + costFormat = copy_src.costFormat; + outputGridSize = copy_src.outputGridSize; + hintGridSize = copy_src.hintGridSize; + performanceLevel = copy_src.performanceLevel; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkOpticalFlowSessionCreateInfoNV& safe_VkOpticalFlowSessionCreateInfoNV::operator=( + const safe_VkOpticalFlowSessionCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + width = copy_src.width; + height = copy_src.height; + imageFormat = copy_src.imageFormat; + flowVectorFormat = copy_src.flowVectorFormat; + costFormat = copy_src.costFormat; + outputGridSize = copy_src.outputGridSize; + hintGridSize = copy_src.hintGridSize; + performanceLevel = copy_src.performanceLevel; + flags = copy_src.flags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkOpticalFlowSessionCreateInfoNV::~safe_VkOpticalFlowSessionCreateInfoNV() { FreePnextChain(pNext); } + +void safe_VkOpticalFlowSessionCreateInfoNV::initialize(const VkOpticalFlowSessionCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + width = in_struct->width; + height = in_struct->height; + imageFormat = in_struct->imageFormat; + flowVectorFormat = in_struct->flowVectorFormat; + costFormat = in_struct->costFormat; + outputGridSize = in_struct->outputGridSize; + hintGridSize = in_struct->hintGridSize; + performanceLevel = in_struct->performanceLevel; + flags = in_struct->flags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkOpticalFlowSessionCreateInfoNV::initialize(const safe_VkOpticalFlowSessionCreateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + width = copy_src->width; + height = copy_src->height; + imageFormat = copy_src->imageFormat; + flowVectorFormat = copy_src->flowVectorFormat; + costFormat = copy_src->costFormat; + outputGridSize = copy_src->outputGridSize; + hintGridSize = copy_src->hintGridSize; + performanceLevel = copy_src->performanceLevel; + flags = copy_src->flags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkOpticalFlowSessionCreatePrivateDataInfoNV::safe_VkOpticalFlowSessionCreatePrivateDataInfoNV( + const VkOpticalFlowSessionCreatePrivateDataInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), id(in_struct->id), size(in_struct->size), pPrivateData(in_struct->pPrivateData) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkOpticalFlowSessionCreatePrivateDataInfoNV::safe_VkOpticalFlowSessionCreatePrivateDataInfoNV() + : sType(VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV), + pNext(nullptr), + id(), + size(), + pPrivateData(nullptr) {} + +safe_VkOpticalFlowSessionCreatePrivateDataInfoNV::safe_VkOpticalFlowSessionCreatePrivateDataInfoNV( + const safe_VkOpticalFlowSessionCreatePrivateDataInfoNV& copy_src) { + sType = copy_src.sType; + id = copy_src.id; + size = copy_src.size; + pPrivateData = copy_src.pPrivateData; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkOpticalFlowSessionCreatePrivateDataInfoNV& safe_VkOpticalFlowSessionCreatePrivateDataInfoNV::operator=( + const safe_VkOpticalFlowSessionCreatePrivateDataInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + id = copy_src.id; + size = copy_src.size; + pPrivateData = copy_src.pPrivateData; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkOpticalFlowSessionCreatePrivateDataInfoNV::~safe_VkOpticalFlowSessionCreatePrivateDataInfoNV() { FreePnextChain(pNext); } + +void safe_VkOpticalFlowSessionCreatePrivateDataInfoNV::initialize(const VkOpticalFlowSessionCreatePrivateDataInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + id = in_struct->id; + size = in_struct->size; + pPrivateData = in_struct->pPrivateData; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkOpticalFlowSessionCreatePrivateDataInfoNV::initialize(const safe_VkOpticalFlowSessionCreatePrivateDataInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + id = copy_src->id; + size = copy_src->size; + pPrivateData = copy_src->pPrivateData; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkOpticalFlowExecuteInfoNV::safe_VkOpticalFlowExecuteInfoNV(const VkOpticalFlowExecuteInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), flags(in_struct->flags), regionCount(in_struct->regionCount), pRegions(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pRegions) { + pRegions = new VkRect2D[in_struct->regionCount]; + memcpy((void*)pRegions, (void*)in_struct->pRegions, sizeof(VkRect2D) * in_struct->regionCount); + } +} + +safe_VkOpticalFlowExecuteInfoNV::safe_VkOpticalFlowExecuteInfoNV() + : sType(VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV), pNext(nullptr), flags(), regionCount(), pRegions(nullptr) {} + +safe_VkOpticalFlowExecuteInfoNV::safe_VkOpticalFlowExecuteInfoNV(const safe_VkOpticalFlowExecuteInfoNV& copy_src) { + sType = copy_src.sType; + flags = copy_src.flags; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pRegions) { + pRegions = new VkRect2D[copy_src.regionCount]; + memcpy((void*)pRegions, (void*)copy_src.pRegions, sizeof(VkRect2D) * copy_src.regionCount); + } +} + +safe_VkOpticalFlowExecuteInfoNV& safe_VkOpticalFlowExecuteInfoNV::operator=(const safe_VkOpticalFlowExecuteInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + + sType = copy_src.sType; + flags = copy_src.flags; + regionCount = copy_src.regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pRegions) { + pRegions = new VkRect2D[copy_src.regionCount]; + memcpy((void*)pRegions, (void*)copy_src.pRegions, sizeof(VkRect2D) * copy_src.regionCount); + } + + return *this; +} + +safe_VkOpticalFlowExecuteInfoNV::~safe_VkOpticalFlowExecuteInfoNV() { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); +} + +void safe_VkOpticalFlowExecuteInfoNV::initialize(const VkOpticalFlowExecuteInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pRegions) delete[] pRegions; + FreePnextChain(pNext); + sType = in_struct->sType; + flags = in_struct->flags; + regionCount = in_struct->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pRegions) { + pRegions = new VkRect2D[in_struct->regionCount]; + memcpy((void*)pRegions, (void*)in_struct->pRegions, sizeof(VkRect2D) * in_struct->regionCount); + } +} + +void safe_VkOpticalFlowExecuteInfoNV::initialize(const safe_VkOpticalFlowExecuteInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + flags = copy_src->flags; + regionCount = copy_src->regionCount; + pRegions = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pRegions) { + pRegions = new VkRect2D[copy_src->regionCount]; + memcpy((void*)pRegions, (void*)copy_src->pRegions, sizeof(VkRect2D) * copy_src->regionCount); + } +} +#ifdef VK_USE_PLATFORM_ANDROID_KHR + +safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID::safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID( + const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), externalFormatResolve(in_struct->externalFormatResolve) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID::safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID), pNext(nullptr), externalFormatResolve() {} + +safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID::safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID( + const safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID& copy_src) { + sType = copy_src.sType; + externalFormatResolve = copy_src.externalFormatResolve; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID& safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID::operator=( + const safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + externalFormatResolve = copy_src.externalFormatResolve; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID::~safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID::initialize( + const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + externalFormatResolve = in_struct->externalFormatResolve; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID::initialize( + const safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + externalFormatResolve = copy_src->externalFormatResolve; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID::safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID( + const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + nullColorAttachmentWithExternalFormatResolve(in_struct->nullColorAttachmentWithExternalFormatResolve), + externalFormatResolveChromaOffsetX(in_struct->externalFormatResolveChromaOffsetX), + externalFormatResolveChromaOffsetY(in_struct->externalFormatResolveChromaOffsetY) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID::safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID), + pNext(nullptr), + nullColorAttachmentWithExternalFormatResolve(), + externalFormatResolveChromaOffsetX(), + externalFormatResolveChromaOffsetY() {} + +safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID::safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID( + const safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID& copy_src) { + sType = copy_src.sType; + nullColorAttachmentWithExternalFormatResolve = copy_src.nullColorAttachmentWithExternalFormatResolve; + externalFormatResolveChromaOffsetX = copy_src.externalFormatResolveChromaOffsetX; + externalFormatResolveChromaOffsetY = copy_src.externalFormatResolveChromaOffsetY; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID& safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID::operator=( + const safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + nullColorAttachmentWithExternalFormatResolve = copy_src.nullColorAttachmentWithExternalFormatResolve; + externalFormatResolveChromaOffsetX = copy_src.externalFormatResolveChromaOffsetX; + externalFormatResolveChromaOffsetY = copy_src.externalFormatResolveChromaOffsetY; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID::~safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID::initialize( + const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + nullColorAttachmentWithExternalFormatResolve = in_struct->nullColorAttachmentWithExternalFormatResolve; + externalFormatResolveChromaOffsetX = in_struct->externalFormatResolveChromaOffsetX; + externalFormatResolveChromaOffsetY = in_struct->externalFormatResolveChromaOffsetY; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID::initialize( + const safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + nullColorAttachmentWithExternalFormatResolve = copy_src->nullColorAttachmentWithExternalFormatResolve; + externalFormatResolveChromaOffsetX = copy_src->externalFormatResolveChromaOffsetX; + externalFormatResolveChromaOffsetY = copy_src->externalFormatResolveChromaOffsetY; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID::safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID( + const VkAndroidHardwareBufferFormatResolvePropertiesANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), colorAttachmentFormat(in_struct->colorAttachmentFormat) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID::safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID() + : sType(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID), pNext(nullptr), colorAttachmentFormat() {} + +safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID::safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID( + const safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID& copy_src) { + sType = copy_src.sType; + colorAttachmentFormat = copy_src.colorAttachmentFormat; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID& safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID::operator=( + const safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + colorAttachmentFormat = copy_src.colorAttachmentFormat; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID::~safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID() { + FreePnextChain(pNext); +} + +void safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID::initialize( + const VkAndroidHardwareBufferFormatResolvePropertiesANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + colorAttachmentFormat = in_struct->colorAttachmentFormat; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID::initialize( + const safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + colorAttachmentFormat = copy_src->colorAttachmentFormat; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_ANDROID_KHR + +safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM::safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM( + const VkPhysicalDeviceTilePropertiesFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), tileProperties(in_struct->tileProperties) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM::safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM), pNext(nullptr), tileProperties() {} + +safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM::safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM( + const safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM& copy_src) { + sType = copy_src.sType; + tileProperties = copy_src.tileProperties; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM& safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM::operator=( + const safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + tileProperties = copy_src.tileProperties; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM::~safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM::initialize(const VkPhysicalDeviceTilePropertiesFeaturesQCOM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + tileProperties = in_struct->tileProperties; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM::initialize(const safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + tileProperties = copy_src->tileProperties; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkTilePropertiesQCOM::safe_VkTilePropertiesQCOM(const VkTilePropertiesQCOM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), tileSize(in_struct->tileSize), apronSize(in_struct->apronSize), origin(in_struct->origin) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkTilePropertiesQCOM::safe_VkTilePropertiesQCOM() + : sType(VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM), pNext(nullptr), tileSize(), apronSize(), origin() {} + +safe_VkTilePropertiesQCOM::safe_VkTilePropertiesQCOM(const safe_VkTilePropertiesQCOM& copy_src) { + sType = copy_src.sType; + tileSize = copy_src.tileSize; + apronSize = copy_src.apronSize; + origin = copy_src.origin; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkTilePropertiesQCOM& safe_VkTilePropertiesQCOM::operator=(const safe_VkTilePropertiesQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + tileSize = copy_src.tileSize; + apronSize = copy_src.apronSize; + origin = copy_src.origin; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkTilePropertiesQCOM::~safe_VkTilePropertiesQCOM() { FreePnextChain(pNext); } + +void safe_VkTilePropertiesQCOM::initialize(const VkTilePropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + tileSize = in_struct->tileSize; + apronSize = in_struct->apronSize; + origin = in_struct->origin; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkTilePropertiesQCOM::initialize(const safe_VkTilePropertiesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + tileSize = copy_src->tileSize; + apronSize = copy_src->apronSize; + origin = copy_src->origin; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC::safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC( + const VkPhysicalDeviceAmigoProfilingFeaturesSEC* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), amigoProfiling(in_struct->amigoProfiling) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC::safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC), pNext(nullptr), amigoProfiling() {} + +safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC::safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC( + const safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC& copy_src) { + sType = copy_src.sType; + amigoProfiling = copy_src.amigoProfiling; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC& safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC::operator=( + const safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + amigoProfiling = copy_src.amigoProfiling; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC::~safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC::initialize(const VkPhysicalDeviceAmigoProfilingFeaturesSEC* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + amigoProfiling = in_struct->amigoProfiling; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC::initialize(const safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + amigoProfiling = copy_src->amigoProfiling; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAmigoProfilingSubmitInfoSEC::safe_VkAmigoProfilingSubmitInfoSEC(const VkAmigoProfilingSubmitInfoSEC* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + firstDrawTimestamp(in_struct->firstDrawTimestamp), + swapBufferTimestamp(in_struct->swapBufferTimestamp) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAmigoProfilingSubmitInfoSEC::safe_VkAmigoProfilingSubmitInfoSEC() + : sType(VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC), pNext(nullptr), firstDrawTimestamp(), swapBufferTimestamp() {} + +safe_VkAmigoProfilingSubmitInfoSEC::safe_VkAmigoProfilingSubmitInfoSEC(const safe_VkAmigoProfilingSubmitInfoSEC& copy_src) { + sType = copy_src.sType; + firstDrawTimestamp = copy_src.firstDrawTimestamp; + swapBufferTimestamp = copy_src.swapBufferTimestamp; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAmigoProfilingSubmitInfoSEC& safe_VkAmigoProfilingSubmitInfoSEC::operator=( + const safe_VkAmigoProfilingSubmitInfoSEC& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + firstDrawTimestamp = copy_src.firstDrawTimestamp; + swapBufferTimestamp = copy_src.swapBufferTimestamp; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAmigoProfilingSubmitInfoSEC::~safe_VkAmigoProfilingSubmitInfoSEC() { FreePnextChain(pNext); } + +void safe_VkAmigoProfilingSubmitInfoSEC::initialize(const VkAmigoProfilingSubmitInfoSEC* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + firstDrawTimestamp = in_struct->firstDrawTimestamp; + swapBufferTimestamp = in_struct->swapBufferTimestamp; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAmigoProfilingSubmitInfoSEC::initialize(const safe_VkAmigoProfilingSubmitInfoSEC* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + firstDrawTimestamp = copy_src->firstDrawTimestamp; + swapBufferTimestamp = copy_src->swapBufferTimestamp; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM( + const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), multiviewPerViewViewports(in_struct->multiviewPerViewViewports) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM), + pNext(nullptr), + multiviewPerViewViewports() {} + +safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM( + const safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& copy_src) { + sType = copy_src.sType; + multiviewPerViewViewports = copy_src.multiviewPerViewViewports; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::operator=( + const safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + multiviewPerViewViewports = copy_src.multiviewPerViewViewports; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::~safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::initialize( + const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + multiviewPerViewViewports = in_struct->multiviewPerViewViewports; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::initialize( + const safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + multiviewPerViewViewports = copy_src->multiviewPerViewViewports; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV::safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV( + const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), rayTracingInvocationReorderReorderingHint(in_struct->rayTracingInvocationReorderReorderingHint) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV::safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV), + pNext(nullptr), + rayTracingInvocationReorderReorderingHint() {} + +safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV::safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV( + const safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV& copy_src) { + sType = copy_src.sType; + rayTracingInvocationReorderReorderingHint = copy_src.rayTracingInvocationReorderReorderingHint; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV& +safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV::operator=( + const safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + rayTracingInvocationReorderReorderingHint = copy_src.rayTracingInvocationReorderReorderingHint; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV::~safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV::initialize( + const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + rayTracingInvocationReorderReorderingHint = in_struct->rayTracingInvocationReorderReorderingHint; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV::initialize( + const safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + rayTracingInvocationReorderReorderingHint = copy_src->rayTracingInvocationReorderReorderingHint; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV::safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV( + const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), rayTracingInvocationReorder(in_struct->rayTracingInvocationReorder) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV::safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV), + pNext(nullptr), + rayTracingInvocationReorder() {} + +safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV::safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV( + const safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV& copy_src) { + sType = copy_src.sType; + rayTracingInvocationReorder = copy_src.rayTracingInvocationReorder; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV& safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV::operator=( + const safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + rayTracingInvocationReorder = copy_src.rayTracingInvocationReorder; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV::~safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV::initialize( + const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + rayTracingInvocationReorder = in_struct->rayTracingInvocationReorder; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV::initialize( + const safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + rayTracingInvocationReorder = copy_src->rayTracingInvocationReorder; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV( + const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), extendedSparseAddressSpace(in_struct->extendedSparseAddressSpace) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV), + pNext(nullptr), + extendedSparseAddressSpace() {} + +safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV( + const safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& copy_src) { + sType = copy_src.sType; + extendedSparseAddressSpace = copy_src.extendedSparseAddressSpace; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::operator=( + const safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + extendedSparseAddressSpace = copy_src.extendedSparseAddressSpace; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::~safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::initialize( + const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + extendedSparseAddressSpace = in_struct->extendedSparseAddressSpace; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::initialize( + const safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + extendedSparseAddressSpace = copy_src->extendedSparseAddressSpace; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV::safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV( + const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + extendedSparseAddressSpaceSize(in_struct->extendedSparseAddressSpaceSize), + extendedSparseImageUsageFlags(in_struct->extendedSparseImageUsageFlags), + extendedSparseBufferUsageFlags(in_struct->extendedSparseBufferUsageFlags) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV::safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV), + pNext(nullptr), + extendedSparseAddressSpaceSize(), + extendedSparseImageUsageFlags(), + extendedSparseBufferUsageFlags() {} + +safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV::safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV( + const safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV& copy_src) { + sType = copy_src.sType; + extendedSparseAddressSpaceSize = copy_src.extendedSparseAddressSpaceSize; + extendedSparseImageUsageFlags = copy_src.extendedSparseImageUsageFlags; + extendedSparseBufferUsageFlags = copy_src.extendedSparseBufferUsageFlags; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV& safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV::operator=( + const safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + extendedSparseAddressSpaceSize = copy_src.extendedSparseAddressSpaceSize; + extendedSparseImageUsageFlags = copy_src.extendedSparseImageUsageFlags; + extendedSparseBufferUsageFlags = copy_src.extendedSparseBufferUsageFlags; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV::~safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV::initialize( + const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + extendedSparseAddressSpaceSize = in_struct->extendedSparseAddressSpaceSize; + extendedSparseImageUsageFlags = in_struct->extendedSparseImageUsageFlags; + extendedSparseBufferUsageFlags = in_struct->extendedSparseBufferUsageFlags; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV::initialize( + const safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + extendedSparseAddressSpaceSize = copy_src->extendedSparseAddressSpaceSize; + extendedSparseImageUsageFlags = copy_src->extendedSparseImageUsageFlags; + extendedSparseBufferUsageFlags = copy_src->extendedSparseBufferUsageFlags; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM::safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM( + const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), shaderCoreBuiltins(in_struct->shaderCoreBuiltins) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM::safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM), pNext(nullptr), shaderCoreBuiltins() {} + +safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM::safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM( + const safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM& copy_src) { + sType = copy_src.sType; + shaderCoreBuiltins = copy_src.shaderCoreBuiltins; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM& safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM::operator=( + const safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderCoreBuiltins = copy_src.shaderCoreBuiltins; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM::~safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM::initialize(const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderCoreBuiltins = in_struct->shaderCoreBuiltins; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM::initialize( + const safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderCoreBuiltins = copy_src->shaderCoreBuiltins; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM::safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM( + const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + shaderCoreMask(in_struct->shaderCoreMask), + shaderCoreCount(in_struct->shaderCoreCount), + shaderWarpsPerCore(in_struct->shaderWarpsPerCore) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM::safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM), + pNext(nullptr), + shaderCoreMask(), + shaderCoreCount(), + shaderWarpsPerCore() {} + +safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM::safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM( + const safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM& copy_src) { + sType = copy_src.sType; + shaderCoreMask = copy_src.shaderCoreMask; + shaderCoreCount = copy_src.shaderCoreCount; + shaderWarpsPerCore = copy_src.shaderWarpsPerCore; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM& safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM::operator=( + const safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderCoreMask = copy_src.shaderCoreMask; + shaderCoreCount = copy_src.shaderCoreCount; + shaderWarpsPerCore = copy_src.shaderWarpsPerCore; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM::~safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM::initialize( + const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderCoreMask = in_struct->shaderCoreMask; + shaderCoreCount = in_struct->shaderCoreCount; + shaderWarpsPerCore = in_struct->shaderWarpsPerCore; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM::initialize( + const safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderCoreMask = copy_src->shaderCoreMask; + shaderCoreCount = copy_src->shaderCoreCount; + shaderWarpsPerCore = copy_src->shaderWarpsPerCore; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkLatencySleepModeInfoNV::safe_VkLatencySleepModeInfoNV(const VkLatencySleepModeInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + lowLatencyMode(in_struct->lowLatencyMode), + lowLatencyBoost(in_struct->lowLatencyBoost), + minimumIntervalUs(in_struct->minimumIntervalUs) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkLatencySleepModeInfoNV::safe_VkLatencySleepModeInfoNV() + : sType(VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV), + pNext(nullptr), + lowLatencyMode(), + lowLatencyBoost(), + minimumIntervalUs() {} + +safe_VkLatencySleepModeInfoNV::safe_VkLatencySleepModeInfoNV(const safe_VkLatencySleepModeInfoNV& copy_src) { + sType = copy_src.sType; + lowLatencyMode = copy_src.lowLatencyMode; + lowLatencyBoost = copy_src.lowLatencyBoost; + minimumIntervalUs = copy_src.minimumIntervalUs; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkLatencySleepModeInfoNV& safe_VkLatencySleepModeInfoNV::operator=(const safe_VkLatencySleepModeInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + lowLatencyMode = copy_src.lowLatencyMode; + lowLatencyBoost = copy_src.lowLatencyBoost; + minimumIntervalUs = copy_src.minimumIntervalUs; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkLatencySleepModeInfoNV::~safe_VkLatencySleepModeInfoNV() { FreePnextChain(pNext); } + +void safe_VkLatencySleepModeInfoNV::initialize(const VkLatencySleepModeInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + lowLatencyMode = in_struct->lowLatencyMode; + lowLatencyBoost = in_struct->lowLatencyBoost; + minimumIntervalUs = in_struct->minimumIntervalUs; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkLatencySleepModeInfoNV::initialize(const safe_VkLatencySleepModeInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + lowLatencyMode = copy_src->lowLatencyMode; + lowLatencyBoost = copy_src->lowLatencyBoost; + minimumIntervalUs = copy_src->minimumIntervalUs; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkLatencySleepInfoNV::safe_VkLatencySleepInfoNV(const VkLatencySleepInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), signalSemaphore(in_struct->signalSemaphore), value(in_struct->value) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkLatencySleepInfoNV::safe_VkLatencySleepInfoNV() + : sType(VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV), pNext(nullptr), signalSemaphore(), value() {} + +safe_VkLatencySleepInfoNV::safe_VkLatencySleepInfoNV(const safe_VkLatencySleepInfoNV& copy_src) { + sType = copy_src.sType; + signalSemaphore = copy_src.signalSemaphore; + value = copy_src.value; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkLatencySleepInfoNV& safe_VkLatencySleepInfoNV::operator=(const safe_VkLatencySleepInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + signalSemaphore = copy_src.signalSemaphore; + value = copy_src.value; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkLatencySleepInfoNV::~safe_VkLatencySleepInfoNV() { FreePnextChain(pNext); } + +void safe_VkLatencySleepInfoNV::initialize(const VkLatencySleepInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + signalSemaphore = in_struct->signalSemaphore; + value = in_struct->value; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkLatencySleepInfoNV::initialize(const safe_VkLatencySleepInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + signalSemaphore = copy_src->signalSemaphore; + value = copy_src->value; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSetLatencyMarkerInfoNV::safe_VkSetLatencyMarkerInfoNV(const VkSetLatencyMarkerInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), presentID(in_struct->presentID), marker(in_struct->marker) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSetLatencyMarkerInfoNV::safe_VkSetLatencyMarkerInfoNV() + : sType(VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV), pNext(nullptr), presentID(), marker() {} + +safe_VkSetLatencyMarkerInfoNV::safe_VkSetLatencyMarkerInfoNV(const safe_VkSetLatencyMarkerInfoNV& copy_src) { + sType = copy_src.sType; + presentID = copy_src.presentID; + marker = copy_src.marker; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSetLatencyMarkerInfoNV& safe_VkSetLatencyMarkerInfoNV::operator=(const safe_VkSetLatencyMarkerInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + presentID = copy_src.presentID; + marker = copy_src.marker; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSetLatencyMarkerInfoNV::~safe_VkSetLatencyMarkerInfoNV() { FreePnextChain(pNext); } + +void safe_VkSetLatencyMarkerInfoNV::initialize(const VkSetLatencyMarkerInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + presentID = in_struct->presentID; + marker = in_struct->marker; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSetLatencyMarkerInfoNV::initialize(const safe_VkSetLatencyMarkerInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentID = copy_src->presentID; + marker = copy_src->marker; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkLatencyTimingsFrameReportNV::safe_VkLatencyTimingsFrameReportNV(const VkLatencyTimingsFrameReportNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + presentID(in_struct->presentID), + inputSampleTimeUs(in_struct->inputSampleTimeUs), + simStartTimeUs(in_struct->simStartTimeUs), + simEndTimeUs(in_struct->simEndTimeUs), + renderSubmitStartTimeUs(in_struct->renderSubmitStartTimeUs), + renderSubmitEndTimeUs(in_struct->renderSubmitEndTimeUs), + presentStartTimeUs(in_struct->presentStartTimeUs), + presentEndTimeUs(in_struct->presentEndTimeUs), + driverStartTimeUs(in_struct->driverStartTimeUs), + driverEndTimeUs(in_struct->driverEndTimeUs), + osRenderQueueStartTimeUs(in_struct->osRenderQueueStartTimeUs), + osRenderQueueEndTimeUs(in_struct->osRenderQueueEndTimeUs), + gpuRenderStartTimeUs(in_struct->gpuRenderStartTimeUs), + gpuRenderEndTimeUs(in_struct->gpuRenderEndTimeUs) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkLatencyTimingsFrameReportNV::safe_VkLatencyTimingsFrameReportNV() + : sType(VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV), + pNext(nullptr), + presentID(), + inputSampleTimeUs(), + simStartTimeUs(), + simEndTimeUs(), + renderSubmitStartTimeUs(), + renderSubmitEndTimeUs(), + presentStartTimeUs(), + presentEndTimeUs(), + driverStartTimeUs(), + driverEndTimeUs(), + osRenderQueueStartTimeUs(), + osRenderQueueEndTimeUs(), + gpuRenderStartTimeUs(), + gpuRenderEndTimeUs() {} + +safe_VkLatencyTimingsFrameReportNV::safe_VkLatencyTimingsFrameReportNV(const safe_VkLatencyTimingsFrameReportNV& copy_src) { + sType = copy_src.sType; + presentID = copy_src.presentID; + inputSampleTimeUs = copy_src.inputSampleTimeUs; + simStartTimeUs = copy_src.simStartTimeUs; + simEndTimeUs = copy_src.simEndTimeUs; + renderSubmitStartTimeUs = copy_src.renderSubmitStartTimeUs; + renderSubmitEndTimeUs = copy_src.renderSubmitEndTimeUs; + presentStartTimeUs = copy_src.presentStartTimeUs; + presentEndTimeUs = copy_src.presentEndTimeUs; + driverStartTimeUs = copy_src.driverStartTimeUs; + driverEndTimeUs = copy_src.driverEndTimeUs; + osRenderQueueStartTimeUs = copy_src.osRenderQueueStartTimeUs; + osRenderQueueEndTimeUs = copy_src.osRenderQueueEndTimeUs; + gpuRenderStartTimeUs = copy_src.gpuRenderStartTimeUs; + gpuRenderEndTimeUs = copy_src.gpuRenderEndTimeUs; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkLatencyTimingsFrameReportNV& safe_VkLatencyTimingsFrameReportNV::operator=( + const safe_VkLatencyTimingsFrameReportNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + presentID = copy_src.presentID; + inputSampleTimeUs = copy_src.inputSampleTimeUs; + simStartTimeUs = copy_src.simStartTimeUs; + simEndTimeUs = copy_src.simEndTimeUs; + renderSubmitStartTimeUs = copy_src.renderSubmitStartTimeUs; + renderSubmitEndTimeUs = copy_src.renderSubmitEndTimeUs; + presentStartTimeUs = copy_src.presentStartTimeUs; + presentEndTimeUs = copy_src.presentEndTimeUs; + driverStartTimeUs = copy_src.driverStartTimeUs; + driverEndTimeUs = copy_src.driverEndTimeUs; + osRenderQueueStartTimeUs = copy_src.osRenderQueueStartTimeUs; + osRenderQueueEndTimeUs = copy_src.osRenderQueueEndTimeUs; + gpuRenderStartTimeUs = copy_src.gpuRenderStartTimeUs; + gpuRenderEndTimeUs = copy_src.gpuRenderEndTimeUs; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkLatencyTimingsFrameReportNV::~safe_VkLatencyTimingsFrameReportNV() { FreePnextChain(pNext); } + +void safe_VkLatencyTimingsFrameReportNV::initialize(const VkLatencyTimingsFrameReportNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + presentID = in_struct->presentID; + inputSampleTimeUs = in_struct->inputSampleTimeUs; + simStartTimeUs = in_struct->simStartTimeUs; + simEndTimeUs = in_struct->simEndTimeUs; + renderSubmitStartTimeUs = in_struct->renderSubmitStartTimeUs; + renderSubmitEndTimeUs = in_struct->renderSubmitEndTimeUs; + presentStartTimeUs = in_struct->presentStartTimeUs; + presentEndTimeUs = in_struct->presentEndTimeUs; + driverStartTimeUs = in_struct->driverStartTimeUs; + driverEndTimeUs = in_struct->driverEndTimeUs; + osRenderQueueStartTimeUs = in_struct->osRenderQueueStartTimeUs; + osRenderQueueEndTimeUs = in_struct->osRenderQueueEndTimeUs; + gpuRenderStartTimeUs = in_struct->gpuRenderStartTimeUs; + gpuRenderEndTimeUs = in_struct->gpuRenderEndTimeUs; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkLatencyTimingsFrameReportNV::initialize(const safe_VkLatencyTimingsFrameReportNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentID = copy_src->presentID; + inputSampleTimeUs = copy_src->inputSampleTimeUs; + simStartTimeUs = copy_src->simStartTimeUs; + simEndTimeUs = copy_src->simEndTimeUs; + renderSubmitStartTimeUs = copy_src->renderSubmitStartTimeUs; + renderSubmitEndTimeUs = copy_src->renderSubmitEndTimeUs; + presentStartTimeUs = copy_src->presentStartTimeUs; + presentEndTimeUs = copy_src->presentEndTimeUs; + driverStartTimeUs = copy_src->driverStartTimeUs; + driverEndTimeUs = copy_src->driverEndTimeUs; + osRenderQueueStartTimeUs = copy_src->osRenderQueueStartTimeUs; + osRenderQueueEndTimeUs = copy_src->osRenderQueueEndTimeUs; + gpuRenderStartTimeUs = copy_src->gpuRenderStartTimeUs; + gpuRenderEndTimeUs = copy_src->gpuRenderEndTimeUs; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkGetLatencyMarkerInfoNV::safe_VkGetLatencyMarkerInfoNV(const VkGetLatencyMarkerInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), timingCount(in_struct->timingCount), pTimings(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (timingCount && in_struct->pTimings) { + pTimings = new safe_VkLatencyTimingsFrameReportNV[timingCount]; + for (uint32_t i = 0; i < timingCount; ++i) { + pTimings[i].initialize(&in_struct->pTimings[i]); + } + } +} + +safe_VkGetLatencyMarkerInfoNV::safe_VkGetLatencyMarkerInfoNV() + : sType(VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV), pNext(nullptr), timingCount(), pTimings(nullptr) {} + +safe_VkGetLatencyMarkerInfoNV::safe_VkGetLatencyMarkerInfoNV(const safe_VkGetLatencyMarkerInfoNV& copy_src) { + sType = copy_src.sType; + timingCount = copy_src.timingCount; + pTimings = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (timingCount && copy_src.pTimings) { + pTimings = new safe_VkLatencyTimingsFrameReportNV[timingCount]; + for (uint32_t i = 0; i < timingCount; ++i) { + pTimings[i].initialize(©_src.pTimings[i]); + } + } +} + +safe_VkGetLatencyMarkerInfoNV& safe_VkGetLatencyMarkerInfoNV::operator=(const safe_VkGetLatencyMarkerInfoNV& copy_src) { + if (©_src == this) return *this; + + if (pTimings) delete[] pTimings; + FreePnextChain(pNext); + + sType = copy_src.sType; + timingCount = copy_src.timingCount; + pTimings = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + if (timingCount && copy_src.pTimings) { + pTimings = new safe_VkLatencyTimingsFrameReportNV[timingCount]; + for (uint32_t i = 0; i < timingCount; ++i) { + pTimings[i].initialize(©_src.pTimings[i]); + } + } + + return *this; +} + +safe_VkGetLatencyMarkerInfoNV::~safe_VkGetLatencyMarkerInfoNV() { + if (pTimings) delete[] pTimings; + FreePnextChain(pNext); +} + +void safe_VkGetLatencyMarkerInfoNV::initialize(const VkGetLatencyMarkerInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pTimings) delete[] pTimings; + FreePnextChain(pNext); + sType = in_struct->sType; + timingCount = in_struct->timingCount; + pTimings = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + if (timingCount && in_struct->pTimings) { + pTimings = new safe_VkLatencyTimingsFrameReportNV[timingCount]; + for (uint32_t i = 0; i < timingCount; ++i) { + pTimings[i].initialize(&in_struct->pTimings[i]); + } + } +} + +void safe_VkGetLatencyMarkerInfoNV::initialize(const safe_VkGetLatencyMarkerInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + timingCount = copy_src->timingCount; + pTimings = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + if (timingCount && copy_src->pTimings) { + pTimings = new safe_VkLatencyTimingsFrameReportNV[timingCount]; + for (uint32_t i = 0; i < timingCount; ++i) { + pTimings[i].initialize(©_src->pTimings[i]); + } + } +} + +safe_VkLatencySubmissionPresentIdNV::safe_VkLatencySubmissionPresentIdNV(const VkLatencySubmissionPresentIdNV* 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_VkLatencySubmissionPresentIdNV::safe_VkLatencySubmissionPresentIdNV() + : sType(VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV), pNext(nullptr), presentID() {} + +safe_VkLatencySubmissionPresentIdNV::safe_VkLatencySubmissionPresentIdNV(const safe_VkLatencySubmissionPresentIdNV& copy_src) { + sType = copy_src.sType; + presentID = copy_src.presentID; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkLatencySubmissionPresentIdNV& safe_VkLatencySubmissionPresentIdNV::operator=( + const safe_VkLatencySubmissionPresentIdNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + presentID = copy_src.presentID; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkLatencySubmissionPresentIdNV::~safe_VkLatencySubmissionPresentIdNV() { FreePnextChain(pNext); } + +void safe_VkLatencySubmissionPresentIdNV::initialize(const VkLatencySubmissionPresentIdNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + presentID = in_struct->presentID; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkLatencySubmissionPresentIdNV::initialize(const safe_VkLatencySubmissionPresentIdNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentID = copy_src->presentID; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSwapchainLatencyCreateInfoNV::safe_VkSwapchainLatencyCreateInfoNV(const VkSwapchainLatencyCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), latencyModeEnable(in_struct->latencyModeEnable) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSwapchainLatencyCreateInfoNV::safe_VkSwapchainLatencyCreateInfoNV() + : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV), pNext(nullptr), latencyModeEnable() {} + +safe_VkSwapchainLatencyCreateInfoNV::safe_VkSwapchainLatencyCreateInfoNV(const safe_VkSwapchainLatencyCreateInfoNV& copy_src) { + sType = copy_src.sType; + latencyModeEnable = copy_src.latencyModeEnable; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSwapchainLatencyCreateInfoNV& safe_VkSwapchainLatencyCreateInfoNV::operator=( + const safe_VkSwapchainLatencyCreateInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + latencyModeEnable = copy_src.latencyModeEnable; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSwapchainLatencyCreateInfoNV::~safe_VkSwapchainLatencyCreateInfoNV() { FreePnextChain(pNext); } + +void safe_VkSwapchainLatencyCreateInfoNV::initialize(const VkSwapchainLatencyCreateInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + latencyModeEnable = in_struct->latencyModeEnable; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSwapchainLatencyCreateInfoNV::initialize(const safe_VkSwapchainLatencyCreateInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + latencyModeEnable = copy_src->latencyModeEnable; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkOutOfBandQueueTypeInfoNV::safe_VkOutOfBandQueueTypeInfoNV(const VkOutOfBandQueueTypeInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), queueType(in_struct->queueType) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkOutOfBandQueueTypeInfoNV::safe_VkOutOfBandQueueTypeInfoNV() + : sType(VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV), pNext(nullptr), queueType() {} + +safe_VkOutOfBandQueueTypeInfoNV::safe_VkOutOfBandQueueTypeInfoNV(const safe_VkOutOfBandQueueTypeInfoNV& copy_src) { + sType = copy_src.sType; + queueType = copy_src.queueType; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkOutOfBandQueueTypeInfoNV& safe_VkOutOfBandQueueTypeInfoNV::operator=(const safe_VkOutOfBandQueueTypeInfoNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + queueType = copy_src.queueType; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkOutOfBandQueueTypeInfoNV::~safe_VkOutOfBandQueueTypeInfoNV() { FreePnextChain(pNext); } + +void safe_VkOutOfBandQueueTypeInfoNV::initialize(const VkOutOfBandQueueTypeInfoNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + queueType = in_struct->queueType; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkOutOfBandQueueTypeInfoNV::initialize(const safe_VkOutOfBandQueueTypeInfoNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + queueType = copy_src->queueType; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkLatencySurfaceCapabilitiesNV::safe_VkLatencySurfaceCapabilitiesNV(const VkLatencySurfaceCapabilitiesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), presentModeCount(in_struct->presentModeCount), pPresentModes(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pPresentModes) { + pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount]; + memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount); + } +} + +safe_VkLatencySurfaceCapabilitiesNV::safe_VkLatencySurfaceCapabilitiesNV() + : sType(VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV), pNext(nullptr), presentModeCount(), pPresentModes(nullptr) {} + +safe_VkLatencySurfaceCapabilitiesNV::safe_VkLatencySurfaceCapabilitiesNV(const safe_VkLatencySurfaceCapabilitiesNV& copy_src) { + sType = copy_src.sType; + presentModeCount = copy_src.presentModeCount; + pPresentModes = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPresentModes) { + pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount]; + memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount); + } +} + +safe_VkLatencySurfaceCapabilitiesNV& safe_VkLatencySurfaceCapabilitiesNV::operator=( + const safe_VkLatencySurfaceCapabilitiesNV& copy_src) { + if (©_src == this) return *this; + + if (pPresentModes) delete[] pPresentModes; + FreePnextChain(pNext); + + sType = copy_src.sType; + presentModeCount = copy_src.presentModeCount; + pPresentModes = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPresentModes) { + pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount]; + memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount); + } + + return *this; +} + +safe_VkLatencySurfaceCapabilitiesNV::~safe_VkLatencySurfaceCapabilitiesNV() { + if (pPresentModes) delete[] pPresentModes; + FreePnextChain(pNext); +} + +void safe_VkLatencySurfaceCapabilitiesNV::initialize(const VkLatencySurfaceCapabilitiesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pPresentModes) delete[] pPresentModes; + FreePnextChain(pNext); + sType = in_struct->sType; + presentModeCount = in_struct->presentModeCount; + pPresentModes = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pPresentModes) { + pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount]; + memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount); + } +} + +void safe_VkLatencySurfaceCapabilitiesNV::initialize(const safe_VkLatencySurfaceCapabilitiesNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + presentModeCount = copy_src->presentModeCount; + pPresentModes = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pPresentModes) { + pPresentModes = new VkPresentModeKHR[copy_src->presentModeCount]; + memcpy((void*)pPresentModes, (void*)copy_src->pPresentModes, sizeof(VkPresentModeKHR) * copy_src->presentModeCount); + } +} + +safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM( + const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), multiviewPerViewRenderAreas(in_struct->multiviewPerViewRenderAreas) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM), + pNext(nullptr), + multiviewPerViewRenderAreas() {} + +safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM( + const safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& copy_src) { + sType = copy_src.sType; + multiviewPerViewRenderAreas = copy_src.multiviewPerViewRenderAreas; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& +safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::operator=( + const safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + multiviewPerViewRenderAreas = copy_src.multiviewPerViewRenderAreas; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::~safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::initialize( + const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + multiviewPerViewRenderAreas = in_struct->multiviewPerViewRenderAreas; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::initialize( + const safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + multiviewPerViewRenderAreas = copy_src->multiviewPerViewRenderAreas; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM( + const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), perViewRenderAreaCount(in_struct->perViewRenderAreaCount), pPerViewRenderAreas(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pPerViewRenderAreas) { + pPerViewRenderAreas = new VkRect2D[in_struct->perViewRenderAreaCount]; + memcpy((void*)pPerViewRenderAreas, (void*)in_struct->pPerViewRenderAreas, + sizeof(VkRect2D) * in_struct->perViewRenderAreaCount); + } +} + +safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM() + : sType(VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM), + pNext(nullptr), + perViewRenderAreaCount(), + pPerViewRenderAreas(nullptr) {} + +safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM( + const safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& copy_src) { + sType = copy_src.sType; + perViewRenderAreaCount = copy_src.perViewRenderAreaCount; + pPerViewRenderAreas = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPerViewRenderAreas) { + pPerViewRenderAreas = new VkRect2D[copy_src.perViewRenderAreaCount]; + memcpy((void*)pPerViewRenderAreas, (void*)copy_src.pPerViewRenderAreas, sizeof(VkRect2D) * copy_src.perViewRenderAreaCount); + } +} + +safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::operator=( + const safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& copy_src) { + if (©_src == this) return *this; + + if (pPerViewRenderAreas) delete[] pPerViewRenderAreas; + FreePnextChain(pNext); + + sType = copy_src.sType; + perViewRenderAreaCount = copy_src.perViewRenderAreaCount; + pPerViewRenderAreas = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pPerViewRenderAreas) { + pPerViewRenderAreas = new VkRect2D[copy_src.perViewRenderAreaCount]; + memcpy((void*)pPerViewRenderAreas, (void*)copy_src.pPerViewRenderAreas, sizeof(VkRect2D) * copy_src.perViewRenderAreaCount); + } + + return *this; +} + +safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::~safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM() { + if (pPerViewRenderAreas) delete[] pPerViewRenderAreas; + FreePnextChain(pNext); +} + +void safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::initialize( + const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + if (pPerViewRenderAreas) delete[] pPerViewRenderAreas; + FreePnextChain(pNext); + sType = in_struct->sType; + perViewRenderAreaCount = in_struct->perViewRenderAreaCount; + pPerViewRenderAreas = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pPerViewRenderAreas) { + pPerViewRenderAreas = new VkRect2D[in_struct->perViewRenderAreaCount]; + memcpy((void*)pPerViewRenderAreas, (void*)in_struct->pPerViewRenderAreas, + sizeof(VkRect2D) * in_struct->perViewRenderAreaCount); + } +} + +void safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::initialize( + const safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + perViewRenderAreaCount = copy_src->perViewRenderAreaCount; + pPerViewRenderAreas = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pPerViewRenderAreas) { + pPerViewRenderAreas = new VkRect2D[copy_src->perViewRenderAreaCount]; + memcpy((void*)pPerViewRenderAreas, (void*)copy_src->pPerViewRenderAreas, + sizeof(VkRect2D) * copy_src->perViewRenderAreaCount); + } +} + +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) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM::safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM), pNext(nullptr), textureBlockMatch2() {} + +safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM::safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM( + const safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM& copy_src) { + sType = copy_src.sType; + textureBlockMatch2 = copy_src.textureBlockMatch2; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM& safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM::operator=( + const safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + textureBlockMatch2 = copy_src.textureBlockMatch2; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM::~safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM::initialize(const VkPhysicalDeviceImageProcessing2FeaturesQCOM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + textureBlockMatch2 = in_struct->textureBlockMatch2; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM::initialize( + const safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + textureBlockMatch2 = copy_src->textureBlockMatch2; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM::safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM( + const VkPhysicalDeviceImageProcessing2PropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), maxBlockMatchWindow(in_struct->maxBlockMatchWindow) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM::safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM), pNext(nullptr), maxBlockMatchWindow() {} + +safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM::safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM( + const safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM& copy_src) { + sType = copy_src.sType; + maxBlockMatchWindow = copy_src.maxBlockMatchWindow; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM& safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM::operator=( + const safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + maxBlockMatchWindow = copy_src.maxBlockMatchWindow; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM::~safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM::initialize( + const VkPhysicalDeviceImageProcessing2PropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + maxBlockMatchWindow = in_struct->maxBlockMatchWindow; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM::initialize( + const safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + maxBlockMatchWindow = copy_src->maxBlockMatchWindow; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSamplerBlockMatchWindowCreateInfoQCOM::safe_VkSamplerBlockMatchWindowCreateInfoQCOM( + const VkSamplerBlockMatchWindowCreateInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), windowExtent(in_struct->windowExtent), windowCompareMode(in_struct->windowCompareMode) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSamplerBlockMatchWindowCreateInfoQCOM::safe_VkSamplerBlockMatchWindowCreateInfoQCOM() + : sType(VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM), pNext(nullptr), windowExtent(), windowCompareMode() {} + +safe_VkSamplerBlockMatchWindowCreateInfoQCOM::safe_VkSamplerBlockMatchWindowCreateInfoQCOM( + const safe_VkSamplerBlockMatchWindowCreateInfoQCOM& copy_src) { + sType = copy_src.sType; + windowExtent = copy_src.windowExtent; + windowCompareMode = copy_src.windowCompareMode; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSamplerBlockMatchWindowCreateInfoQCOM& safe_VkSamplerBlockMatchWindowCreateInfoQCOM::operator=( + const safe_VkSamplerBlockMatchWindowCreateInfoQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + windowExtent = copy_src.windowExtent; + windowCompareMode = copy_src.windowCompareMode; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSamplerBlockMatchWindowCreateInfoQCOM::~safe_VkSamplerBlockMatchWindowCreateInfoQCOM() { FreePnextChain(pNext); } + +void safe_VkSamplerBlockMatchWindowCreateInfoQCOM::initialize(const VkSamplerBlockMatchWindowCreateInfoQCOM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + windowExtent = in_struct->windowExtent; + windowCompareMode = in_struct->windowCompareMode; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSamplerBlockMatchWindowCreateInfoQCOM::initialize(const safe_VkSamplerBlockMatchWindowCreateInfoQCOM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + windowExtent = copy_src->windowExtent; + windowCompareMode = copy_src->windowCompareMode; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM::safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM( + const VkPhysicalDeviceCubicWeightsFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), selectableCubicWeights(in_struct->selectableCubicWeights) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM::safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM), pNext(nullptr), selectableCubicWeights() {} + +safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM::safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM( + const safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM& copy_src) { + sType = copy_src.sType; + selectableCubicWeights = copy_src.selectableCubicWeights; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM& safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM::operator=( + const safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + selectableCubicWeights = copy_src.selectableCubicWeights; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM::~safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM::initialize(const VkPhysicalDeviceCubicWeightsFeaturesQCOM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + selectableCubicWeights = in_struct->selectableCubicWeights; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM::initialize(const safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + selectableCubicWeights = copy_src->selectableCubicWeights; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSamplerCubicWeightsCreateInfoQCOM::safe_VkSamplerCubicWeightsCreateInfoQCOM( + const VkSamplerCubicWeightsCreateInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), cubicWeights(in_struct->cubicWeights) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSamplerCubicWeightsCreateInfoQCOM::safe_VkSamplerCubicWeightsCreateInfoQCOM() + : sType(VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM), pNext(nullptr), cubicWeights() {} + +safe_VkSamplerCubicWeightsCreateInfoQCOM::safe_VkSamplerCubicWeightsCreateInfoQCOM( + const safe_VkSamplerCubicWeightsCreateInfoQCOM& copy_src) { + sType = copy_src.sType; + cubicWeights = copy_src.cubicWeights; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSamplerCubicWeightsCreateInfoQCOM& safe_VkSamplerCubicWeightsCreateInfoQCOM::operator=( + const safe_VkSamplerCubicWeightsCreateInfoQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + cubicWeights = copy_src.cubicWeights; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSamplerCubicWeightsCreateInfoQCOM::~safe_VkSamplerCubicWeightsCreateInfoQCOM() { FreePnextChain(pNext); } + +void safe_VkSamplerCubicWeightsCreateInfoQCOM::initialize(const VkSamplerCubicWeightsCreateInfoQCOM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + cubicWeights = in_struct->cubicWeights; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSamplerCubicWeightsCreateInfoQCOM::initialize(const safe_VkSamplerCubicWeightsCreateInfoQCOM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + cubicWeights = copy_src->cubicWeights; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkBlitImageCubicWeightsInfoQCOM::safe_VkBlitImageCubicWeightsInfoQCOM(const VkBlitImageCubicWeightsInfoQCOM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), cubicWeights(in_struct->cubicWeights) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkBlitImageCubicWeightsInfoQCOM::safe_VkBlitImageCubicWeightsInfoQCOM() + : sType(VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM), pNext(nullptr), cubicWeights() {} + +safe_VkBlitImageCubicWeightsInfoQCOM::safe_VkBlitImageCubicWeightsInfoQCOM(const safe_VkBlitImageCubicWeightsInfoQCOM& copy_src) { + sType = copy_src.sType; + cubicWeights = copy_src.cubicWeights; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkBlitImageCubicWeightsInfoQCOM& safe_VkBlitImageCubicWeightsInfoQCOM::operator=( + const safe_VkBlitImageCubicWeightsInfoQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + cubicWeights = copy_src.cubicWeights; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkBlitImageCubicWeightsInfoQCOM::~safe_VkBlitImageCubicWeightsInfoQCOM() { FreePnextChain(pNext); } + +void safe_VkBlitImageCubicWeightsInfoQCOM::initialize(const VkBlitImageCubicWeightsInfoQCOM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + cubicWeights = in_struct->cubicWeights; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkBlitImageCubicWeightsInfoQCOM::initialize(const safe_VkBlitImageCubicWeightsInfoQCOM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + cubicWeights = copy_src->cubicWeights; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM::safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM( + const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), ycbcrDegamma(in_struct->ycbcrDegamma) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM::safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM), pNext(nullptr), ycbcrDegamma() {} + +safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM::safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM( + const safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM& copy_src) { + sType = copy_src.sType; + ycbcrDegamma = copy_src.ycbcrDegamma; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM& safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM::operator=( + const safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + ycbcrDegamma = copy_src.ycbcrDegamma; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM::~safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM::initialize(const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + ycbcrDegamma = in_struct->ycbcrDegamma; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM::initialize(const safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + ycbcrDegamma = copy_src->ycbcrDegamma; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM( + const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), enableYDegamma(in_struct->enableYDegamma), enableCbCrDegamma(in_struct->enableCbCrDegamma) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM() + : sType(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM), + pNext(nullptr), + enableYDegamma(), + enableCbCrDegamma() {} + +safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM( + const safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& copy_src) { + sType = copy_src.sType; + enableYDegamma = copy_src.enableYDegamma; + enableCbCrDegamma = copy_src.enableCbCrDegamma; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::operator=( + const safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + enableYDegamma = copy_src.enableYDegamma; + enableCbCrDegamma = copy_src.enableCbCrDegamma; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::~safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM() { + FreePnextChain(pNext); +} + +void safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::initialize( + const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + enableYDegamma = in_struct->enableYDegamma; + enableCbCrDegamma = in_struct->enableCbCrDegamma; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::initialize( + const safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + enableYDegamma = copy_src->enableYDegamma; + enableCbCrDegamma = copy_src->enableCbCrDegamma; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceCubicClampFeaturesQCOM::safe_VkPhysicalDeviceCubicClampFeaturesQCOM( + const VkPhysicalDeviceCubicClampFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), cubicRangeClamp(in_struct->cubicRangeClamp) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceCubicClampFeaturesQCOM::safe_VkPhysicalDeviceCubicClampFeaturesQCOM() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM), pNext(nullptr), cubicRangeClamp() {} + +safe_VkPhysicalDeviceCubicClampFeaturesQCOM::safe_VkPhysicalDeviceCubicClampFeaturesQCOM( + const safe_VkPhysicalDeviceCubicClampFeaturesQCOM& copy_src) { + sType = copy_src.sType; + cubicRangeClamp = copy_src.cubicRangeClamp; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceCubicClampFeaturesQCOM& safe_VkPhysicalDeviceCubicClampFeaturesQCOM::operator=( + const safe_VkPhysicalDeviceCubicClampFeaturesQCOM& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + cubicRangeClamp = copy_src.cubicRangeClamp; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceCubicClampFeaturesQCOM::~safe_VkPhysicalDeviceCubicClampFeaturesQCOM() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceCubicClampFeaturesQCOM::initialize(const VkPhysicalDeviceCubicClampFeaturesQCOM* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + cubicRangeClamp = in_struct->cubicRangeClamp; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceCubicClampFeaturesQCOM::initialize(const safe_VkPhysicalDeviceCubicClampFeaturesQCOM* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + cubicRangeClamp = copy_src->cubicRangeClamp; + pNext = SafePnextCopy(copy_src->pNext); +} +#ifdef VK_USE_PLATFORM_SCREEN_QNX + +safe_VkScreenBufferPropertiesQNX::safe_VkScreenBufferPropertiesQNX(const VkScreenBufferPropertiesQNX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), allocationSize(in_struct->allocationSize), memoryTypeBits(in_struct->memoryTypeBits) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkScreenBufferPropertiesQNX::safe_VkScreenBufferPropertiesQNX() + : sType(VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX), pNext(nullptr), allocationSize(), memoryTypeBits() {} + +safe_VkScreenBufferPropertiesQNX::safe_VkScreenBufferPropertiesQNX(const safe_VkScreenBufferPropertiesQNX& copy_src) { + sType = copy_src.sType; + allocationSize = copy_src.allocationSize; + memoryTypeBits = copy_src.memoryTypeBits; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkScreenBufferPropertiesQNX& safe_VkScreenBufferPropertiesQNX::operator=(const safe_VkScreenBufferPropertiesQNX& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + allocationSize = copy_src.allocationSize; + memoryTypeBits = copy_src.memoryTypeBits; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkScreenBufferPropertiesQNX::~safe_VkScreenBufferPropertiesQNX() { FreePnextChain(pNext); } + +void safe_VkScreenBufferPropertiesQNX::initialize(const VkScreenBufferPropertiesQNX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + allocationSize = in_struct->allocationSize; + memoryTypeBits = in_struct->memoryTypeBits; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkScreenBufferPropertiesQNX::initialize(const safe_VkScreenBufferPropertiesQNX* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + allocationSize = copy_src->allocationSize; + memoryTypeBits = copy_src->memoryTypeBits; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkScreenBufferFormatPropertiesQNX::safe_VkScreenBufferFormatPropertiesQNX(const VkScreenBufferFormatPropertiesQNX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + format(in_struct->format), + externalFormat(in_struct->externalFormat), + screenUsage(in_struct->screenUsage), + formatFeatures(in_struct->formatFeatures), + samplerYcbcrConversionComponents(in_struct->samplerYcbcrConversionComponents), + suggestedYcbcrModel(in_struct->suggestedYcbcrModel), + suggestedYcbcrRange(in_struct->suggestedYcbcrRange), + suggestedXChromaOffset(in_struct->suggestedXChromaOffset), + suggestedYChromaOffset(in_struct->suggestedYChromaOffset) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkScreenBufferFormatPropertiesQNX::safe_VkScreenBufferFormatPropertiesQNX() + : sType(VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX), + pNext(nullptr), + format(), + externalFormat(), + screenUsage(), + formatFeatures(), + samplerYcbcrConversionComponents(), + suggestedYcbcrModel(), + suggestedYcbcrRange(), + suggestedXChromaOffset(), + suggestedYChromaOffset() {} + +safe_VkScreenBufferFormatPropertiesQNX::safe_VkScreenBufferFormatPropertiesQNX( + const safe_VkScreenBufferFormatPropertiesQNX& copy_src) { + sType = copy_src.sType; + format = copy_src.format; + externalFormat = copy_src.externalFormat; + screenUsage = copy_src.screenUsage; + formatFeatures = copy_src.formatFeatures; + samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents; + suggestedYcbcrModel = copy_src.suggestedYcbcrModel; + suggestedYcbcrRange = copy_src.suggestedYcbcrRange; + suggestedXChromaOffset = copy_src.suggestedXChromaOffset; + suggestedYChromaOffset = copy_src.suggestedYChromaOffset; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkScreenBufferFormatPropertiesQNX& safe_VkScreenBufferFormatPropertiesQNX::operator=( + const safe_VkScreenBufferFormatPropertiesQNX& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + format = copy_src.format; + externalFormat = copy_src.externalFormat; + screenUsage = copy_src.screenUsage; + formatFeatures = copy_src.formatFeatures; + samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents; + suggestedYcbcrModel = copy_src.suggestedYcbcrModel; + suggestedYcbcrRange = copy_src.suggestedYcbcrRange; + suggestedXChromaOffset = copy_src.suggestedXChromaOffset; + suggestedYChromaOffset = copy_src.suggestedYChromaOffset; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkScreenBufferFormatPropertiesQNX::~safe_VkScreenBufferFormatPropertiesQNX() { FreePnextChain(pNext); } + +void safe_VkScreenBufferFormatPropertiesQNX::initialize(const VkScreenBufferFormatPropertiesQNX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + format = in_struct->format; + externalFormat = in_struct->externalFormat; + screenUsage = in_struct->screenUsage; + formatFeatures = in_struct->formatFeatures; + samplerYcbcrConversionComponents = in_struct->samplerYcbcrConversionComponents; + suggestedYcbcrModel = in_struct->suggestedYcbcrModel; + suggestedYcbcrRange = in_struct->suggestedYcbcrRange; + suggestedXChromaOffset = in_struct->suggestedXChromaOffset; + suggestedYChromaOffset = in_struct->suggestedYChromaOffset; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkScreenBufferFormatPropertiesQNX::initialize(const safe_VkScreenBufferFormatPropertiesQNX* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + format = copy_src->format; + externalFormat = copy_src->externalFormat; + screenUsage = copy_src->screenUsage; + formatFeatures = copy_src->formatFeatures; + samplerYcbcrConversionComponents = copy_src->samplerYcbcrConversionComponents; + suggestedYcbcrModel = copy_src->suggestedYcbcrModel; + suggestedYcbcrRange = copy_src->suggestedYcbcrRange; + suggestedXChromaOffset = copy_src->suggestedXChromaOffset; + suggestedYChromaOffset = copy_src->suggestedYChromaOffset; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkImportScreenBufferInfoQNX::safe_VkImportScreenBufferInfoQNX(const VkImportScreenBufferInfoQNX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), buffer(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->buffer) { + buffer = new _screen_buffer(*in_struct->buffer); + } +} + +safe_VkImportScreenBufferInfoQNX::safe_VkImportScreenBufferInfoQNX() + : sType(VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX), pNext(nullptr), buffer(nullptr) {} + +safe_VkImportScreenBufferInfoQNX::safe_VkImportScreenBufferInfoQNX(const safe_VkImportScreenBufferInfoQNX& copy_src) { + sType = copy_src.sType; + buffer = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.buffer) { + buffer = new _screen_buffer(*copy_src.buffer); + } +} + +safe_VkImportScreenBufferInfoQNX& safe_VkImportScreenBufferInfoQNX::operator=(const safe_VkImportScreenBufferInfoQNX& copy_src) { + if (©_src == this) return *this; + + if (buffer) delete buffer; + FreePnextChain(pNext); + + sType = copy_src.sType; + buffer = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.buffer) { + buffer = new _screen_buffer(*copy_src.buffer); + } + + return *this; +} + +safe_VkImportScreenBufferInfoQNX::~safe_VkImportScreenBufferInfoQNX() { + if (buffer) delete buffer; + FreePnextChain(pNext); +} + +void safe_VkImportScreenBufferInfoQNX::initialize(const VkImportScreenBufferInfoQNX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (buffer) delete buffer; + FreePnextChain(pNext); + sType = in_struct->sType; + buffer = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->buffer) { + buffer = new _screen_buffer(*in_struct->buffer); + } +} + +void safe_VkImportScreenBufferInfoQNX::initialize(const safe_VkImportScreenBufferInfoQNX* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + buffer = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->buffer) { + buffer = new _screen_buffer(*copy_src->buffer); + } +} + +safe_VkExternalFormatQNX::safe_VkExternalFormatQNX(const VkExternalFormatQNX* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), externalFormat(in_struct->externalFormat) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkExternalFormatQNX::safe_VkExternalFormatQNX() + : sType(VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX), pNext(nullptr), externalFormat() {} + +safe_VkExternalFormatQNX::safe_VkExternalFormatQNX(const safe_VkExternalFormatQNX& copy_src) { + sType = copy_src.sType; + externalFormat = copy_src.externalFormat; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkExternalFormatQNX& safe_VkExternalFormatQNX::operator=(const safe_VkExternalFormatQNX& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + externalFormat = copy_src.externalFormat; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkExternalFormatQNX::~safe_VkExternalFormatQNX() { FreePnextChain(pNext); } + +void safe_VkExternalFormatQNX::initialize(const VkExternalFormatQNX* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + externalFormat = in_struct->externalFormat; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkExternalFormatQNX::initialize(const safe_VkExternalFormatQNX* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + externalFormat = copy_src->externalFormat; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX( + const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), screenBufferImport(in_struct->screenBufferImport) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX), pNext(nullptr), screenBufferImport() {} + +safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX( + const safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& copy_src) { + sType = copy_src.sType; + screenBufferImport = copy_src.screenBufferImport; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::operator=( + const safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + screenBufferImport = copy_src.screenBufferImport; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::~safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::initialize( + const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + screenBufferImport = in_struct->screenBufferImport; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::initialize( + const safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + screenBufferImport = copy_src->screenBufferImport; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_USE_PLATFORM_SCREEN_QNX + +safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT( + const VkPhysicalDeviceLayeredDriverPropertiesMSFT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), underlyingAPI(in_struct->underlyingAPI) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT), pNext(nullptr), underlyingAPI() {} + +safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT( + const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT& copy_src) { + sType = copy_src.sType; + underlyingAPI = copy_src.underlyingAPI; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT& safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::operator=( + const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + underlyingAPI = copy_src.underlyingAPI; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::~safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::initialize(const VkPhysicalDeviceLayeredDriverPropertiesMSFT* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + underlyingAPI = in_struct->underlyingAPI; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::initialize(const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + underlyingAPI = copy_src->underlyingAPI; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV( + const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), descriptorPoolOverallocation(in_struct->descriptorPoolOverallocation) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV), + pNext(nullptr), + descriptorPoolOverallocation() {} + +safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV( + const safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV& copy_src) { + sType = copy_src.sType; + descriptorPoolOverallocation = copy_src.descriptorPoolOverallocation; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV& safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::operator=( + const safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + descriptorPoolOverallocation = copy_src.descriptorPoolOverallocation; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::~safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::initialize( + const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + descriptorPoolOverallocation = in_struct->descriptorPoolOverallocation; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::initialize( + const safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + descriptorPoolOverallocation = copy_src->descriptorPoolOverallocation; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::safe_VkPhysicalDeviceRawAccessChainsFeaturesNV( + const VkPhysicalDeviceRawAccessChainsFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), shaderRawAccessChains(in_struct->shaderRawAccessChains) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::safe_VkPhysicalDeviceRawAccessChainsFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV), pNext(nullptr), shaderRawAccessChains() {} + +safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::safe_VkPhysicalDeviceRawAccessChainsFeaturesNV( + const safe_VkPhysicalDeviceRawAccessChainsFeaturesNV& copy_src) { + sType = copy_src.sType; + shaderRawAccessChains = copy_src.shaderRawAccessChains; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceRawAccessChainsFeaturesNV& safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::operator=( + const safe_VkPhysicalDeviceRawAccessChainsFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderRawAccessChains = copy_src.shaderRawAccessChains; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::~safe_VkPhysicalDeviceRawAccessChainsFeaturesNV() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::initialize(const VkPhysicalDeviceRawAccessChainsFeaturesNV* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderRawAccessChains = in_struct->shaderRawAccessChains; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::initialize(const safe_VkPhysicalDeviceRawAccessChainsFeaturesNV* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderRawAccessChains = copy_src->shaderRawAccessChains; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV( + const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), shaderFloat16VectorAtomics(in_struct->shaderFloat16VectorAtomics) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV), + pNext(nullptr), + shaderFloat16VectorAtomics() {} + +safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV( + const safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& copy_src) { + sType = copy_src.sType; + shaderFloat16VectorAtomics = copy_src.shaderFloat16VectorAtomics; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::operator=( + const safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderFloat16VectorAtomics = copy_src.shaderFloat16VectorAtomics; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::~safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::initialize( + const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderFloat16VectorAtomics = in_struct->shaderFloat16VectorAtomics; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::initialize( + const safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderFloat16VectorAtomics = copy_src->shaderFloat16VectorAtomics; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceRayTracingValidationFeaturesNV::safe_VkPhysicalDeviceRayTracingValidationFeaturesNV( + const VkPhysicalDeviceRayTracingValidationFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), rayTracingValidation(in_struct->rayTracingValidation) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceRayTracingValidationFeaturesNV::safe_VkPhysicalDeviceRayTracingValidationFeaturesNV() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV), pNext(nullptr), rayTracingValidation() {} + +safe_VkPhysicalDeviceRayTracingValidationFeaturesNV::safe_VkPhysicalDeviceRayTracingValidationFeaturesNV( + const safe_VkPhysicalDeviceRayTracingValidationFeaturesNV& copy_src) { + sType = copy_src.sType; + rayTracingValidation = copy_src.rayTracingValidation; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceRayTracingValidationFeaturesNV& safe_VkPhysicalDeviceRayTracingValidationFeaturesNV::operator=( + const safe_VkPhysicalDeviceRayTracingValidationFeaturesNV& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + rayTracingValidation = copy_src.rayTracingValidation; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceRayTracingValidationFeaturesNV::~safe_VkPhysicalDeviceRayTracingValidationFeaturesNV() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceRayTracingValidationFeaturesNV::initialize( + const VkPhysicalDeviceRayTracingValidationFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + rayTracingValidation = in_struct->rayTracingValidation; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceRayTracingValidationFeaturesNV::initialize( + const safe_VkPhysicalDeviceRayTracingValidationFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + rayTracingValidation = copy_src->rayTracingValidation; + pNext = SafePnextCopy(copy_src->pNext); +} + +} // namespace vku + +// NOLINTEND diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 3bf1283..12b40df 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -16,6 +16,7 @@ target_include_directories(vul_tests PRIVATE ) target_sources(vul_tests PRIVATE + safe_struct.cpp struct_helper.cpp test_formats.cpp test_interface.cpp @@ -35,6 +36,7 @@ target_link_libraries(vul_tests PRIVATE Vulkan::UtilityHeaders Vulkan::LayerSettings Vulkan::CompilerConfiguration + Vulkan::SafeStruct ) # Test add_subdirectory suppport diff --git a/tests/safe_struct.cpp b/tests/safe_struct.cpp new file mode 100644 index 0000000..4af6640 --- /dev/null +++ b/tests/safe_struct.cpp @@ -0,0 +1,239 @@ +// Copyright 2023 The Khronos Group Inc. +// Copyright 2023 Valve Corporation +// Copyright 2023 LunarG, Inc. +// +// SPDX-License-Identifier: Apache-2.0 +// + +#include +#include +#include +#include + +TEST(safe_struct, basic) { + vku::safe_VkInstanceCreateInfo safe_info; + { + VkApplicationInfo app = vku::InitStructHelper(); + app.pApplicationName = "test"; + app.applicationVersion = 42; + + VkDebugUtilsMessengerCreateInfoEXT debug_ci = vku::InitStructHelper(); + debug_ci.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; + + VkInstanceCreateInfo info = vku::InitStructHelper(); + info.pApplicationInfo = &app; + info.pNext = &debug_ci; + + safe_info.initialize(&info); + + memset(&info, 0x11, sizeof(info)); + memset(&app, 0x22, sizeof(app)); + memset(&debug_ci, 0x33, sizeof(debug_ci)); + } + ASSERT_EQ(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, safe_info.sType); + ASSERT_EQ(0, strcmp("test", safe_info.pApplicationInfo->pApplicationName)); + ASSERT_EQ(42, safe_info.pApplicationInfo->applicationVersion); + + auto debug_ci = vku::FindStructInPNextChain(safe_info.pNext); + ASSERT_NE(nullptr, debug_ci); + ASSERT_EQ(VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT, debug_ci->messageSeverity); +} + +TEST(safe_struct, safe_void_pointer_copies) { + // vku::safe_VkSpecializationInfo, constructor + { + std::vector data(20, std::byte{0b11110000}); + + VkSpecializationInfo info = {}; + info.dataSize = uint32_t(data.size()); + info.pData = data.data(); + + vku::safe_VkSpecializationInfo safe(&info); + + ASSERT_TRUE(safe.pData != info.pData); + ASSERT_TRUE(safe.dataSize == info.dataSize); + + data.clear(); // Invalidate any references, pointers, or iterators referring to contained elements. + + auto copied_bytes = reinterpret_cast(safe.pData); + ASSERT_TRUE(copied_bytes[19] == std::byte{0b11110000}); + } + + // vku::safe_VkPipelineExecutableInternalRepresentationKHR, initialize + { + std::vector data(11, std::byte{0b01001001}); + + VkPipelineExecutableInternalRepresentationKHR info = {}; + info.dataSize = uint32_t(data.size()); + info.pData = data.data(); + + vku::safe_VkPipelineExecutableInternalRepresentationKHR safe; + + safe.initialize(&info); + + ASSERT_TRUE(safe.dataSize == info.dataSize); + ASSERT_TRUE(safe.pData != info.pData); + + data.clear(); // Invalidate any references, pointers, or iterators referring to contained elements. + + auto copied_bytes = reinterpret_cast(safe.pData); + ASSERT_TRUE(copied_bytes[10] == std::byte{0b01001001}); + } +} + +TEST(safe_struct, custom_safe_pnext_copy) { + // This tests an additional "copy_state" parameter in the SafePNextCopy function that allows "customizing" safe_* struct + // construction.. This is required for structs such as VkPipelineRenderingCreateInfo (which extend VkGraphicsPipelineCreateInfo) + // whose members must be partially ignored depending on the graphics sub-state present. + + VkFormat format = VK_FORMAT_B8G8R8A8_UNORM; + VkPipelineRenderingCreateInfo pri = vku::InitStructHelper(); + pri.colorAttachmentCount = 1; + pri.pColorAttachmentFormats = &format; + + bool ignore_default_construction = true; + vku::PNextCopyState copy_state = { + [&ignore_default_construction](VkBaseOutStructure *safe_struct, + [[maybe_unused]] const VkBaseOutStructure *in_struct) -> bool { + if (ignore_default_construction) { + auto tmp = reinterpret_cast(safe_struct); + tmp->colorAttachmentCount = 0; + tmp->pColorAttachmentFormats = nullptr; + return true; + } + return false; + }, + }; + + { + VkGraphicsPipelineCreateInfo gpci = vku::InitStructHelper(&pri); + vku::safe_VkGraphicsPipelineCreateInfo safe_gpci(&gpci, false, false, ©_state); + + auto safe_pri = reinterpret_cast(safe_gpci.pNext); + // Ensure original input struct was not modified + ASSERT_EQ(pri.colorAttachmentCount, 1); + ASSERT_EQ(pri.pColorAttachmentFormats, &format); + + // Ensure safe struct was modified + ASSERT_EQ(safe_pri->colorAttachmentCount, 0); + ASSERT_EQ(safe_pri->pColorAttachmentFormats, nullptr); + } + + // Ensure PNextCopyState::init is also applied when there is more than one element in the pNext chain + { + VkGraphicsPipelineLibraryCreateInfoEXT gpl_info = vku::InitStructHelper(&pri); + VkGraphicsPipelineCreateInfo gpci = vku::InitStructHelper(&gpl_info); + + vku::safe_VkGraphicsPipelineCreateInfo safe_gpci(&gpci, false, false, ©_state); + + auto safe_gpl_info = reinterpret_cast(safe_gpci.pNext); + auto safe_pri = reinterpret_cast(safe_gpl_info->pNext); + // Ensure original input struct was not modified + ASSERT_EQ(pri.colorAttachmentCount, 1); + ASSERT_EQ(pri.pColorAttachmentFormats, &format); + + // Ensure safe struct was modified + ASSERT_EQ(safe_pri->colorAttachmentCount, 0); + ASSERT_EQ(safe_pri->pColorAttachmentFormats, nullptr); + } + + // Check that signaling to use the default constructor works + { + pri.colorAttachmentCount = 1; + pri.pColorAttachmentFormats = &format; + + ignore_default_construction = false; + VkGraphicsPipelineCreateInfo gpci = vku::InitStructHelper(&pri); + vku::safe_VkGraphicsPipelineCreateInfo safe_gpci(&gpci, false, false, ©_state); + + auto safe_pri = reinterpret_cast(safe_gpci.pNext); + // Ensure original input struct was not modified + ASSERT_EQ(pri.colorAttachmentCount, 1); + ASSERT_EQ(pri.pColorAttachmentFormats, &format); + + // Ensure safe struct was modified + ASSERT_EQ(safe_pri->colorAttachmentCount, 1); + ASSERT_EQ(*safe_pri->pColorAttachmentFormats, format); + } +} + +TEST(safe_struct, extension_add_remove) { + std::array extensions{ + "VK_KHR_maintenance1", "VK_KHR_maintenance2", "VK_KHR_maintenance3", + "VK_KHR_maintenance4", "VK_KHR_maintenance5", "VK_KHR_maintenance6", + }; + VkDeviceCreateInfo ci = vku::InitStructHelper(); + ci.ppEnabledExtensionNames = extensions.data(); + ci.enabledExtensionCount = static_cast(extensions.size()); + + vku::safe_VkDeviceCreateInfo safe_ci(&ci); + ASSERT_EQ(3, vku::FindExtension(safe_ci, "VK_KHR_maintenance4")); + ASSERT_EQ(safe_ci.enabledExtensionCount, vku::FindExtension(safe_ci, "VK_KHR_maintenance0")); + + ASSERT_EQ(false, vku::RemoveExtension(safe_ci, "VK_KHR_maintenance0")); + ASSERT_EQ(true, vku::AddExtension(safe_ci, "VK_KHR_maintenance0")); + + ASSERT_EQ(true, vku::RemoveExtension(safe_ci, "VK_KHR_maintenance0")); + for (const auto &ext : extensions) { + ASSERT_EQ(true, vku::RemoveExtension(safe_ci, ext)); + } + ASSERT_EQ(false, vku::RemoveExtension(safe_ci, "VK_KHR_maintenance0")); + + ASSERT_EQ(0, safe_ci.enabledExtensionCount); + ASSERT_EQ(nullptr, safe_ci.ppEnabledExtensionNames); + + for (const auto &ext : extensions) { + ASSERT_EQ(true, vku::AddExtension(safe_ci, ext)); + } + ASSERT_EQ(extensions.size(), safe_ci.enabledExtensionCount); +} + +TEST(safe_struct, pnext_add_remove) { + VkPhysicalDeviceRayTracingPipelineFeaturesKHR rtp = vku::InitStructHelper(); + VkPhysicalDeviceRayQueryFeaturesKHR rtq = vku::InitStructHelper(&rtp); + VkPhysicalDeviceMeshShaderFeaturesEXT mesh = vku::InitStructHelper(&rtq); + VkPhysicalDeviceFeatures2 features = vku::InitStructHelper(&mesh); + + vku::safe_VkPhysicalDeviceFeatures2 sf(&features); + + // unlink the structs so they can be added one at a time. + rtp.pNext = nullptr; + rtq.pNext = nullptr; + mesh.pNext = nullptr; + + ASSERT_EQ(true, vku::RemoveFromPnext(sf, rtq.sType)); + ASSERT_EQ(nullptr, vku::FindStructInPNextChain(sf.pNext)); + ASSERT_EQ(false, vku::RemoveFromPnext(sf, rtq.sType)); + + ASSERT_EQ(true, vku::RemoveFromPnext(sf, rtp.sType)); + ASSERT_EQ(nullptr, vku::FindStructInPNextChain(sf.pNext)); + + ASSERT_EQ(true, vku::RemoveFromPnext(sf, mesh.sType)); + ASSERT_EQ(nullptr, vku::FindStructInPNextChain(sf.pNext)); + + ASSERT_EQ(nullptr, sf.pNext); + ASSERT_EQ(true, vku::AddToPnext(sf, mesh)); + ASSERT_EQ(false, vku::AddToPnext(sf, mesh)); + ASSERT_NE(nullptr, vku::FindStructInPNextChain(sf.pNext)); + + ASSERT_EQ(true, vku::AddToPnext(sf, rtq)); + ASSERT_EQ(false, vku::AddToPnext(sf, rtq)); + ASSERT_NE(nullptr, vku::FindStructInPNextChain(sf.pNext)); + + ASSERT_EQ(true, vku::AddToPnext(sf, rtp)); + ASSERT_EQ(false, vku::AddToPnext(sf, rtp)); + ASSERT_NE(nullptr, vku::FindStructInPNextChain(sf.pNext)); + + ASSERT_EQ(true, vku::RemoveFromPnext(sf, mesh.sType)); + ASSERT_EQ(true, vku::RemoveFromPnext(sf, rtp.sType)); + ASSERT_EQ(true, vku::RemoveFromPnext(sf, rtq.sType)); + + // relink the structs so they can be added all at once + rtq.pNext = &rtp; + mesh.pNext = &rtq; + + ASSERT_EQ(true, vku::AddToPnext(sf, mesh)); + ASSERT_NE(nullptr, vku::FindStructInPNextChain(sf.pNext)); + ASSERT_NE(nullptr, vku::FindStructInPNextChain(sf.pNext)); + ASSERT_NE(nullptr, vku::FindStructInPNextChain(sf.pNext)); +}