1 // *** THIS FILE IS GENERATED - DO NOT EDIT *** 2 // See helper_file_generator.py for modifications 3 4 5 /*************************************************************************** 6 * 7 * Copyright (c) 2015-2020 The Khronos Group Inc. 8 * Copyright (c) 2015-2020 Valve Corporation 9 * Copyright (c) 2015-2020 LunarG, Inc. 10 * Copyright (c) 2015-2020 Google Inc. 11 * 12 * Licensed under the Apache License, Version 2.0 (the "License"); 13 * you may not use this file except in compliance with the License. 14 * You may obtain a copy of the License at 15 * 16 * http://www.apache.org/licenses/LICENSE-2.0 17 * 18 * Unless required by applicable law or agreed to in writing, software 19 * distributed under the License is distributed on an "AS IS" BASIS, 20 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 21 * See the License for the specific language governing permissions and 22 * limitations under the License. 23 * 24 * Author: Mark Lobodzinski <mark@lunarg.com> 25 * Author: Courtney Goeltzenleuchter <courtneygo@google.com> 26 * Author: Tobin Ehlis <tobine@google.com> 27 * Author: Chris Forbes <chrisforbes@google.com> 28 * Author: John Zulauf<jzulauf@lunarg.com> 29 * 30 ****************************************************************************/ 31 32 33 #pragma once 34 #include <vulkan/vulkan.h> 35 #include <stdlib.h> 36 37 void *SafePnextCopy(const void *pNext); 38 void FreePnextChain(const void *pNext); 39 char *SafeStringCopy(const char *in_string); 40 41 42 struct safe_VkBufferMemoryBarrier { 43 VkStructureType sType; 44 const void* pNext; 45 VkAccessFlags srcAccessMask; 46 VkAccessFlags dstAccessMask; 47 uint32_t srcQueueFamilyIndex; 48 uint32_t dstQueueFamilyIndex; 49 VkBuffer buffer; 50 VkDeviceSize offset; 51 VkDeviceSize size; 52 safe_VkBufferMemoryBarrier(const VkBufferMemoryBarrier* in_struct); 53 safe_VkBufferMemoryBarrier(const safe_VkBufferMemoryBarrier& copy_src); 54 safe_VkBufferMemoryBarrier& operator=(const safe_VkBufferMemoryBarrier& copy_src); 55 safe_VkBufferMemoryBarrier(); 56 ~safe_VkBufferMemoryBarrier(); 57 void initialize(const VkBufferMemoryBarrier* in_struct); 58 void initialize(const safe_VkBufferMemoryBarrier* copy_src); ptrsafe_VkBufferMemoryBarrier59 VkBufferMemoryBarrier *ptr() { return reinterpret_cast<VkBufferMemoryBarrier *>(this); } ptrsafe_VkBufferMemoryBarrier60 VkBufferMemoryBarrier const *ptr() const { return reinterpret_cast<VkBufferMemoryBarrier const *>(this); } 61 }; 62 63 struct safe_VkImageMemoryBarrier { 64 VkStructureType sType; 65 const void* pNext; 66 VkAccessFlags srcAccessMask; 67 VkAccessFlags dstAccessMask; 68 VkImageLayout oldLayout; 69 VkImageLayout newLayout; 70 uint32_t srcQueueFamilyIndex; 71 uint32_t dstQueueFamilyIndex; 72 VkImage image; 73 VkImageSubresourceRange subresourceRange; 74 safe_VkImageMemoryBarrier(const VkImageMemoryBarrier* in_struct); 75 safe_VkImageMemoryBarrier(const safe_VkImageMemoryBarrier& copy_src); 76 safe_VkImageMemoryBarrier& operator=(const safe_VkImageMemoryBarrier& copy_src); 77 safe_VkImageMemoryBarrier(); 78 ~safe_VkImageMemoryBarrier(); 79 void initialize(const VkImageMemoryBarrier* in_struct); 80 void initialize(const safe_VkImageMemoryBarrier* copy_src); ptrsafe_VkImageMemoryBarrier81 VkImageMemoryBarrier *ptr() { return reinterpret_cast<VkImageMemoryBarrier *>(this); } ptrsafe_VkImageMemoryBarrier82 VkImageMemoryBarrier const *ptr() const { return reinterpret_cast<VkImageMemoryBarrier const *>(this); } 83 }; 84 85 struct safe_VkMemoryBarrier { 86 VkStructureType sType; 87 const void* pNext; 88 VkAccessFlags srcAccessMask; 89 VkAccessFlags dstAccessMask; 90 safe_VkMemoryBarrier(const VkMemoryBarrier* in_struct); 91 safe_VkMemoryBarrier(const safe_VkMemoryBarrier& copy_src); 92 safe_VkMemoryBarrier& operator=(const safe_VkMemoryBarrier& copy_src); 93 safe_VkMemoryBarrier(); 94 ~safe_VkMemoryBarrier(); 95 void initialize(const VkMemoryBarrier* in_struct); 96 void initialize(const safe_VkMemoryBarrier* copy_src); ptrsafe_VkMemoryBarrier97 VkMemoryBarrier *ptr() { return reinterpret_cast<VkMemoryBarrier *>(this); } ptrsafe_VkMemoryBarrier98 VkMemoryBarrier const *ptr() const { return reinterpret_cast<VkMemoryBarrier const *>(this); } 99 }; 100 101 struct safe_VkAllocationCallbacks { 102 void* pUserData; 103 PFN_vkAllocationFunction pfnAllocation; 104 PFN_vkReallocationFunction pfnReallocation; 105 PFN_vkFreeFunction pfnFree; 106 PFN_vkInternalAllocationNotification pfnInternalAllocation; 107 PFN_vkInternalFreeNotification pfnInternalFree; 108 safe_VkAllocationCallbacks(const VkAllocationCallbacks* in_struct); 109 safe_VkAllocationCallbacks(const safe_VkAllocationCallbacks& copy_src); 110 safe_VkAllocationCallbacks& operator=(const safe_VkAllocationCallbacks& copy_src); 111 safe_VkAllocationCallbacks(); 112 ~safe_VkAllocationCallbacks(); 113 void initialize(const VkAllocationCallbacks* in_struct); 114 void initialize(const safe_VkAllocationCallbacks* copy_src); ptrsafe_VkAllocationCallbacks115 VkAllocationCallbacks *ptr() { return reinterpret_cast<VkAllocationCallbacks *>(this); } ptrsafe_VkAllocationCallbacks116 VkAllocationCallbacks const *ptr() const { return reinterpret_cast<VkAllocationCallbacks const *>(this); } 117 }; 118 119 struct safe_VkApplicationInfo { 120 VkStructureType sType; 121 const void* pNext; 122 const char* pApplicationName; 123 uint32_t applicationVersion; 124 const char* pEngineName; 125 uint32_t engineVersion; 126 uint32_t apiVersion; 127 safe_VkApplicationInfo(const VkApplicationInfo* in_struct); 128 safe_VkApplicationInfo(const safe_VkApplicationInfo& copy_src); 129 safe_VkApplicationInfo& operator=(const safe_VkApplicationInfo& copy_src); 130 safe_VkApplicationInfo(); 131 ~safe_VkApplicationInfo(); 132 void initialize(const VkApplicationInfo* in_struct); 133 void initialize(const safe_VkApplicationInfo* copy_src); ptrsafe_VkApplicationInfo134 VkApplicationInfo *ptr() { return reinterpret_cast<VkApplicationInfo *>(this); } ptrsafe_VkApplicationInfo135 VkApplicationInfo const *ptr() const { return reinterpret_cast<VkApplicationInfo const *>(this); } 136 }; 137 138 struct safe_VkInstanceCreateInfo { 139 VkStructureType sType; 140 const void* pNext; 141 VkInstanceCreateFlags flags; 142 safe_VkApplicationInfo* pApplicationInfo; 143 uint32_t enabledLayerCount; 144 const char* const* ppEnabledLayerNames; 145 uint32_t enabledExtensionCount; 146 const char* const* ppEnabledExtensionNames; 147 safe_VkInstanceCreateInfo(const VkInstanceCreateInfo* in_struct); 148 safe_VkInstanceCreateInfo(const safe_VkInstanceCreateInfo& copy_src); 149 safe_VkInstanceCreateInfo& operator=(const safe_VkInstanceCreateInfo& copy_src); 150 safe_VkInstanceCreateInfo(); 151 ~safe_VkInstanceCreateInfo(); 152 void initialize(const VkInstanceCreateInfo* in_struct); 153 void initialize(const safe_VkInstanceCreateInfo* copy_src); ptrsafe_VkInstanceCreateInfo154 VkInstanceCreateInfo *ptr() { return reinterpret_cast<VkInstanceCreateInfo *>(this); } ptrsafe_VkInstanceCreateInfo155 VkInstanceCreateInfo const *ptr() const { return reinterpret_cast<VkInstanceCreateInfo const *>(this); } 156 }; 157 158 struct safe_VkDeviceQueueCreateInfo { 159 VkStructureType sType; 160 const void* pNext; 161 VkDeviceQueueCreateFlags flags; 162 uint32_t queueFamilyIndex; 163 uint32_t queueCount; 164 const float* pQueuePriorities; 165 safe_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo* in_struct); 166 safe_VkDeviceQueueCreateInfo(const safe_VkDeviceQueueCreateInfo& copy_src); 167 safe_VkDeviceQueueCreateInfo& operator=(const safe_VkDeviceQueueCreateInfo& copy_src); 168 safe_VkDeviceQueueCreateInfo(); 169 ~safe_VkDeviceQueueCreateInfo(); 170 void initialize(const VkDeviceQueueCreateInfo* in_struct); 171 void initialize(const safe_VkDeviceQueueCreateInfo* copy_src); ptrsafe_VkDeviceQueueCreateInfo172 VkDeviceQueueCreateInfo *ptr() { return reinterpret_cast<VkDeviceQueueCreateInfo *>(this); } ptrsafe_VkDeviceQueueCreateInfo173 VkDeviceQueueCreateInfo const *ptr() const { return reinterpret_cast<VkDeviceQueueCreateInfo const *>(this); } 174 }; 175 176 struct safe_VkDeviceCreateInfo { 177 VkStructureType sType; 178 const void* pNext; 179 VkDeviceCreateFlags flags; 180 uint32_t queueCreateInfoCount; 181 safe_VkDeviceQueueCreateInfo* pQueueCreateInfos; 182 uint32_t enabledLayerCount; 183 const char* const* ppEnabledLayerNames; 184 uint32_t enabledExtensionCount; 185 const char* const* ppEnabledExtensionNames; 186 const VkPhysicalDeviceFeatures* pEnabledFeatures; 187 safe_VkDeviceCreateInfo(const VkDeviceCreateInfo* in_struct); 188 safe_VkDeviceCreateInfo(const safe_VkDeviceCreateInfo& copy_src); 189 safe_VkDeviceCreateInfo& operator=(const safe_VkDeviceCreateInfo& copy_src); 190 safe_VkDeviceCreateInfo(); 191 ~safe_VkDeviceCreateInfo(); 192 void initialize(const VkDeviceCreateInfo* in_struct); 193 void initialize(const safe_VkDeviceCreateInfo* copy_src); ptrsafe_VkDeviceCreateInfo194 VkDeviceCreateInfo *ptr() { return reinterpret_cast<VkDeviceCreateInfo *>(this); } ptrsafe_VkDeviceCreateInfo195 VkDeviceCreateInfo const *ptr() const { return reinterpret_cast<VkDeviceCreateInfo const *>(this); } 196 }; 197 198 struct safe_VkSubmitInfo { 199 VkStructureType sType; 200 const void* pNext; 201 uint32_t waitSemaphoreCount; 202 VkSemaphore* pWaitSemaphores; 203 const VkPipelineStageFlags* pWaitDstStageMask; 204 uint32_t commandBufferCount; 205 VkCommandBuffer* pCommandBuffers; 206 uint32_t signalSemaphoreCount; 207 VkSemaphore* pSignalSemaphores; 208 safe_VkSubmitInfo(const VkSubmitInfo* in_struct); 209 safe_VkSubmitInfo(const safe_VkSubmitInfo& copy_src); 210 safe_VkSubmitInfo& operator=(const safe_VkSubmitInfo& copy_src); 211 safe_VkSubmitInfo(); 212 ~safe_VkSubmitInfo(); 213 void initialize(const VkSubmitInfo* in_struct); 214 void initialize(const safe_VkSubmitInfo* copy_src); ptrsafe_VkSubmitInfo215 VkSubmitInfo *ptr() { return reinterpret_cast<VkSubmitInfo *>(this); } ptrsafe_VkSubmitInfo216 VkSubmitInfo const *ptr() const { return reinterpret_cast<VkSubmitInfo const *>(this); } 217 }; 218 219 struct safe_VkMappedMemoryRange { 220 VkStructureType sType; 221 const void* pNext; 222 VkDeviceMemory memory; 223 VkDeviceSize offset; 224 VkDeviceSize size; 225 safe_VkMappedMemoryRange(const VkMappedMemoryRange* in_struct); 226 safe_VkMappedMemoryRange(const safe_VkMappedMemoryRange& copy_src); 227 safe_VkMappedMemoryRange& operator=(const safe_VkMappedMemoryRange& copy_src); 228 safe_VkMappedMemoryRange(); 229 ~safe_VkMappedMemoryRange(); 230 void initialize(const VkMappedMemoryRange* in_struct); 231 void initialize(const safe_VkMappedMemoryRange* copy_src); ptrsafe_VkMappedMemoryRange232 VkMappedMemoryRange *ptr() { return reinterpret_cast<VkMappedMemoryRange *>(this); } ptrsafe_VkMappedMemoryRange233 VkMappedMemoryRange const *ptr() const { return reinterpret_cast<VkMappedMemoryRange const *>(this); } 234 }; 235 236 struct safe_VkMemoryAllocateInfo { 237 VkStructureType sType; 238 const void* pNext; 239 VkDeviceSize allocationSize; 240 uint32_t memoryTypeIndex; 241 safe_VkMemoryAllocateInfo(const VkMemoryAllocateInfo* in_struct); 242 safe_VkMemoryAllocateInfo(const safe_VkMemoryAllocateInfo& copy_src); 243 safe_VkMemoryAllocateInfo& operator=(const safe_VkMemoryAllocateInfo& copy_src); 244 safe_VkMemoryAllocateInfo(); 245 ~safe_VkMemoryAllocateInfo(); 246 void initialize(const VkMemoryAllocateInfo* in_struct); 247 void initialize(const safe_VkMemoryAllocateInfo* copy_src); ptrsafe_VkMemoryAllocateInfo248 VkMemoryAllocateInfo *ptr() { return reinterpret_cast<VkMemoryAllocateInfo *>(this); } ptrsafe_VkMemoryAllocateInfo249 VkMemoryAllocateInfo const *ptr() const { return reinterpret_cast<VkMemoryAllocateInfo const *>(this); } 250 }; 251 252 struct safe_VkSparseBufferMemoryBindInfo { 253 VkBuffer buffer; 254 uint32_t bindCount; 255 VkSparseMemoryBind* pBinds; 256 safe_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo* in_struct); 257 safe_VkSparseBufferMemoryBindInfo(const safe_VkSparseBufferMemoryBindInfo& copy_src); 258 safe_VkSparseBufferMemoryBindInfo& operator=(const safe_VkSparseBufferMemoryBindInfo& copy_src); 259 safe_VkSparseBufferMemoryBindInfo(); 260 ~safe_VkSparseBufferMemoryBindInfo(); 261 void initialize(const VkSparseBufferMemoryBindInfo* in_struct); 262 void initialize(const safe_VkSparseBufferMemoryBindInfo* copy_src); ptrsafe_VkSparseBufferMemoryBindInfo263 VkSparseBufferMemoryBindInfo *ptr() { return reinterpret_cast<VkSparseBufferMemoryBindInfo *>(this); } ptrsafe_VkSparseBufferMemoryBindInfo264 VkSparseBufferMemoryBindInfo const *ptr() const { return reinterpret_cast<VkSparseBufferMemoryBindInfo const *>(this); } 265 }; 266 267 struct safe_VkSparseImageOpaqueMemoryBindInfo { 268 VkImage image; 269 uint32_t bindCount; 270 VkSparseMemoryBind* pBinds; 271 safe_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo* in_struct); 272 safe_VkSparseImageOpaqueMemoryBindInfo(const safe_VkSparseImageOpaqueMemoryBindInfo& copy_src); 273 safe_VkSparseImageOpaqueMemoryBindInfo& operator=(const safe_VkSparseImageOpaqueMemoryBindInfo& copy_src); 274 safe_VkSparseImageOpaqueMemoryBindInfo(); 275 ~safe_VkSparseImageOpaqueMemoryBindInfo(); 276 void initialize(const VkSparseImageOpaqueMemoryBindInfo* in_struct); 277 void initialize(const safe_VkSparseImageOpaqueMemoryBindInfo* copy_src); ptrsafe_VkSparseImageOpaqueMemoryBindInfo278 VkSparseImageOpaqueMemoryBindInfo *ptr() { return reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo *>(this); } ptrsafe_VkSparseImageOpaqueMemoryBindInfo279 VkSparseImageOpaqueMemoryBindInfo const *ptr() const { return reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo const *>(this); } 280 }; 281 282 struct safe_VkSparseImageMemoryBindInfo { 283 VkImage image; 284 uint32_t bindCount; 285 VkSparseImageMemoryBind* pBinds; 286 safe_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo* in_struct); 287 safe_VkSparseImageMemoryBindInfo(const safe_VkSparseImageMemoryBindInfo& copy_src); 288 safe_VkSparseImageMemoryBindInfo& operator=(const safe_VkSparseImageMemoryBindInfo& copy_src); 289 safe_VkSparseImageMemoryBindInfo(); 290 ~safe_VkSparseImageMemoryBindInfo(); 291 void initialize(const VkSparseImageMemoryBindInfo* in_struct); 292 void initialize(const safe_VkSparseImageMemoryBindInfo* copy_src); ptrsafe_VkSparseImageMemoryBindInfo293 VkSparseImageMemoryBindInfo *ptr() { return reinterpret_cast<VkSparseImageMemoryBindInfo *>(this); } ptrsafe_VkSparseImageMemoryBindInfo294 VkSparseImageMemoryBindInfo const *ptr() const { return reinterpret_cast<VkSparseImageMemoryBindInfo const *>(this); } 295 }; 296 297 struct safe_VkBindSparseInfo { 298 VkStructureType sType; 299 const void* pNext; 300 uint32_t waitSemaphoreCount; 301 VkSemaphore* pWaitSemaphores; 302 uint32_t bufferBindCount; 303 safe_VkSparseBufferMemoryBindInfo* pBufferBinds; 304 uint32_t imageOpaqueBindCount; 305 safe_VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; 306 uint32_t imageBindCount; 307 safe_VkSparseImageMemoryBindInfo* pImageBinds; 308 uint32_t signalSemaphoreCount; 309 VkSemaphore* pSignalSemaphores; 310 safe_VkBindSparseInfo(const VkBindSparseInfo* in_struct); 311 safe_VkBindSparseInfo(const safe_VkBindSparseInfo& copy_src); 312 safe_VkBindSparseInfo& operator=(const safe_VkBindSparseInfo& copy_src); 313 safe_VkBindSparseInfo(); 314 ~safe_VkBindSparseInfo(); 315 void initialize(const VkBindSparseInfo* in_struct); 316 void initialize(const safe_VkBindSparseInfo* copy_src); ptrsafe_VkBindSparseInfo317 VkBindSparseInfo *ptr() { return reinterpret_cast<VkBindSparseInfo *>(this); } ptrsafe_VkBindSparseInfo318 VkBindSparseInfo const *ptr() const { return reinterpret_cast<VkBindSparseInfo const *>(this); } 319 }; 320 321 struct safe_VkFenceCreateInfo { 322 VkStructureType sType; 323 const void* pNext; 324 VkFenceCreateFlags flags; 325 safe_VkFenceCreateInfo(const VkFenceCreateInfo* in_struct); 326 safe_VkFenceCreateInfo(const safe_VkFenceCreateInfo& copy_src); 327 safe_VkFenceCreateInfo& operator=(const safe_VkFenceCreateInfo& copy_src); 328 safe_VkFenceCreateInfo(); 329 ~safe_VkFenceCreateInfo(); 330 void initialize(const VkFenceCreateInfo* in_struct); 331 void initialize(const safe_VkFenceCreateInfo* copy_src); ptrsafe_VkFenceCreateInfo332 VkFenceCreateInfo *ptr() { return reinterpret_cast<VkFenceCreateInfo *>(this); } ptrsafe_VkFenceCreateInfo333 VkFenceCreateInfo const *ptr() const { return reinterpret_cast<VkFenceCreateInfo const *>(this); } 334 }; 335 336 struct safe_VkSemaphoreCreateInfo { 337 VkStructureType sType; 338 const void* pNext; 339 VkSemaphoreCreateFlags flags; 340 safe_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo* in_struct); 341 safe_VkSemaphoreCreateInfo(const safe_VkSemaphoreCreateInfo& copy_src); 342 safe_VkSemaphoreCreateInfo& operator=(const safe_VkSemaphoreCreateInfo& copy_src); 343 safe_VkSemaphoreCreateInfo(); 344 ~safe_VkSemaphoreCreateInfo(); 345 void initialize(const VkSemaphoreCreateInfo* in_struct); 346 void initialize(const safe_VkSemaphoreCreateInfo* copy_src); ptrsafe_VkSemaphoreCreateInfo347 VkSemaphoreCreateInfo *ptr() { return reinterpret_cast<VkSemaphoreCreateInfo *>(this); } ptrsafe_VkSemaphoreCreateInfo348 VkSemaphoreCreateInfo const *ptr() const { return reinterpret_cast<VkSemaphoreCreateInfo const *>(this); } 349 }; 350 351 struct safe_VkEventCreateInfo { 352 VkStructureType sType; 353 const void* pNext; 354 VkEventCreateFlags flags; 355 safe_VkEventCreateInfo(const VkEventCreateInfo* in_struct); 356 safe_VkEventCreateInfo(const safe_VkEventCreateInfo& copy_src); 357 safe_VkEventCreateInfo& operator=(const safe_VkEventCreateInfo& copy_src); 358 safe_VkEventCreateInfo(); 359 ~safe_VkEventCreateInfo(); 360 void initialize(const VkEventCreateInfo* in_struct); 361 void initialize(const safe_VkEventCreateInfo* copy_src); ptrsafe_VkEventCreateInfo362 VkEventCreateInfo *ptr() { return reinterpret_cast<VkEventCreateInfo *>(this); } ptrsafe_VkEventCreateInfo363 VkEventCreateInfo const *ptr() const { return reinterpret_cast<VkEventCreateInfo const *>(this); } 364 }; 365 366 struct safe_VkQueryPoolCreateInfo { 367 VkStructureType sType; 368 const void* pNext; 369 VkQueryPoolCreateFlags flags; 370 VkQueryType queryType; 371 uint32_t queryCount; 372 VkQueryPipelineStatisticFlags pipelineStatistics; 373 safe_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo* in_struct); 374 safe_VkQueryPoolCreateInfo(const safe_VkQueryPoolCreateInfo& copy_src); 375 safe_VkQueryPoolCreateInfo& operator=(const safe_VkQueryPoolCreateInfo& copy_src); 376 safe_VkQueryPoolCreateInfo(); 377 ~safe_VkQueryPoolCreateInfo(); 378 void initialize(const VkQueryPoolCreateInfo* in_struct); 379 void initialize(const safe_VkQueryPoolCreateInfo* copy_src); ptrsafe_VkQueryPoolCreateInfo380 VkQueryPoolCreateInfo *ptr() { return reinterpret_cast<VkQueryPoolCreateInfo *>(this); } ptrsafe_VkQueryPoolCreateInfo381 VkQueryPoolCreateInfo const *ptr() const { return reinterpret_cast<VkQueryPoolCreateInfo const *>(this); } 382 }; 383 384 struct safe_VkBufferCreateInfo { 385 VkStructureType sType; 386 const void* pNext; 387 VkBufferCreateFlags flags; 388 VkDeviceSize size; 389 VkBufferUsageFlags usage; 390 VkSharingMode sharingMode; 391 uint32_t queueFamilyIndexCount; 392 const uint32_t* pQueueFamilyIndices; 393 safe_VkBufferCreateInfo(const VkBufferCreateInfo* in_struct); 394 safe_VkBufferCreateInfo(const safe_VkBufferCreateInfo& copy_src); 395 safe_VkBufferCreateInfo& operator=(const safe_VkBufferCreateInfo& copy_src); 396 safe_VkBufferCreateInfo(); 397 ~safe_VkBufferCreateInfo(); 398 void initialize(const VkBufferCreateInfo* in_struct); 399 void initialize(const safe_VkBufferCreateInfo* copy_src); ptrsafe_VkBufferCreateInfo400 VkBufferCreateInfo *ptr() { return reinterpret_cast<VkBufferCreateInfo *>(this); } ptrsafe_VkBufferCreateInfo401 VkBufferCreateInfo const *ptr() const { return reinterpret_cast<VkBufferCreateInfo const *>(this); } 402 }; 403 404 struct safe_VkBufferViewCreateInfo { 405 VkStructureType sType; 406 const void* pNext; 407 VkBufferViewCreateFlags flags; 408 VkBuffer buffer; 409 VkFormat format; 410 VkDeviceSize offset; 411 VkDeviceSize range; 412 safe_VkBufferViewCreateInfo(const VkBufferViewCreateInfo* in_struct); 413 safe_VkBufferViewCreateInfo(const safe_VkBufferViewCreateInfo& copy_src); 414 safe_VkBufferViewCreateInfo& operator=(const safe_VkBufferViewCreateInfo& copy_src); 415 safe_VkBufferViewCreateInfo(); 416 ~safe_VkBufferViewCreateInfo(); 417 void initialize(const VkBufferViewCreateInfo* in_struct); 418 void initialize(const safe_VkBufferViewCreateInfo* copy_src); ptrsafe_VkBufferViewCreateInfo419 VkBufferViewCreateInfo *ptr() { return reinterpret_cast<VkBufferViewCreateInfo *>(this); } ptrsafe_VkBufferViewCreateInfo420 VkBufferViewCreateInfo const *ptr() const { return reinterpret_cast<VkBufferViewCreateInfo const *>(this); } 421 }; 422 423 struct safe_VkImageCreateInfo { 424 VkStructureType sType; 425 const void* pNext; 426 VkImageCreateFlags flags; 427 VkImageType imageType; 428 VkFormat format; 429 VkExtent3D extent; 430 uint32_t mipLevels; 431 uint32_t arrayLayers; 432 VkSampleCountFlagBits samples; 433 VkImageTiling tiling; 434 VkImageUsageFlags usage; 435 VkSharingMode sharingMode; 436 uint32_t queueFamilyIndexCount; 437 const uint32_t* pQueueFamilyIndices; 438 VkImageLayout initialLayout; 439 safe_VkImageCreateInfo(const VkImageCreateInfo* in_struct); 440 safe_VkImageCreateInfo(const safe_VkImageCreateInfo& copy_src); 441 safe_VkImageCreateInfo& operator=(const safe_VkImageCreateInfo& copy_src); 442 safe_VkImageCreateInfo(); 443 ~safe_VkImageCreateInfo(); 444 void initialize(const VkImageCreateInfo* in_struct); 445 void initialize(const safe_VkImageCreateInfo* copy_src); ptrsafe_VkImageCreateInfo446 VkImageCreateInfo *ptr() { return reinterpret_cast<VkImageCreateInfo *>(this); } ptrsafe_VkImageCreateInfo447 VkImageCreateInfo const *ptr() const { return reinterpret_cast<VkImageCreateInfo const *>(this); } 448 }; 449 450 struct safe_VkImageViewCreateInfo { 451 VkStructureType sType; 452 const void* pNext; 453 VkImageViewCreateFlags flags; 454 VkImage image; 455 VkImageViewType viewType; 456 VkFormat format; 457 VkComponentMapping components; 458 VkImageSubresourceRange subresourceRange; 459 safe_VkImageViewCreateInfo(const VkImageViewCreateInfo* in_struct); 460 safe_VkImageViewCreateInfo(const safe_VkImageViewCreateInfo& copy_src); 461 safe_VkImageViewCreateInfo& operator=(const safe_VkImageViewCreateInfo& copy_src); 462 safe_VkImageViewCreateInfo(); 463 ~safe_VkImageViewCreateInfo(); 464 void initialize(const VkImageViewCreateInfo* in_struct); 465 void initialize(const safe_VkImageViewCreateInfo* copy_src); ptrsafe_VkImageViewCreateInfo466 VkImageViewCreateInfo *ptr() { return reinterpret_cast<VkImageViewCreateInfo *>(this); } ptrsafe_VkImageViewCreateInfo467 VkImageViewCreateInfo const *ptr() const { return reinterpret_cast<VkImageViewCreateInfo const *>(this); } 468 }; 469 470 struct safe_VkShaderModuleCreateInfo { 471 VkStructureType sType; 472 const void* pNext; 473 VkShaderModuleCreateFlags flags; 474 size_t codeSize; 475 const uint32_t* pCode; 476 safe_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo* in_struct); 477 safe_VkShaderModuleCreateInfo(const safe_VkShaderModuleCreateInfo& copy_src); 478 safe_VkShaderModuleCreateInfo& operator=(const safe_VkShaderModuleCreateInfo& copy_src); 479 safe_VkShaderModuleCreateInfo(); 480 ~safe_VkShaderModuleCreateInfo(); 481 void initialize(const VkShaderModuleCreateInfo* in_struct); 482 void initialize(const safe_VkShaderModuleCreateInfo* copy_src); ptrsafe_VkShaderModuleCreateInfo483 VkShaderModuleCreateInfo *ptr() { return reinterpret_cast<VkShaderModuleCreateInfo *>(this); } ptrsafe_VkShaderModuleCreateInfo484 VkShaderModuleCreateInfo const *ptr() const { return reinterpret_cast<VkShaderModuleCreateInfo const *>(this); } 485 }; 486 487 struct safe_VkPipelineCacheCreateInfo { 488 VkStructureType sType; 489 const void* pNext; 490 VkPipelineCacheCreateFlags flags; 491 size_t initialDataSize; 492 const void* pInitialData; 493 safe_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo* in_struct); 494 safe_VkPipelineCacheCreateInfo(const safe_VkPipelineCacheCreateInfo& copy_src); 495 safe_VkPipelineCacheCreateInfo& operator=(const safe_VkPipelineCacheCreateInfo& copy_src); 496 safe_VkPipelineCacheCreateInfo(); 497 ~safe_VkPipelineCacheCreateInfo(); 498 void initialize(const VkPipelineCacheCreateInfo* in_struct); 499 void initialize(const safe_VkPipelineCacheCreateInfo* copy_src); ptrsafe_VkPipelineCacheCreateInfo500 VkPipelineCacheCreateInfo *ptr() { return reinterpret_cast<VkPipelineCacheCreateInfo *>(this); } ptrsafe_VkPipelineCacheCreateInfo501 VkPipelineCacheCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineCacheCreateInfo const *>(this); } 502 }; 503 504 struct safe_VkSpecializationInfo { 505 uint32_t mapEntryCount; 506 const VkSpecializationMapEntry* pMapEntries; 507 size_t dataSize; 508 const void* pData; 509 safe_VkSpecializationInfo(const VkSpecializationInfo* in_struct); 510 safe_VkSpecializationInfo(const safe_VkSpecializationInfo& copy_src); 511 safe_VkSpecializationInfo& operator=(const safe_VkSpecializationInfo& copy_src); 512 safe_VkSpecializationInfo(); 513 ~safe_VkSpecializationInfo(); 514 void initialize(const VkSpecializationInfo* in_struct); 515 void initialize(const safe_VkSpecializationInfo* copy_src); ptrsafe_VkSpecializationInfo516 VkSpecializationInfo *ptr() { return reinterpret_cast<VkSpecializationInfo *>(this); } ptrsafe_VkSpecializationInfo517 VkSpecializationInfo const *ptr() const { return reinterpret_cast<VkSpecializationInfo const *>(this); } 518 }; 519 520 struct safe_VkPipelineShaderStageCreateInfo { 521 VkStructureType sType; 522 const void* pNext; 523 VkPipelineShaderStageCreateFlags flags; 524 VkShaderStageFlagBits stage; 525 VkShaderModule module; 526 const char* pName; 527 safe_VkSpecializationInfo* pSpecializationInfo; 528 safe_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo* in_struct); 529 safe_VkPipelineShaderStageCreateInfo(const safe_VkPipelineShaderStageCreateInfo& copy_src); 530 safe_VkPipelineShaderStageCreateInfo& operator=(const safe_VkPipelineShaderStageCreateInfo& copy_src); 531 safe_VkPipelineShaderStageCreateInfo(); 532 ~safe_VkPipelineShaderStageCreateInfo(); 533 void initialize(const VkPipelineShaderStageCreateInfo* in_struct); 534 void initialize(const safe_VkPipelineShaderStageCreateInfo* copy_src); ptrsafe_VkPipelineShaderStageCreateInfo535 VkPipelineShaderStageCreateInfo *ptr() { return reinterpret_cast<VkPipelineShaderStageCreateInfo *>(this); } ptrsafe_VkPipelineShaderStageCreateInfo536 VkPipelineShaderStageCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineShaderStageCreateInfo const *>(this); } 537 }; 538 539 struct safe_VkComputePipelineCreateInfo { 540 VkStructureType sType; 541 const void* pNext; 542 VkPipelineCreateFlags flags; 543 safe_VkPipelineShaderStageCreateInfo stage; 544 VkPipelineLayout layout; 545 VkPipeline basePipelineHandle; 546 int32_t basePipelineIndex; 547 safe_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo* in_struct); 548 safe_VkComputePipelineCreateInfo(const safe_VkComputePipelineCreateInfo& copy_src); 549 safe_VkComputePipelineCreateInfo& operator=(const safe_VkComputePipelineCreateInfo& copy_src); 550 safe_VkComputePipelineCreateInfo(); 551 ~safe_VkComputePipelineCreateInfo(); 552 void initialize(const VkComputePipelineCreateInfo* in_struct); 553 void initialize(const safe_VkComputePipelineCreateInfo* copy_src); ptrsafe_VkComputePipelineCreateInfo554 VkComputePipelineCreateInfo *ptr() { return reinterpret_cast<VkComputePipelineCreateInfo *>(this); } ptrsafe_VkComputePipelineCreateInfo555 VkComputePipelineCreateInfo const *ptr() const { return reinterpret_cast<VkComputePipelineCreateInfo const *>(this); } 556 }; 557 558 struct safe_VkPipelineVertexInputStateCreateInfo { 559 VkStructureType sType; 560 const void* pNext; 561 VkPipelineVertexInputStateCreateFlags flags; 562 uint32_t vertexBindingDescriptionCount; 563 const VkVertexInputBindingDescription* pVertexBindingDescriptions; 564 uint32_t vertexAttributeDescriptionCount; 565 const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; 566 safe_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo* in_struct); 567 safe_VkPipelineVertexInputStateCreateInfo(const safe_VkPipelineVertexInputStateCreateInfo& copy_src); 568 safe_VkPipelineVertexInputStateCreateInfo& operator=(const safe_VkPipelineVertexInputStateCreateInfo& copy_src); 569 safe_VkPipelineVertexInputStateCreateInfo(); 570 ~safe_VkPipelineVertexInputStateCreateInfo(); 571 void initialize(const VkPipelineVertexInputStateCreateInfo* in_struct); 572 void initialize(const safe_VkPipelineVertexInputStateCreateInfo* copy_src); ptrsafe_VkPipelineVertexInputStateCreateInfo573 VkPipelineVertexInputStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineVertexInputStateCreateInfo *>(this); } ptrsafe_VkPipelineVertexInputStateCreateInfo574 VkPipelineVertexInputStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineVertexInputStateCreateInfo const *>(this); } 575 }; 576 577 struct safe_VkPipelineInputAssemblyStateCreateInfo { 578 VkStructureType sType; 579 const void* pNext; 580 VkPipelineInputAssemblyStateCreateFlags flags; 581 VkPrimitiveTopology topology; 582 VkBool32 primitiveRestartEnable; 583 safe_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo* in_struct); 584 safe_VkPipelineInputAssemblyStateCreateInfo(const safe_VkPipelineInputAssemblyStateCreateInfo& copy_src); 585 safe_VkPipelineInputAssemblyStateCreateInfo& operator=(const safe_VkPipelineInputAssemblyStateCreateInfo& copy_src); 586 safe_VkPipelineInputAssemblyStateCreateInfo(); 587 ~safe_VkPipelineInputAssemblyStateCreateInfo(); 588 void initialize(const VkPipelineInputAssemblyStateCreateInfo* in_struct); 589 void initialize(const safe_VkPipelineInputAssemblyStateCreateInfo* copy_src); ptrsafe_VkPipelineInputAssemblyStateCreateInfo590 VkPipelineInputAssemblyStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo *>(this); } ptrsafe_VkPipelineInputAssemblyStateCreateInfo591 VkPipelineInputAssemblyStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo const *>(this); } 592 }; 593 594 struct safe_VkPipelineTessellationStateCreateInfo { 595 VkStructureType sType; 596 const void* pNext; 597 VkPipelineTessellationStateCreateFlags flags; 598 uint32_t patchControlPoints; 599 safe_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo* in_struct); 600 safe_VkPipelineTessellationStateCreateInfo(const safe_VkPipelineTessellationStateCreateInfo& copy_src); 601 safe_VkPipelineTessellationStateCreateInfo& operator=(const safe_VkPipelineTessellationStateCreateInfo& copy_src); 602 safe_VkPipelineTessellationStateCreateInfo(); 603 ~safe_VkPipelineTessellationStateCreateInfo(); 604 void initialize(const VkPipelineTessellationStateCreateInfo* in_struct); 605 void initialize(const safe_VkPipelineTessellationStateCreateInfo* copy_src); ptrsafe_VkPipelineTessellationStateCreateInfo606 VkPipelineTessellationStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineTessellationStateCreateInfo *>(this); } ptrsafe_VkPipelineTessellationStateCreateInfo607 VkPipelineTessellationStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineTessellationStateCreateInfo const *>(this); } 608 }; 609 610 struct safe_VkPipelineViewportStateCreateInfo { 611 VkStructureType sType; 612 const void* pNext; 613 VkPipelineViewportStateCreateFlags flags; 614 uint32_t viewportCount; 615 const VkViewport* pViewports; 616 uint32_t scissorCount; 617 const VkRect2D* pScissors; 618 safe_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports, const bool is_dynamic_scissors); 619 safe_VkPipelineViewportStateCreateInfo(const safe_VkPipelineViewportStateCreateInfo& copy_src); 620 safe_VkPipelineViewportStateCreateInfo& operator=(const safe_VkPipelineViewportStateCreateInfo& copy_src); 621 safe_VkPipelineViewportStateCreateInfo(); 622 ~safe_VkPipelineViewportStateCreateInfo(); 623 void initialize(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports, const bool is_dynamic_scissors); 624 void initialize(const safe_VkPipelineViewportStateCreateInfo* copy_src); ptrsafe_VkPipelineViewportStateCreateInfo625 VkPipelineViewportStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineViewportStateCreateInfo *>(this); } ptrsafe_VkPipelineViewportStateCreateInfo626 VkPipelineViewportStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineViewportStateCreateInfo const *>(this); } 627 }; 628 629 struct safe_VkPipelineRasterizationStateCreateInfo { 630 VkStructureType sType; 631 const void* pNext; 632 VkPipelineRasterizationStateCreateFlags flags; 633 VkBool32 depthClampEnable; 634 VkBool32 rasterizerDiscardEnable; 635 VkPolygonMode polygonMode; 636 VkCullModeFlags cullMode; 637 VkFrontFace frontFace; 638 VkBool32 depthBiasEnable; 639 float depthBiasConstantFactor; 640 float depthBiasClamp; 641 float depthBiasSlopeFactor; 642 float lineWidth; 643 safe_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo* in_struct); 644 safe_VkPipelineRasterizationStateCreateInfo(const safe_VkPipelineRasterizationStateCreateInfo& copy_src); 645 safe_VkPipelineRasterizationStateCreateInfo& operator=(const safe_VkPipelineRasterizationStateCreateInfo& copy_src); 646 safe_VkPipelineRasterizationStateCreateInfo(); 647 ~safe_VkPipelineRasterizationStateCreateInfo(); 648 void initialize(const VkPipelineRasterizationStateCreateInfo* in_struct); 649 void initialize(const safe_VkPipelineRasterizationStateCreateInfo* copy_src); ptrsafe_VkPipelineRasterizationStateCreateInfo650 VkPipelineRasterizationStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineRasterizationStateCreateInfo *>(this); } ptrsafe_VkPipelineRasterizationStateCreateInfo651 VkPipelineRasterizationStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineRasterizationStateCreateInfo const *>(this); } 652 }; 653 654 struct safe_VkPipelineMultisampleStateCreateInfo { 655 VkStructureType sType; 656 const void* pNext; 657 VkPipelineMultisampleStateCreateFlags flags; 658 VkSampleCountFlagBits rasterizationSamples; 659 VkBool32 sampleShadingEnable; 660 float minSampleShading; 661 const VkSampleMask* pSampleMask; 662 VkBool32 alphaToCoverageEnable; 663 VkBool32 alphaToOneEnable; 664 safe_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo* in_struct); 665 safe_VkPipelineMultisampleStateCreateInfo(const safe_VkPipelineMultisampleStateCreateInfo& copy_src); 666 safe_VkPipelineMultisampleStateCreateInfo& operator=(const safe_VkPipelineMultisampleStateCreateInfo& copy_src); 667 safe_VkPipelineMultisampleStateCreateInfo(); 668 ~safe_VkPipelineMultisampleStateCreateInfo(); 669 void initialize(const VkPipelineMultisampleStateCreateInfo* in_struct); 670 void initialize(const safe_VkPipelineMultisampleStateCreateInfo* copy_src); ptrsafe_VkPipelineMultisampleStateCreateInfo671 VkPipelineMultisampleStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineMultisampleStateCreateInfo *>(this); } ptrsafe_VkPipelineMultisampleStateCreateInfo672 VkPipelineMultisampleStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineMultisampleStateCreateInfo const *>(this); } 673 }; 674 675 struct safe_VkPipelineDepthStencilStateCreateInfo { 676 VkStructureType sType; 677 const void* pNext; 678 VkPipelineDepthStencilStateCreateFlags flags; 679 VkBool32 depthTestEnable; 680 VkBool32 depthWriteEnable; 681 VkCompareOp depthCompareOp; 682 VkBool32 depthBoundsTestEnable; 683 VkBool32 stencilTestEnable; 684 VkStencilOpState front; 685 VkStencilOpState back; 686 float minDepthBounds; 687 float maxDepthBounds; 688 safe_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo* in_struct); 689 safe_VkPipelineDepthStencilStateCreateInfo(const safe_VkPipelineDepthStencilStateCreateInfo& copy_src); 690 safe_VkPipelineDepthStencilStateCreateInfo& operator=(const safe_VkPipelineDepthStencilStateCreateInfo& copy_src); 691 safe_VkPipelineDepthStencilStateCreateInfo(); 692 ~safe_VkPipelineDepthStencilStateCreateInfo(); 693 void initialize(const VkPipelineDepthStencilStateCreateInfo* in_struct); 694 void initialize(const safe_VkPipelineDepthStencilStateCreateInfo* copy_src); ptrsafe_VkPipelineDepthStencilStateCreateInfo695 VkPipelineDepthStencilStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo *>(this); } ptrsafe_VkPipelineDepthStencilStateCreateInfo696 VkPipelineDepthStencilStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo const *>(this); } 697 }; 698 699 struct safe_VkPipelineColorBlendStateCreateInfo { 700 VkStructureType sType; 701 const void* pNext; 702 VkPipelineColorBlendStateCreateFlags flags; 703 VkBool32 logicOpEnable; 704 VkLogicOp logicOp; 705 uint32_t attachmentCount; 706 const VkPipelineColorBlendAttachmentState* pAttachments; 707 float blendConstants[4]; 708 safe_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo* in_struct); 709 safe_VkPipelineColorBlendStateCreateInfo(const safe_VkPipelineColorBlendStateCreateInfo& copy_src); 710 safe_VkPipelineColorBlendStateCreateInfo& operator=(const safe_VkPipelineColorBlendStateCreateInfo& copy_src); 711 safe_VkPipelineColorBlendStateCreateInfo(); 712 ~safe_VkPipelineColorBlendStateCreateInfo(); 713 void initialize(const VkPipelineColorBlendStateCreateInfo* in_struct); 714 void initialize(const safe_VkPipelineColorBlendStateCreateInfo* copy_src); ptrsafe_VkPipelineColorBlendStateCreateInfo715 VkPipelineColorBlendStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineColorBlendStateCreateInfo *>(this); } ptrsafe_VkPipelineColorBlendStateCreateInfo716 VkPipelineColorBlendStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineColorBlendStateCreateInfo const *>(this); } 717 }; 718 719 struct safe_VkPipelineDynamicStateCreateInfo { 720 VkStructureType sType; 721 const void* pNext; 722 VkPipelineDynamicStateCreateFlags flags; 723 uint32_t dynamicStateCount; 724 const VkDynamicState* pDynamicStates; 725 safe_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* in_struct); 726 safe_VkPipelineDynamicStateCreateInfo(const safe_VkPipelineDynamicStateCreateInfo& copy_src); 727 safe_VkPipelineDynamicStateCreateInfo& operator=(const safe_VkPipelineDynamicStateCreateInfo& copy_src); 728 safe_VkPipelineDynamicStateCreateInfo(); 729 ~safe_VkPipelineDynamicStateCreateInfo(); 730 void initialize(const VkPipelineDynamicStateCreateInfo* in_struct); 731 void initialize(const safe_VkPipelineDynamicStateCreateInfo* copy_src); ptrsafe_VkPipelineDynamicStateCreateInfo732 VkPipelineDynamicStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineDynamicStateCreateInfo *>(this); } ptrsafe_VkPipelineDynamicStateCreateInfo733 VkPipelineDynamicStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineDynamicStateCreateInfo const *>(this); } 734 }; 735 736 struct safe_VkGraphicsPipelineCreateInfo { 737 VkStructureType sType; 738 const void* pNext; 739 VkPipelineCreateFlags flags; 740 uint32_t stageCount; 741 safe_VkPipelineShaderStageCreateInfo* pStages; 742 safe_VkPipelineVertexInputStateCreateInfo* pVertexInputState; 743 safe_VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; 744 safe_VkPipelineTessellationStateCreateInfo* pTessellationState; 745 safe_VkPipelineViewportStateCreateInfo* pViewportState; 746 safe_VkPipelineRasterizationStateCreateInfo* pRasterizationState; 747 safe_VkPipelineMultisampleStateCreateInfo* pMultisampleState; 748 safe_VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; 749 safe_VkPipelineColorBlendStateCreateInfo* pColorBlendState; 750 safe_VkPipelineDynamicStateCreateInfo* pDynamicState; 751 VkPipelineLayout layout; 752 VkRenderPass renderPass; 753 uint32_t subpass; 754 VkPipeline basePipelineHandle; 755 int32_t basePipelineIndex; 756 safe_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment, const bool uses_depthstencil_attachment); 757 safe_VkGraphicsPipelineCreateInfo(const safe_VkGraphicsPipelineCreateInfo& copy_src); 758 safe_VkGraphicsPipelineCreateInfo& operator=(const safe_VkGraphicsPipelineCreateInfo& copy_src); 759 safe_VkGraphicsPipelineCreateInfo(); 760 ~safe_VkGraphicsPipelineCreateInfo(); 761 void initialize(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment, const bool uses_depthstencil_attachment); 762 void initialize(const safe_VkGraphicsPipelineCreateInfo* copy_src); ptrsafe_VkGraphicsPipelineCreateInfo763 VkGraphicsPipelineCreateInfo *ptr() { return reinterpret_cast<VkGraphicsPipelineCreateInfo *>(this); } ptrsafe_VkGraphicsPipelineCreateInfo764 VkGraphicsPipelineCreateInfo const *ptr() const { return reinterpret_cast<VkGraphicsPipelineCreateInfo const *>(this); } 765 }; 766 767 struct safe_VkPipelineLayoutCreateInfo { 768 VkStructureType sType; 769 const void* pNext; 770 VkPipelineLayoutCreateFlags flags; 771 uint32_t setLayoutCount; 772 VkDescriptorSetLayout* pSetLayouts; 773 uint32_t pushConstantRangeCount; 774 const VkPushConstantRange* pPushConstantRanges; 775 safe_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo* in_struct); 776 safe_VkPipelineLayoutCreateInfo(const safe_VkPipelineLayoutCreateInfo& copy_src); 777 safe_VkPipelineLayoutCreateInfo& operator=(const safe_VkPipelineLayoutCreateInfo& copy_src); 778 safe_VkPipelineLayoutCreateInfo(); 779 ~safe_VkPipelineLayoutCreateInfo(); 780 void initialize(const VkPipelineLayoutCreateInfo* in_struct); 781 void initialize(const safe_VkPipelineLayoutCreateInfo* copy_src); ptrsafe_VkPipelineLayoutCreateInfo782 VkPipelineLayoutCreateInfo *ptr() { return reinterpret_cast<VkPipelineLayoutCreateInfo *>(this); } ptrsafe_VkPipelineLayoutCreateInfo783 VkPipelineLayoutCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineLayoutCreateInfo const *>(this); } 784 }; 785 786 struct safe_VkSamplerCreateInfo { 787 VkStructureType sType; 788 const void* pNext; 789 VkSamplerCreateFlags flags; 790 VkFilter magFilter; 791 VkFilter minFilter; 792 VkSamplerMipmapMode mipmapMode; 793 VkSamplerAddressMode addressModeU; 794 VkSamplerAddressMode addressModeV; 795 VkSamplerAddressMode addressModeW; 796 float mipLodBias; 797 VkBool32 anisotropyEnable; 798 float maxAnisotropy; 799 VkBool32 compareEnable; 800 VkCompareOp compareOp; 801 float minLod; 802 float maxLod; 803 VkBorderColor borderColor; 804 VkBool32 unnormalizedCoordinates; 805 safe_VkSamplerCreateInfo(const VkSamplerCreateInfo* in_struct); 806 safe_VkSamplerCreateInfo(const safe_VkSamplerCreateInfo& copy_src); 807 safe_VkSamplerCreateInfo& operator=(const safe_VkSamplerCreateInfo& copy_src); 808 safe_VkSamplerCreateInfo(); 809 ~safe_VkSamplerCreateInfo(); 810 void initialize(const VkSamplerCreateInfo* in_struct); 811 void initialize(const safe_VkSamplerCreateInfo* copy_src); ptrsafe_VkSamplerCreateInfo812 VkSamplerCreateInfo *ptr() { return reinterpret_cast<VkSamplerCreateInfo *>(this); } ptrsafe_VkSamplerCreateInfo813 VkSamplerCreateInfo const *ptr() const { return reinterpret_cast<VkSamplerCreateInfo const *>(this); } 814 }; 815 816 struct safe_VkCopyDescriptorSet { 817 VkStructureType sType; 818 const void* pNext; 819 VkDescriptorSet srcSet; 820 uint32_t srcBinding; 821 uint32_t srcArrayElement; 822 VkDescriptorSet dstSet; 823 uint32_t dstBinding; 824 uint32_t dstArrayElement; 825 uint32_t descriptorCount; 826 safe_VkCopyDescriptorSet(const VkCopyDescriptorSet* in_struct); 827 safe_VkCopyDescriptorSet(const safe_VkCopyDescriptorSet& copy_src); 828 safe_VkCopyDescriptorSet& operator=(const safe_VkCopyDescriptorSet& copy_src); 829 safe_VkCopyDescriptorSet(); 830 ~safe_VkCopyDescriptorSet(); 831 void initialize(const VkCopyDescriptorSet* in_struct); 832 void initialize(const safe_VkCopyDescriptorSet* copy_src); ptrsafe_VkCopyDescriptorSet833 VkCopyDescriptorSet *ptr() { return reinterpret_cast<VkCopyDescriptorSet *>(this); } ptrsafe_VkCopyDescriptorSet834 VkCopyDescriptorSet const *ptr() const { return reinterpret_cast<VkCopyDescriptorSet const *>(this); } 835 }; 836 837 struct safe_VkDescriptorPoolCreateInfo { 838 VkStructureType sType; 839 const void* pNext; 840 VkDescriptorPoolCreateFlags flags; 841 uint32_t maxSets; 842 uint32_t poolSizeCount; 843 const VkDescriptorPoolSize* pPoolSizes; 844 safe_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo* in_struct); 845 safe_VkDescriptorPoolCreateInfo(const safe_VkDescriptorPoolCreateInfo& copy_src); 846 safe_VkDescriptorPoolCreateInfo& operator=(const safe_VkDescriptorPoolCreateInfo& copy_src); 847 safe_VkDescriptorPoolCreateInfo(); 848 ~safe_VkDescriptorPoolCreateInfo(); 849 void initialize(const VkDescriptorPoolCreateInfo* in_struct); 850 void initialize(const safe_VkDescriptorPoolCreateInfo* copy_src); ptrsafe_VkDescriptorPoolCreateInfo851 VkDescriptorPoolCreateInfo *ptr() { return reinterpret_cast<VkDescriptorPoolCreateInfo *>(this); } ptrsafe_VkDescriptorPoolCreateInfo852 VkDescriptorPoolCreateInfo const *ptr() const { return reinterpret_cast<VkDescriptorPoolCreateInfo const *>(this); } 853 }; 854 855 struct safe_VkDescriptorSetAllocateInfo { 856 VkStructureType sType; 857 const void* pNext; 858 VkDescriptorPool descriptorPool; 859 uint32_t descriptorSetCount; 860 VkDescriptorSetLayout* pSetLayouts; 861 safe_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo* in_struct); 862 safe_VkDescriptorSetAllocateInfo(const safe_VkDescriptorSetAllocateInfo& copy_src); 863 safe_VkDescriptorSetAllocateInfo& operator=(const safe_VkDescriptorSetAllocateInfo& copy_src); 864 safe_VkDescriptorSetAllocateInfo(); 865 ~safe_VkDescriptorSetAllocateInfo(); 866 void initialize(const VkDescriptorSetAllocateInfo* in_struct); 867 void initialize(const safe_VkDescriptorSetAllocateInfo* copy_src); ptrsafe_VkDescriptorSetAllocateInfo868 VkDescriptorSetAllocateInfo *ptr() { return reinterpret_cast<VkDescriptorSetAllocateInfo *>(this); } ptrsafe_VkDescriptorSetAllocateInfo869 VkDescriptorSetAllocateInfo const *ptr() const { return reinterpret_cast<VkDescriptorSetAllocateInfo const *>(this); } 870 }; 871 872 struct safe_VkDescriptorSetLayoutBinding { 873 uint32_t binding; 874 VkDescriptorType descriptorType; 875 uint32_t descriptorCount; 876 VkShaderStageFlags stageFlags; 877 VkSampler* pImmutableSamplers; 878 safe_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding* in_struct); 879 safe_VkDescriptorSetLayoutBinding(const safe_VkDescriptorSetLayoutBinding& copy_src); 880 safe_VkDescriptorSetLayoutBinding& operator=(const safe_VkDescriptorSetLayoutBinding& copy_src); 881 safe_VkDescriptorSetLayoutBinding(); 882 ~safe_VkDescriptorSetLayoutBinding(); 883 void initialize(const VkDescriptorSetLayoutBinding* in_struct); 884 void initialize(const safe_VkDescriptorSetLayoutBinding* copy_src); ptrsafe_VkDescriptorSetLayoutBinding885 VkDescriptorSetLayoutBinding *ptr() { return reinterpret_cast<VkDescriptorSetLayoutBinding *>(this); } ptrsafe_VkDescriptorSetLayoutBinding886 VkDescriptorSetLayoutBinding const *ptr() const { return reinterpret_cast<VkDescriptorSetLayoutBinding const *>(this); } 887 }; 888 889 struct safe_VkDescriptorSetLayoutCreateInfo { 890 VkStructureType sType; 891 const void* pNext; 892 VkDescriptorSetLayoutCreateFlags flags; 893 uint32_t bindingCount; 894 safe_VkDescriptorSetLayoutBinding* pBindings; 895 safe_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo* in_struct); 896 safe_VkDescriptorSetLayoutCreateInfo(const safe_VkDescriptorSetLayoutCreateInfo& copy_src); 897 safe_VkDescriptorSetLayoutCreateInfo& operator=(const safe_VkDescriptorSetLayoutCreateInfo& copy_src); 898 safe_VkDescriptorSetLayoutCreateInfo(); 899 ~safe_VkDescriptorSetLayoutCreateInfo(); 900 void initialize(const VkDescriptorSetLayoutCreateInfo* in_struct); 901 void initialize(const safe_VkDescriptorSetLayoutCreateInfo* copy_src); ptrsafe_VkDescriptorSetLayoutCreateInfo902 VkDescriptorSetLayoutCreateInfo *ptr() { return reinterpret_cast<VkDescriptorSetLayoutCreateInfo *>(this); } ptrsafe_VkDescriptorSetLayoutCreateInfo903 VkDescriptorSetLayoutCreateInfo const *ptr() const { return reinterpret_cast<VkDescriptorSetLayoutCreateInfo const *>(this); } 904 }; 905 906 struct safe_VkWriteDescriptorSet { 907 VkStructureType sType; 908 const void* pNext; 909 VkDescriptorSet dstSet; 910 uint32_t dstBinding; 911 uint32_t dstArrayElement; 912 uint32_t descriptorCount; 913 VkDescriptorType descriptorType; 914 VkDescriptorImageInfo* pImageInfo; 915 VkDescriptorBufferInfo* pBufferInfo; 916 VkBufferView* pTexelBufferView; 917 safe_VkWriteDescriptorSet(const VkWriteDescriptorSet* in_struct); 918 safe_VkWriteDescriptorSet(const safe_VkWriteDescriptorSet& copy_src); 919 safe_VkWriteDescriptorSet& operator=(const safe_VkWriteDescriptorSet& copy_src); 920 safe_VkWriteDescriptorSet(); 921 ~safe_VkWriteDescriptorSet(); 922 void initialize(const VkWriteDescriptorSet* in_struct); 923 void initialize(const safe_VkWriteDescriptorSet* copy_src); ptrsafe_VkWriteDescriptorSet924 VkWriteDescriptorSet *ptr() { return reinterpret_cast<VkWriteDescriptorSet *>(this); } ptrsafe_VkWriteDescriptorSet925 VkWriteDescriptorSet const *ptr() const { return reinterpret_cast<VkWriteDescriptorSet const *>(this); } 926 }; 927 928 struct safe_VkFramebufferCreateInfo { 929 VkStructureType sType; 930 const void* pNext; 931 VkFramebufferCreateFlags flags; 932 VkRenderPass renderPass; 933 uint32_t attachmentCount; 934 VkImageView* pAttachments; 935 uint32_t width; 936 uint32_t height; 937 uint32_t layers; 938 safe_VkFramebufferCreateInfo(const VkFramebufferCreateInfo* in_struct); 939 safe_VkFramebufferCreateInfo(const safe_VkFramebufferCreateInfo& copy_src); 940 safe_VkFramebufferCreateInfo& operator=(const safe_VkFramebufferCreateInfo& copy_src); 941 safe_VkFramebufferCreateInfo(); 942 ~safe_VkFramebufferCreateInfo(); 943 void initialize(const VkFramebufferCreateInfo* in_struct); 944 void initialize(const safe_VkFramebufferCreateInfo* copy_src); ptrsafe_VkFramebufferCreateInfo945 VkFramebufferCreateInfo *ptr() { return reinterpret_cast<VkFramebufferCreateInfo *>(this); } ptrsafe_VkFramebufferCreateInfo946 VkFramebufferCreateInfo const *ptr() const { return reinterpret_cast<VkFramebufferCreateInfo const *>(this); } 947 }; 948 949 struct safe_VkSubpassDescription { 950 VkSubpassDescriptionFlags flags; 951 VkPipelineBindPoint pipelineBindPoint; 952 uint32_t inputAttachmentCount; 953 const VkAttachmentReference* pInputAttachments; 954 uint32_t colorAttachmentCount; 955 const VkAttachmentReference* pColorAttachments; 956 const VkAttachmentReference* pResolveAttachments; 957 const VkAttachmentReference* pDepthStencilAttachment; 958 uint32_t preserveAttachmentCount; 959 const uint32_t* pPreserveAttachments; 960 safe_VkSubpassDescription(const VkSubpassDescription* in_struct); 961 safe_VkSubpassDescription(const safe_VkSubpassDescription& copy_src); 962 safe_VkSubpassDescription& operator=(const safe_VkSubpassDescription& copy_src); 963 safe_VkSubpassDescription(); 964 ~safe_VkSubpassDescription(); 965 void initialize(const VkSubpassDescription* in_struct); 966 void initialize(const safe_VkSubpassDescription* copy_src); ptrsafe_VkSubpassDescription967 VkSubpassDescription *ptr() { return reinterpret_cast<VkSubpassDescription *>(this); } ptrsafe_VkSubpassDescription968 VkSubpassDescription const *ptr() const { return reinterpret_cast<VkSubpassDescription const *>(this); } 969 }; 970 971 struct safe_VkRenderPassCreateInfo { 972 VkStructureType sType; 973 const void* pNext; 974 VkRenderPassCreateFlags flags; 975 uint32_t attachmentCount; 976 const VkAttachmentDescription* pAttachments; 977 uint32_t subpassCount; 978 safe_VkSubpassDescription* pSubpasses; 979 uint32_t dependencyCount; 980 const VkSubpassDependency* pDependencies; 981 safe_VkRenderPassCreateInfo(const VkRenderPassCreateInfo* in_struct); 982 safe_VkRenderPassCreateInfo(const safe_VkRenderPassCreateInfo& copy_src); 983 safe_VkRenderPassCreateInfo& operator=(const safe_VkRenderPassCreateInfo& copy_src); 984 safe_VkRenderPassCreateInfo(); 985 ~safe_VkRenderPassCreateInfo(); 986 void initialize(const VkRenderPassCreateInfo* in_struct); 987 void initialize(const safe_VkRenderPassCreateInfo* copy_src); ptrsafe_VkRenderPassCreateInfo988 VkRenderPassCreateInfo *ptr() { return reinterpret_cast<VkRenderPassCreateInfo *>(this); } ptrsafe_VkRenderPassCreateInfo989 VkRenderPassCreateInfo const *ptr() const { return reinterpret_cast<VkRenderPassCreateInfo const *>(this); } 990 }; 991 992 struct safe_VkCommandPoolCreateInfo { 993 VkStructureType sType; 994 const void* pNext; 995 VkCommandPoolCreateFlags flags; 996 uint32_t queueFamilyIndex; 997 safe_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo* in_struct); 998 safe_VkCommandPoolCreateInfo(const safe_VkCommandPoolCreateInfo& copy_src); 999 safe_VkCommandPoolCreateInfo& operator=(const safe_VkCommandPoolCreateInfo& copy_src); 1000 safe_VkCommandPoolCreateInfo(); 1001 ~safe_VkCommandPoolCreateInfo(); 1002 void initialize(const VkCommandPoolCreateInfo* in_struct); 1003 void initialize(const safe_VkCommandPoolCreateInfo* copy_src); ptrsafe_VkCommandPoolCreateInfo1004 VkCommandPoolCreateInfo *ptr() { return reinterpret_cast<VkCommandPoolCreateInfo *>(this); } ptrsafe_VkCommandPoolCreateInfo1005 VkCommandPoolCreateInfo const *ptr() const { return reinterpret_cast<VkCommandPoolCreateInfo const *>(this); } 1006 }; 1007 1008 struct safe_VkCommandBufferAllocateInfo { 1009 VkStructureType sType; 1010 const void* pNext; 1011 VkCommandPool commandPool; 1012 VkCommandBufferLevel level; 1013 uint32_t commandBufferCount; 1014 safe_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo* in_struct); 1015 safe_VkCommandBufferAllocateInfo(const safe_VkCommandBufferAllocateInfo& copy_src); 1016 safe_VkCommandBufferAllocateInfo& operator=(const safe_VkCommandBufferAllocateInfo& copy_src); 1017 safe_VkCommandBufferAllocateInfo(); 1018 ~safe_VkCommandBufferAllocateInfo(); 1019 void initialize(const VkCommandBufferAllocateInfo* in_struct); 1020 void initialize(const safe_VkCommandBufferAllocateInfo* copy_src); ptrsafe_VkCommandBufferAllocateInfo1021 VkCommandBufferAllocateInfo *ptr() { return reinterpret_cast<VkCommandBufferAllocateInfo *>(this); } ptrsafe_VkCommandBufferAllocateInfo1022 VkCommandBufferAllocateInfo const *ptr() const { return reinterpret_cast<VkCommandBufferAllocateInfo const *>(this); } 1023 }; 1024 1025 struct safe_VkCommandBufferInheritanceInfo { 1026 VkStructureType sType; 1027 const void* pNext; 1028 VkRenderPass renderPass; 1029 uint32_t subpass; 1030 VkFramebuffer framebuffer; 1031 VkBool32 occlusionQueryEnable; 1032 VkQueryControlFlags queryFlags; 1033 VkQueryPipelineStatisticFlags pipelineStatistics; 1034 safe_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo* in_struct); 1035 safe_VkCommandBufferInheritanceInfo(const safe_VkCommandBufferInheritanceInfo& copy_src); 1036 safe_VkCommandBufferInheritanceInfo& operator=(const safe_VkCommandBufferInheritanceInfo& copy_src); 1037 safe_VkCommandBufferInheritanceInfo(); 1038 ~safe_VkCommandBufferInheritanceInfo(); 1039 void initialize(const VkCommandBufferInheritanceInfo* in_struct); 1040 void initialize(const safe_VkCommandBufferInheritanceInfo* copy_src); ptrsafe_VkCommandBufferInheritanceInfo1041 VkCommandBufferInheritanceInfo *ptr() { return reinterpret_cast<VkCommandBufferInheritanceInfo *>(this); } ptrsafe_VkCommandBufferInheritanceInfo1042 VkCommandBufferInheritanceInfo const *ptr() const { return reinterpret_cast<VkCommandBufferInheritanceInfo const *>(this); } 1043 }; 1044 1045 struct safe_VkCommandBufferBeginInfo { 1046 VkStructureType sType; 1047 const void* pNext; 1048 VkCommandBufferUsageFlags flags; 1049 safe_VkCommandBufferInheritanceInfo* pInheritanceInfo; 1050 safe_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo* in_struct); 1051 safe_VkCommandBufferBeginInfo(const safe_VkCommandBufferBeginInfo& copy_src); 1052 safe_VkCommandBufferBeginInfo& operator=(const safe_VkCommandBufferBeginInfo& copy_src); 1053 safe_VkCommandBufferBeginInfo(); 1054 ~safe_VkCommandBufferBeginInfo(); 1055 void initialize(const VkCommandBufferBeginInfo* in_struct); 1056 void initialize(const safe_VkCommandBufferBeginInfo* copy_src); ptrsafe_VkCommandBufferBeginInfo1057 VkCommandBufferBeginInfo *ptr() { return reinterpret_cast<VkCommandBufferBeginInfo *>(this); } ptrsafe_VkCommandBufferBeginInfo1058 VkCommandBufferBeginInfo const *ptr() const { return reinterpret_cast<VkCommandBufferBeginInfo const *>(this); } 1059 }; 1060 1061 struct safe_VkRenderPassBeginInfo { 1062 VkStructureType sType; 1063 const void* pNext; 1064 VkRenderPass renderPass; 1065 VkFramebuffer framebuffer; 1066 VkRect2D renderArea; 1067 uint32_t clearValueCount; 1068 const VkClearValue* pClearValues; 1069 safe_VkRenderPassBeginInfo(const VkRenderPassBeginInfo* in_struct); 1070 safe_VkRenderPassBeginInfo(const safe_VkRenderPassBeginInfo& copy_src); 1071 safe_VkRenderPassBeginInfo& operator=(const safe_VkRenderPassBeginInfo& copy_src); 1072 safe_VkRenderPassBeginInfo(); 1073 ~safe_VkRenderPassBeginInfo(); 1074 void initialize(const VkRenderPassBeginInfo* in_struct); 1075 void initialize(const safe_VkRenderPassBeginInfo* copy_src); ptrsafe_VkRenderPassBeginInfo1076 VkRenderPassBeginInfo *ptr() { return reinterpret_cast<VkRenderPassBeginInfo *>(this); } ptrsafe_VkRenderPassBeginInfo1077 VkRenderPassBeginInfo const *ptr() const { return reinterpret_cast<VkRenderPassBeginInfo const *>(this); } 1078 }; 1079 1080 struct safe_VkPhysicalDeviceSubgroupProperties { 1081 VkStructureType sType; 1082 void* pNext; 1083 uint32_t subgroupSize; 1084 VkShaderStageFlags supportedStages; 1085 VkSubgroupFeatureFlags supportedOperations; 1086 VkBool32 quadOperationsInAllStages; 1087 safe_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties* in_struct); 1088 safe_VkPhysicalDeviceSubgroupProperties(const safe_VkPhysicalDeviceSubgroupProperties& copy_src); 1089 safe_VkPhysicalDeviceSubgroupProperties& operator=(const safe_VkPhysicalDeviceSubgroupProperties& copy_src); 1090 safe_VkPhysicalDeviceSubgroupProperties(); 1091 ~safe_VkPhysicalDeviceSubgroupProperties(); 1092 void initialize(const VkPhysicalDeviceSubgroupProperties* in_struct); 1093 void initialize(const safe_VkPhysicalDeviceSubgroupProperties* copy_src); ptrsafe_VkPhysicalDeviceSubgroupProperties1094 VkPhysicalDeviceSubgroupProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceSubgroupProperties *>(this); } ptrsafe_VkPhysicalDeviceSubgroupProperties1095 VkPhysicalDeviceSubgroupProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSubgroupProperties const *>(this); } 1096 }; 1097 1098 struct safe_VkBindBufferMemoryInfo { 1099 VkStructureType sType; 1100 const void* pNext; 1101 VkBuffer buffer; 1102 VkDeviceMemory memory; 1103 VkDeviceSize memoryOffset; 1104 safe_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo* in_struct); 1105 safe_VkBindBufferMemoryInfo(const safe_VkBindBufferMemoryInfo& copy_src); 1106 safe_VkBindBufferMemoryInfo& operator=(const safe_VkBindBufferMemoryInfo& copy_src); 1107 safe_VkBindBufferMemoryInfo(); 1108 ~safe_VkBindBufferMemoryInfo(); 1109 void initialize(const VkBindBufferMemoryInfo* in_struct); 1110 void initialize(const safe_VkBindBufferMemoryInfo* copy_src); ptrsafe_VkBindBufferMemoryInfo1111 VkBindBufferMemoryInfo *ptr() { return reinterpret_cast<VkBindBufferMemoryInfo *>(this); } ptrsafe_VkBindBufferMemoryInfo1112 VkBindBufferMemoryInfo const *ptr() const { return reinterpret_cast<VkBindBufferMemoryInfo const *>(this); } 1113 }; 1114 1115 struct safe_VkBindImageMemoryInfo { 1116 VkStructureType sType; 1117 const void* pNext; 1118 VkImage image; 1119 VkDeviceMemory memory; 1120 VkDeviceSize memoryOffset; 1121 safe_VkBindImageMemoryInfo(const VkBindImageMemoryInfo* in_struct); 1122 safe_VkBindImageMemoryInfo(const safe_VkBindImageMemoryInfo& copy_src); 1123 safe_VkBindImageMemoryInfo& operator=(const safe_VkBindImageMemoryInfo& copy_src); 1124 safe_VkBindImageMemoryInfo(); 1125 ~safe_VkBindImageMemoryInfo(); 1126 void initialize(const VkBindImageMemoryInfo* in_struct); 1127 void initialize(const safe_VkBindImageMemoryInfo* copy_src); ptrsafe_VkBindImageMemoryInfo1128 VkBindImageMemoryInfo *ptr() { return reinterpret_cast<VkBindImageMemoryInfo *>(this); } ptrsafe_VkBindImageMemoryInfo1129 VkBindImageMemoryInfo const *ptr() const { return reinterpret_cast<VkBindImageMemoryInfo const *>(this); } 1130 }; 1131 1132 struct safe_VkPhysicalDevice16BitStorageFeatures { 1133 VkStructureType sType; 1134 void* pNext; 1135 VkBool32 storageBuffer16BitAccess; 1136 VkBool32 uniformAndStorageBuffer16BitAccess; 1137 VkBool32 storagePushConstant16; 1138 VkBool32 storageInputOutput16; 1139 safe_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures* in_struct); 1140 safe_VkPhysicalDevice16BitStorageFeatures(const safe_VkPhysicalDevice16BitStorageFeatures& copy_src); 1141 safe_VkPhysicalDevice16BitStorageFeatures& operator=(const safe_VkPhysicalDevice16BitStorageFeatures& copy_src); 1142 safe_VkPhysicalDevice16BitStorageFeatures(); 1143 ~safe_VkPhysicalDevice16BitStorageFeatures(); 1144 void initialize(const VkPhysicalDevice16BitStorageFeatures* in_struct); 1145 void initialize(const safe_VkPhysicalDevice16BitStorageFeatures* copy_src); ptrsafe_VkPhysicalDevice16BitStorageFeatures1146 VkPhysicalDevice16BitStorageFeatures *ptr() { return reinterpret_cast<VkPhysicalDevice16BitStorageFeatures *>(this); } ptrsafe_VkPhysicalDevice16BitStorageFeatures1147 VkPhysicalDevice16BitStorageFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDevice16BitStorageFeatures const *>(this); } 1148 }; 1149 1150 struct safe_VkMemoryDedicatedRequirements { 1151 VkStructureType sType; 1152 void* pNext; 1153 VkBool32 prefersDedicatedAllocation; 1154 VkBool32 requiresDedicatedAllocation; 1155 safe_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements* in_struct); 1156 safe_VkMemoryDedicatedRequirements(const safe_VkMemoryDedicatedRequirements& copy_src); 1157 safe_VkMemoryDedicatedRequirements& operator=(const safe_VkMemoryDedicatedRequirements& copy_src); 1158 safe_VkMemoryDedicatedRequirements(); 1159 ~safe_VkMemoryDedicatedRequirements(); 1160 void initialize(const VkMemoryDedicatedRequirements* in_struct); 1161 void initialize(const safe_VkMemoryDedicatedRequirements* copy_src); ptrsafe_VkMemoryDedicatedRequirements1162 VkMemoryDedicatedRequirements *ptr() { return reinterpret_cast<VkMemoryDedicatedRequirements *>(this); } ptrsafe_VkMemoryDedicatedRequirements1163 VkMemoryDedicatedRequirements const *ptr() const { return reinterpret_cast<VkMemoryDedicatedRequirements const *>(this); } 1164 }; 1165 1166 struct safe_VkMemoryDedicatedAllocateInfo { 1167 VkStructureType sType; 1168 const void* pNext; 1169 VkImage image; 1170 VkBuffer buffer; 1171 safe_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo* in_struct); 1172 safe_VkMemoryDedicatedAllocateInfo(const safe_VkMemoryDedicatedAllocateInfo& copy_src); 1173 safe_VkMemoryDedicatedAllocateInfo& operator=(const safe_VkMemoryDedicatedAllocateInfo& copy_src); 1174 safe_VkMemoryDedicatedAllocateInfo(); 1175 ~safe_VkMemoryDedicatedAllocateInfo(); 1176 void initialize(const VkMemoryDedicatedAllocateInfo* in_struct); 1177 void initialize(const safe_VkMemoryDedicatedAllocateInfo* copy_src); ptrsafe_VkMemoryDedicatedAllocateInfo1178 VkMemoryDedicatedAllocateInfo *ptr() { return reinterpret_cast<VkMemoryDedicatedAllocateInfo *>(this); } ptrsafe_VkMemoryDedicatedAllocateInfo1179 VkMemoryDedicatedAllocateInfo const *ptr() const { return reinterpret_cast<VkMemoryDedicatedAllocateInfo const *>(this); } 1180 }; 1181 1182 struct safe_VkMemoryAllocateFlagsInfo { 1183 VkStructureType sType; 1184 const void* pNext; 1185 VkMemoryAllocateFlags flags; 1186 uint32_t deviceMask; 1187 safe_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo* in_struct); 1188 safe_VkMemoryAllocateFlagsInfo(const safe_VkMemoryAllocateFlagsInfo& copy_src); 1189 safe_VkMemoryAllocateFlagsInfo& operator=(const safe_VkMemoryAllocateFlagsInfo& copy_src); 1190 safe_VkMemoryAllocateFlagsInfo(); 1191 ~safe_VkMemoryAllocateFlagsInfo(); 1192 void initialize(const VkMemoryAllocateFlagsInfo* in_struct); 1193 void initialize(const safe_VkMemoryAllocateFlagsInfo* copy_src); ptrsafe_VkMemoryAllocateFlagsInfo1194 VkMemoryAllocateFlagsInfo *ptr() { return reinterpret_cast<VkMemoryAllocateFlagsInfo *>(this); } ptrsafe_VkMemoryAllocateFlagsInfo1195 VkMemoryAllocateFlagsInfo const *ptr() const { return reinterpret_cast<VkMemoryAllocateFlagsInfo const *>(this); } 1196 }; 1197 1198 struct safe_VkDeviceGroupRenderPassBeginInfo { 1199 VkStructureType sType; 1200 const void* pNext; 1201 uint32_t deviceMask; 1202 uint32_t deviceRenderAreaCount; 1203 const VkRect2D* pDeviceRenderAreas; 1204 safe_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo* in_struct); 1205 safe_VkDeviceGroupRenderPassBeginInfo(const safe_VkDeviceGroupRenderPassBeginInfo& copy_src); 1206 safe_VkDeviceGroupRenderPassBeginInfo& operator=(const safe_VkDeviceGroupRenderPassBeginInfo& copy_src); 1207 safe_VkDeviceGroupRenderPassBeginInfo(); 1208 ~safe_VkDeviceGroupRenderPassBeginInfo(); 1209 void initialize(const VkDeviceGroupRenderPassBeginInfo* in_struct); 1210 void initialize(const safe_VkDeviceGroupRenderPassBeginInfo* copy_src); ptrsafe_VkDeviceGroupRenderPassBeginInfo1211 VkDeviceGroupRenderPassBeginInfo *ptr() { return reinterpret_cast<VkDeviceGroupRenderPassBeginInfo *>(this); } ptrsafe_VkDeviceGroupRenderPassBeginInfo1212 VkDeviceGroupRenderPassBeginInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupRenderPassBeginInfo const *>(this); } 1213 }; 1214 1215 struct safe_VkDeviceGroupCommandBufferBeginInfo { 1216 VkStructureType sType; 1217 const void* pNext; 1218 uint32_t deviceMask; 1219 safe_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo* in_struct); 1220 safe_VkDeviceGroupCommandBufferBeginInfo(const safe_VkDeviceGroupCommandBufferBeginInfo& copy_src); 1221 safe_VkDeviceGroupCommandBufferBeginInfo& operator=(const safe_VkDeviceGroupCommandBufferBeginInfo& copy_src); 1222 safe_VkDeviceGroupCommandBufferBeginInfo(); 1223 ~safe_VkDeviceGroupCommandBufferBeginInfo(); 1224 void initialize(const VkDeviceGroupCommandBufferBeginInfo* in_struct); 1225 void initialize(const safe_VkDeviceGroupCommandBufferBeginInfo* copy_src); ptrsafe_VkDeviceGroupCommandBufferBeginInfo1226 VkDeviceGroupCommandBufferBeginInfo *ptr() { return reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo *>(this); } ptrsafe_VkDeviceGroupCommandBufferBeginInfo1227 VkDeviceGroupCommandBufferBeginInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo const *>(this); } 1228 }; 1229 1230 struct safe_VkDeviceGroupSubmitInfo { 1231 VkStructureType sType; 1232 const void* pNext; 1233 uint32_t waitSemaphoreCount; 1234 const uint32_t* pWaitSemaphoreDeviceIndices; 1235 uint32_t commandBufferCount; 1236 const uint32_t* pCommandBufferDeviceMasks; 1237 uint32_t signalSemaphoreCount; 1238 const uint32_t* pSignalSemaphoreDeviceIndices; 1239 safe_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo* in_struct); 1240 safe_VkDeviceGroupSubmitInfo(const safe_VkDeviceGroupSubmitInfo& copy_src); 1241 safe_VkDeviceGroupSubmitInfo& operator=(const safe_VkDeviceGroupSubmitInfo& copy_src); 1242 safe_VkDeviceGroupSubmitInfo(); 1243 ~safe_VkDeviceGroupSubmitInfo(); 1244 void initialize(const VkDeviceGroupSubmitInfo* in_struct); 1245 void initialize(const safe_VkDeviceGroupSubmitInfo* copy_src); ptrsafe_VkDeviceGroupSubmitInfo1246 VkDeviceGroupSubmitInfo *ptr() { return reinterpret_cast<VkDeviceGroupSubmitInfo *>(this); } ptrsafe_VkDeviceGroupSubmitInfo1247 VkDeviceGroupSubmitInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupSubmitInfo const *>(this); } 1248 }; 1249 1250 struct safe_VkDeviceGroupBindSparseInfo { 1251 VkStructureType sType; 1252 const void* pNext; 1253 uint32_t resourceDeviceIndex; 1254 uint32_t memoryDeviceIndex; 1255 safe_VkDeviceGroupBindSparseInfo(const VkDeviceGroupBindSparseInfo* in_struct); 1256 safe_VkDeviceGroupBindSparseInfo(const safe_VkDeviceGroupBindSparseInfo& copy_src); 1257 safe_VkDeviceGroupBindSparseInfo& operator=(const safe_VkDeviceGroupBindSparseInfo& copy_src); 1258 safe_VkDeviceGroupBindSparseInfo(); 1259 ~safe_VkDeviceGroupBindSparseInfo(); 1260 void initialize(const VkDeviceGroupBindSparseInfo* in_struct); 1261 void initialize(const safe_VkDeviceGroupBindSparseInfo* copy_src); ptrsafe_VkDeviceGroupBindSparseInfo1262 VkDeviceGroupBindSparseInfo *ptr() { return reinterpret_cast<VkDeviceGroupBindSparseInfo *>(this); } ptrsafe_VkDeviceGroupBindSparseInfo1263 VkDeviceGroupBindSparseInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupBindSparseInfo const *>(this); } 1264 }; 1265 1266 struct safe_VkBindBufferMemoryDeviceGroupInfo { 1267 VkStructureType sType; 1268 const void* pNext; 1269 uint32_t deviceIndexCount; 1270 const uint32_t* pDeviceIndices; 1271 safe_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo* in_struct); 1272 safe_VkBindBufferMemoryDeviceGroupInfo(const safe_VkBindBufferMemoryDeviceGroupInfo& copy_src); 1273 safe_VkBindBufferMemoryDeviceGroupInfo& operator=(const safe_VkBindBufferMemoryDeviceGroupInfo& copy_src); 1274 safe_VkBindBufferMemoryDeviceGroupInfo(); 1275 ~safe_VkBindBufferMemoryDeviceGroupInfo(); 1276 void initialize(const VkBindBufferMemoryDeviceGroupInfo* in_struct); 1277 void initialize(const safe_VkBindBufferMemoryDeviceGroupInfo* copy_src); ptrsafe_VkBindBufferMemoryDeviceGroupInfo1278 VkBindBufferMemoryDeviceGroupInfo *ptr() { return reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo *>(this); } ptrsafe_VkBindBufferMemoryDeviceGroupInfo1279 VkBindBufferMemoryDeviceGroupInfo const *ptr() const { return reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo const *>(this); } 1280 }; 1281 1282 struct safe_VkBindImageMemoryDeviceGroupInfo { 1283 VkStructureType sType; 1284 const void* pNext; 1285 uint32_t deviceIndexCount; 1286 const uint32_t* pDeviceIndices; 1287 uint32_t splitInstanceBindRegionCount; 1288 const VkRect2D* pSplitInstanceBindRegions; 1289 safe_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo* in_struct); 1290 safe_VkBindImageMemoryDeviceGroupInfo(const safe_VkBindImageMemoryDeviceGroupInfo& copy_src); 1291 safe_VkBindImageMemoryDeviceGroupInfo& operator=(const safe_VkBindImageMemoryDeviceGroupInfo& copy_src); 1292 safe_VkBindImageMemoryDeviceGroupInfo(); 1293 ~safe_VkBindImageMemoryDeviceGroupInfo(); 1294 void initialize(const VkBindImageMemoryDeviceGroupInfo* in_struct); 1295 void initialize(const safe_VkBindImageMemoryDeviceGroupInfo* copy_src); ptrsafe_VkBindImageMemoryDeviceGroupInfo1296 VkBindImageMemoryDeviceGroupInfo *ptr() { return reinterpret_cast<VkBindImageMemoryDeviceGroupInfo *>(this); } ptrsafe_VkBindImageMemoryDeviceGroupInfo1297 VkBindImageMemoryDeviceGroupInfo const *ptr() const { return reinterpret_cast<VkBindImageMemoryDeviceGroupInfo const *>(this); } 1298 }; 1299 1300 struct safe_VkPhysicalDeviceGroupProperties { 1301 VkStructureType sType; 1302 void* pNext; 1303 uint32_t physicalDeviceCount; 1304 VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; 1305 VkBool32 subsetAllocation; 1306 safe_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties* in_struct); 1307 safe_VkPhysicalDeviceGroupProperties(const safe_VkPhysicalDeviceGroupProperties& copy_src); 1308 safe_VkPhysicalDeviceGroupProperties& operator=(const safe_VkPhysicalDeviceGroupProperties& copy_src); 1309 safe_VkPhysicalDeviceGroupProperties(); 1310 ~safe_VkPhysicalDeviceGroupProperties(); 1311 void initialize(const VkPhysicalDeviceGroupProperties* in_struct); 1312 void initialize(const safe_VkPhysicalDeviceGroupProperties* copy_src); ptrsafe_VkPhysicalDeviceGroupProperties1313 VkPhysicalDeviceGroupProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceGroupProperties *>(this); } ptrsafe_VkPhysicalDeviceGroupProperties1314 VkPhysicalDeviceGroupProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceGroupProperties const *>(this); } 1315 }; 1316 1317 struct safe_VkDeviceGroupDeviceCreateInfo { 1318 VkStructureType sType; 1319 const void* pNext; 1320 uint32_t physicalDeviceCount; 1321 VkPhysicalDevice* pPhysicalDevices; 1322 safe_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo* in_struct); 1323 safe_VkDeviceGroupDeviceCreateInfo(const safe_VkDeviceGroupDeviceCreateInfo& copy_src); 1324 safe_VkDeviceGroupDeviceCreateInfo& operator=(const safe_VkDeviceGroupDeviceCreateInfo& copy_src); 1325 safe_VkDeviceGroupDeviceCreateInfo(); 1326 ~safe_VkDeviceGroupDeviceCreateInfo(); 1327 void initialize(const VkDeviceGroupDeviceCreateInfo* in_struct); 1328 void initialize(const safe_VkDeviceGroupDeviceCreateInfo* copy_src); ptrsafe_VkDeviceGroupDeviceCreateInfo1329 VkDeviceGroupDeviceCreateInfo *ptr() { return reinterpret_cast<VkDeviceGroupDeviceCreateInfo *>(this); } ptrsafe_VkDeviceGroupDeviceCreateInfo1330 VkDeviceGroupDeviceCreateInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupDeviceCreateInfo const *>(this); } 1331 }; 1332 1333 struct safe_VkBufferMemoryRequirementsInfo2 { 1334 VkStructureType sType; 1335 const void* pNext; 1336 VkBuffer buffer; 1337 safe_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2* in_struct); 1338 safe_VkBufferMemoryRequirementsInfo2(const safe_VkBufferMemoryRequirementsInfo2& copy_src); 1339 safe_VkBufferMemoryRequirementsInfo2& operator=(const safe_VkBufferMemoryRequirementsInfo2& copy_src); 1340 safe_VkBufferMemoryRequirementsInfo2(); 1341 ~safe_VkBufferMemoryRequirementsInfo2(); 1342 void initialize(const VkBufferMemoryRequirementsInfo2* in_struct); 1343 void initialize(const safe_VkBufferMemoryRequirementsInfo2* copy_src); ptrsafe_VkBufferMemoryRequirementsInfo21344 VkBufferMemoryRequirementsInfo2 *ptr() { return reinterpret_cast<VkBufferMemoryRequirementsInfo2 *>(this); } ptrsafe_VkBufferMemoryRequirementsInfo21345 VkBufferMemoryRequirementsInfo2 const *ptr() const { return reinterpret_cast<VkBufferMemoryRequirementsInfo2 const *>(this); } 1346 }; 1347 1348 struct safe_VkImageMemoryRequirementsInfo2 { 1349 VkStructureType sType; 1350 const void* pNext; 1351 VkImage image; 1352 safe_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2* in_struct); 1353 safe_VkImageMemoryRequirementsInfo2(const safe_VkImageMemoryRequirementsInfo2& copy_src); 1354 safe_VkImageMemoryRequirementsInfo2& operator=(const safe_VkImageMemoryRequirementsInfo2& copy_src); 1355 safe_VkImageMemoryRequirementsInfo2(); 1356 ~safe_VkImageMemoryRequirementsInfo2(); 1357 void initialize(const VkImageMemoryRequirementsInfo2* in_struct); 1358 void initialize(const safe_VkImageMemoryRequirementsInfo2* copy_src); ptrsafe_VkImageMemoryRequirementsInfo21359 VkImageMemoryRequirementsInfo2 *ptr() { return reinterpret_cast<VkImageMemoryRequirementsInfo2 *>(this); } ptrsafe_VkImageMemoryRequirementsInfo21360 VkImageMemoryRequirementsInfo2 const *ptr() const { return reinterpret_cast<VkImageMemoryRequirementsInfo2 const *>(this); } 1361 }; 1362 1363 struct safe_VkImageSparseMemoryRequirementsInfo2 { 1364 VkStructureType sType; 1365 const void* pNext; 1366 VkImage image; 1367 safe_VkImageSparseMemoryRequirementsInfo2(const VkImageSparseMemoryRequirementsInfo2* in_struct); 1368 safe_VkImageSparseMemoryRequirementsInfo2(const safe_VkImageSparseMemoryRequirementsInfo2& copy_src); 1369 safe_VkImageSparseMemoryRequirementsInfo2& operator=(const safe_VkImageSparseMemoryRequirementsInfo2& copy_src); 1370 safe_VkImageSparseMemoryRequirementsInfo2(); 1371 ~safe_VkImageSparseMemoryRequirementsInfo2(); 1372 void initialize(const VkImageSparseMemoryRequirementsInfo2* in_struct); 1373 void initialize(const safe_VkImageSparseMemoryRequirementsInfo2* copy_src); ptrsafe_VkImageSparseMemoryRequirementsInfo21374 VkImageSparseMemoryRequirementsInfo2 *ptr() { return reinterpret_cast<VkImageSparseMemoryRequirementsInfo2 *>(this); } ptrsafe_VkImageSparseMemoryRequirementsInfo21375 VkImageSparseMemoryRequirementsInfo2 const *ptr() const { return reinterpret_cast<VkImageSparseMemoryRequirementsInfo2 const *>(this); } 1376 }; 1377 1378 struct safe_VkMemoryRequirements2 { 1379 VkStructureType sType; 1380 void* pNext; 1381 VkMemoryRequirements memoryRequirements; 1382 safe_VkMemoryRequirements2(const VkMemoryRequirements2* in_struct); 1383 safe_VkMemoryRequirements2(const safe_VkMemoryRequirements2& copy_src); 1384 safe_VkMemoryRequirements2& operator=(const safe_VkMemoryRequirements2& copy_src); 1385 safe_VkMemoryRequirements2(); 1386 ~safe_VkMemoryRequirements2(); 1387 void initialize(const VkMemoryRequirements2* in_struct); 1388 void initialize(const safe_VkMemoryRequirements2* copy_src); ptrsafe_VkMemoryRequirements21389 VkMemoryRequirements2 *ptr() { return reinterpret_cast<VkMemoryRequirements2 *>(this); } ptrsafe_VkMemoryRequirements21390 VkMemoryRequirements2 const *ptr() const { return reinterpret_cast<VkMemoryRequirements2 const *>(this); } 1391 }; 1392 1393 struct safe_VkSparseImageMemoryRequirements2 { 1394 VkStructureType sType; 1395 void* pNext; 1396 VkSparseImageMemoryRequirements memoryRequirements; 1397 safe_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2* in_struct); 1398 safe_VkSparseImageMemoryRequirements2(const safe_VkSparseImageMemoryRequirements2& copy_src); 1399 safe_VkSparseImageMemoryRequirements2& operator=(const safe_VkSparseImageMemoryRequirements2& copy_src); 1400 safe_VkSparseImageMemoryRequirements2(); 1401 ~safe_VkSparseImageMemoryRequirements2(); 1402 void initialize(const VkSparseImageMemoryRequirements2* in_struct); 1403 void initialize(const safe_VkSparseImageMemoryRequirements2* copy_src); ptrsafe_VkSparseImageMemoryRequirements21404 VkSparseImageMemoryRequirements2 *ptr() { return reinterpret_cast<VkSparseImageMemoryRequirements2 *>(this); } ptrsafe_VkSparseImageMemoryRequirements21405 VkSparseImageMemoryRequirements2 const *ptr() const { return reinterpret_cast<VkSparseImageMemoryRequirements2 const *>(this); } 1406 }; 1407 1408 struct safe_VkPhysicalDeviceFeatures2 { 1409 VkStructureType sType; 1410 void* pNext; 1411 VkPhysicalDeviceFeatures features; 1412 safe_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2* in_struct); 1413 safe_VkPhysicalDeviceFeatures2(const safe_VkPhysicalDeviceFeatures2& copy_src); 1414 safe_VkPhysicalDeviceFeatures2& operator=(const safe_VkPhysicalDeviceFeatures2& copy_src); 1415 safe_VkPhysicalDeviceFeatures2(); 1416 ~safe_VkPhysicalDeviceFeatures2(); 1417 void initialize(const VkPhysicalDeviceFeatures2* in_struct); 1418 void initialize(const safe_VkPhysicalDeviceFeatures2* copy_src); ptrsafe_VkPhysicalDeviceFeatures21419 VkPhysicalDeviceFeatures2 *ptr() { return reinterpret_cast<VkPhysicalDeviceFeatures2 *>(this); } ptrsafe_VkPhysicalDeviceFeatures21420 VkPhysicalDeviceFeatures2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFeatures2 const *>(this); } 1421 }; 1422 1423 struct safe_VkPhysicalDeviceProperties2 { 1424 VkStructureType sType; 1425 void* pNext; 1426 VkPhysicalDeviceProperties properties; 1427 safe_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2* in_struct); 1428 safe_VkPhysicalDeviceProperties2(const safe_VkPhysicalDeviceProperties2& copy_src); 1429 safe_VkPhysicalDeviceProperties2& operator=(const safe_VkPhysicalDeviceProperties2& copy_src); 1430 safe_VkPhysicalDeviceProperties2(); 1431 ~safe_VkPhysicalDeviceProperties2(); 1432 void initialize(const VkPhysicalDeviceProperties2* in_struct); 1433 void initialize(const safe_VkPhysicalDeviceProperties2* copy_src); ptrsafe_VkPhysicalDeviceProperties21434 VkPhysicalDeviceProperties2 *ptr() { return reinterpret_cast<VkPhysicalDeviceProperties2 *>(this); } ptrsafe_VkPhysicalDeviceProperties21435 VkPhysicalDeviceProperties2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceProperties2 const *>(this); } 1436 }; 1437 1438 struct safe_VkFormatProperties2 { 1439 VkStructureType sType; 1440 void* pNext; 1441 VkFormatProperties formatProperties; 1442 safe_VkFormatProperties2(const VkFormatProperties2* in_struct); 1443 safe_VkFormatProperties2(const safe_VkFormatProperties2& copy_src); 1444 safe_VkFormatProperties2& operator=(const safe_VkFormatProperties2& copy_src); 1445 safe_VkFormatProperties2(); 1446 ~safe_VkFormatProperties2(); 1447 void initialize(const VkFormatProperties2* in_struct); 1448 void initialize(const safe_VkFormatProperties2* copy_src); ptrsafe_VkFormatProperties21449 VkFormatProperties2 *ptr() { return reinterpret_cast<VkFormatProperties2 *>(this); } ptrsafe_VkFormatProperties21450 VkFormatProperties2 const *ptr() const { return reinterpret_cast<VkFormatProperties2 const *>(this); } 1451 }; 1452 1453 struct safe_VkImageFormatProperties2 { 1454 VkStructureType sType; 1455 void* pNext; 1456 VkImageFormatProperties imageFormatProperties; 1457 safe_VkImageFormatProperties2(const VkImageFormatProperties2* in_struct); 1458 safe_VkImageFormatProperties2(const safe_VkImageFormatProperties2& copy_src); 1459 safe_VkImageFormatProperties2& operator=(const safe_VkImageFormatProperties2& copy_src); 1460 safe_VkImageFormatProperties2(); 1461 ~safe_VkImageFormatProperties2(); 1462 void initialize(const VkImageFormatProperties2* in_struct); 1463 void initialize(const safe_VkImageFormatProperties2* copy_src); ptrsafe_VkImageFormatProperties21464 VkImageFormatProperties2 *ptr() { return reinterpret_cast<VkImageFormatProperties2 *>(this); } ptrsafe_VkImageFormatProperties21465 VkImageFormatProperties2 const *ptr() const { return reinterpret_cast<VkImageFormatProperties2 const *>(this); } 1466 }; 1467 1468 struct safe_VkPhysicalDeviceImageFormatInfo2 { 1469 VkStructureType sType; 1470 const void* pNext; 1471 VkFormat format; 1472 VkImageType type; 1473 VkImageTiling tiling; 1474 VkImageUsageFlags usage; 1475 VkImageCreateFlags flags; 1476 safe_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2* in_struct); 1477 safe_VkPhysicalDeviceImageFormatInfo2(const safe_VkPhysicalDeviceImageFormatInfo2& copy_src); 1478 safe_VkPhysicalDeviceImageFormatInfo2& operator=(const safe_VkPhysicalDeviceImageFormatInfo2& copy_src); 1479 safe_VkPhysicalDeviceImageFormatInfo2(); 1480 ~safe_VkPhysicalDeviceImageFormatInfo2(); 1481 void initialize(const VkPhysicalDeviceImageFormatInfo2* in_struct); 1482 void initialize(const safe_VkPhysicalDeviceImageFormatInfo2* copy_src); ptrsafe_VkPhysicalDeviceImageFormatInfo21483 VkPhysicalDeviceImageFormatInfo2 *ptr() { return reinterpret_cast<VkPhysicalDeviceImageFormatInfo2 *>(this); } ptrsafe_VkPhysicalDeviceImageFormatInfo21484 VkPhysicalDeviceImageFormatInfo2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceImageFormatInfo2 const *>(this); } 1485 }; 1486 1487 struct safe_VkQueueFamilyProperties2 { 1488 VkStructureType sType; 1489 void* pNext; 1490 VkQueueFamilyProperties queueFamilyProperties; 1491 safe_VkQueueFamilyProperties2(const VkQueueFamilyProperties2* in_struct); 1492 safe_VkQueueFamilyProperties2(const safe_VkQueueFamilyProperties2& copy_src); 1493 safe_VkQueueFamilyProperties2& operator=(const safe_VkQueueFamilyProperties2& copy_src); 1494 safe_VkQueueFamilyProperties2(); 1495 ~safe_VkQueueFamilyProperties2(); 1496 void initialize(const VkQueueFamilyProperties2* in_struct); 1497 void initialize(const safe_VkQueueFamilyProperties2* copy_src); ptrsafe_VkQueueFamilyProperties21498 VkQueueFamilyProperties2 *ptr() { return reinterpret_cast<VkQueueFamilyProperties2 *>(this); } ptrsafe_VkQueueFamilyProperties21499 VkQueueFamilyProperties2 const *ptr() const { return reinterpret_cast<VkQueueFamilyProperties2 const *>(this); } 1500 }; 1501 1502 struct safe_VkPhysicalDeviceMemoryProperties2 { 1503 VkStructureType sType; 1504 void* pNext; 1505 VkPhysicalDeviceMemoryProperties memoryProperties; 1506 safe_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2* in_struct); 1507 safe_VkPhysicalDeviceMemoryProperties2(const safe_VkPhysicalDeviceMemoryProperties2& copy_src); 1508 safe_VkPhysicalDeviceMemoryProperties2& operator=(const safe_VkPhysicalDeviceMemoryProperties2& copy_src); 1509 safe_VkPhysicalDeviceMemoryProperties2(); 1510 ~safe_VkPhysicalDeviceMemoryProperties2(); 1511 void initialize(const VkPhysicalDeviceMemoryProperties2* in_struct); 1512 void initialize(const safe_VkPhysicalDeviceMemoryProperties2* copy_src); ptrsafe_VkPhysicalDeviceMemoryProperties21513 VkPhysicalDeviceMemoryProperties2 *ptr() { return reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>(this); } ptrsafe_VkPhysicalDeviceMemoryProperties21514 VkPhysicalDeviceMemoryProperties2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMemoryProperties2 const *>(this); } 1515 }; 1516 1517 struct safe_VkSparseImageFormatProperties2 { 1518 VkStructureType sType; 1519 void* pNext; 1520 VkSparseImageFormatProperties properties; 1521 safe_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2* in_struct); 1522 safe_VkSparseImageFormatProperties2(const safe_VkSparseImageFormatProperties2& copy_src); 1523 safe_VkSparseImageFormatProperties2& operator=(const safe_VkSparseImageFormatProperties2& copy_src); 1524 safe_VkSparseImageFormatProperties2(); 1525 ~safe_VkSparseImageFormatProperties2(); 1526 void initialize(const VkSparseImageFormatProperties2* in_struct); 1527 void initialize(const safe_VkSparseImageFormatProperties2* copy_src); ptrsafe_VkSparseImageFormatProperties21528 VkSparseImageFormatProperties2 *ptr() { return reinterpret_cast<VkSparseImageFormatProperties2 *>(this); } ptrsafe_VkSparseImageFormatProperties21529 VkSparseImageFormatProperties2 const *ptr() const { return reinterpret_cast<VkSparseImageFormatProperties2 const *>(this); } 1530 }; 1531 1532 struct safe_VkPhysicalDeviceSparseImageFormatInfo2 { 1533 VkStructureType sType; 1534 const void* pNext; 1535 VkFormat format; 1536 VkImageType type; 1537 VkSampleCountFlagBits samples; 1538 VkImageUsageFlags usage; 1539 VkImageTiling tiling; 1540 safe_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct); 1541 safe_VkPhysicalDeviceSparseImageFormatInfo2(const safe_VkPhysicalDeviceSparseImageFormatInfo2& copy_src); 1542 safe_VkPhysicalDeviceSparseImageFormatInfo2& operator=(const safe_VkPhysicalDeviceSparseImageFormatInfo2& copy_src); 1543 safe_VkPhysicalDeviceSparseImageFormatInfo2(); 1544 ~safe_VkPhysicalDeviceSparseImageFormatInfo2(); 1545 void initialize(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct); 1546 void initialize(const safe_VkPhysicalDeviceSparseImageFormatInfo2* copy_src); ptrsafe_VkPhysicalDeviceSparseImageFormatInfo21547 VkPhysicalDeviceSparseImageFormatInfo2 *ptr() { return reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2 *>(this); } ptrsafe_VkPhysicalDeviceSparseImageFormatInfo21548 VkPhysicalDeviceSparseImageFormatInfo2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2 const *>(this); } 1549 }; 1550 1551 struct safe_VkPhysicalDevicePointClippingProperties { 1552 VkStructureType sType; 1553 void* pNext; 1554 VkPointClippingBehavior pointClippingBehavior; 1555 safe_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties* in_struct); 1556 safe_VkPhysicalDevicePointClippingProperties(const safe_VkPhysicalDevicePointClippingProperties& copy_src); 1557 safe_VkPhysicalDevicePointClippingProperties& operator=(const safe_VkPhysicalDevicePointClippingProperties& copy_src); 1558 safe_VkPhysicalDevicePointClippingProperties(); 1559 ~safe_VkPhysicalDevicePointClippingProperties(); 1560 void initialize(const VkPhysicalDevicePointClippingProperties* in_struct); 1561 void initialize(const safe_VkPhysicalDevicePointClippingProperties* copy_src); ptrsafe_VkPhysicalDevicePointClippingProperties1562 VkPhysicalDevicePointClippingProperties *ptr() { return reinterpret_cast<VkPhysicalDevicePointClippingProperties *>(this); } ptrsafe_VkPhysicalDevicePointClippingProperties1563 VkPhysicalDevicePointClippingProperties const *ptr() const { return reinterpret_cast<VkPhysicalDevicePointClippingProperties const *>(this); } 1564 }; 1565 1566 struct safe_VkRenderPassInputAttachmentAspectCreateInfo { 1567 VkStructureType sType; 1568 const void* pNext; 1569 uint32_t aspectReferenceCount; 1570 const VkInputAttachmentAspectReference* pAspectReferences; 1571 safe_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct); 1572 safe_VkRenderPassInputAttachmentAspectCreateInfo(const safe_VkRenderPassInputAttachmentAspectCreateInfo& copy_src); 1573 safe_VkRenderPassInputAttachmentAspectCreateInfo& operator=(const safe_VkRenderPassInputAttachmentAspectCreateInfo& copy_src); 1574 safe_VkRenderPassInputAttachmentAspectCreateInfo(); 1575 ~safe_VkRenderPassInputAttachmentAspectCreateInfo(); 1576 void initialize(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct); 1577 void initialize(const safe_VkRenderPassInputAttachmentAspectCreateInfo* copy_src); ptrsafe_VkRenderPassInputAttachmentAspectCreateInfo1578 VkRenderPassInputAttachmentAspectCreateInfo *ptr() { return reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo *>(this); } ptrsafe_VkRenderPassInputAttachmentAspectCreateInfo1579 VkRenderPassInputAttachmentAspectCreateInfo const *ptr() const { return reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo const *>(this); } 1580 }; 1581 1582 struct safe_VkImageViewUsageCreateInfo { 1583 VkStructureType sType; 1584 const void* pNext; 1585 VkImageUsageFlags usage; 1586 safe_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo* in_struct); 1587 safe_VkImageViewUsageCreateInfo(const safe_VkImageViewUsageCreateInfo& copy_src); 1588 safe_VkImageViewUsageCreateInfo& operator=(const safe_VkImageViewUsageCreateInfo& copy_src); 1589 safe_VkImageViewUsageCreateInfo(); 1590 ~safe_VkImageViewUsageCreateInfo(); 1591 void initialize(const VkImageViewUsageCreateInfo* in_struct); 1592 void initialize(const safe_VkImageViewUsageCreateInfo* copy_src); ptrsafe_VkImageViewUsageCreateInfo1593 VkImageViewUsageCreateInfo *ptr() { return reinterpret_cast<VkImageViewUsageCreateInfo *>(this); } ptrsafe_VkImageViewUsageCreateInfo1594 VkImageViewUsageCreateInfo const *ptr() const { return reinterpret_cast<VkImageViewUsageCreateInfo const *>(this); } 1595 }; 1596 1597 struct safe_VkPipelineTessellationDomainOriginStateCreateInfo { 1598 VkStructureType sType; 1599 const void* pNext; 1600 VkTessellationDomainOrigin domainOrigin; 1601 safe_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct); 1602 safe_VkPipelineTessellationDomainOriginStateCreateInfo(const safe_VkPipelineTessellationDomainOriginStateCreateInfo& copy_src); 1603 safe_VkPipelineTessellationDomainOriginStateCreateInfo& operator=(const safe_VkPipelineTessellationDomainOriginStateCreateInfo& copy_src); 1604 safe_VkPipelineTessellationDomainOriginStateCreateInfo(); 1605 ~safe_VkPipelineTessellationDomainOriginStateCreateInfo(); 1606 void initialize(const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct); 1607 void initialize(const safe_VkPipelineTessellationDomainOriginStateCreateInfo* copy_src); ptrsafe_VkPipelineTessellationDomainOriginStateCreateInfo1608 VkPipelineTessellationDomainOriginStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo *>(this); } ptrsafe_VkPipelineTessellationDomainOriginStateCreateInfo1609 VkPipelineTessellationDomainOriginStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo const *>(this); } 1610 }; 1611 1612 struct safe_VkRenderPassMultiviewCreateInfo { 1613 VkStructureType sType; 1614 const void* pNext; 1615 uint32_t subpassCount; 1616 const uint32_t* pViewMasks; 1617 uint32_t dependencyCount; 1618 const int32_t* pViewOffsets; 1619 uint32_t correlationMaskCount; 1620 const uint32_t* pCorrelationMasks; 1621 safe_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo* in_struct); 1622 safe_VkRenderPassMultiviewCreateInfo(const safe_VkRenderPassMultiviewCreateInfo& copy_src); 1623 safe_VkRenderPassMultiviewCreateInfo& operator=(const safe_VkRenderPassMultiviewCreateInfo& copy_src); 1624 safe_VkRenderPassMultiviewCreateInfo(); 1625 ~safe_VkRenderPassMultiviewCreateInfo(); 1626 void initialize(const VkRenderPassMultiviewCreateInfo* in_struct); 1627 void initialize(const safe_VkRenderPassMultiviewCreateInfo* copy_src); ptrsafe_VkRenderPassMultiviewCreateInfo1628 VkRenderPassMultiviewCreateInfo *ptr() { return reinterpret_cast<VkRenderPassMultiviewCreateInfo *>(this); } ptrsafe_VkRenderPassMultiviewCreateInfo1629 VkRenderPassMultiviewCreateInfo const *ptr() const { return reinterpret_cast<VkRenderPassMultiviewCreateInfo const *>(this); } 1630 }; 1631 1632 struct safe_VkPhysicalDeviceMultiviewFeatures { 1633 VkStructureType sType; 1634 void* pNext; 1635 VkBool32 multiview; 1636 VkBool32 multiviewGeometryShader; 1637 VkBool32 multiviewTessellationShader; 1638 safe_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures* in_struct); 1639 safe_VkPhysicalDeviceMultiviewFeatures(const safe_VkPhysicalDeviceMultiviewFeatures& copy_src); 1640 safe_VkPhysicalDeviceMultiviewFeatures& operator=(const safe_VkPhysicalDeviceMultiviewFeatures& copy_src); 1641 safe_VkPhysicalDeviceMultiviewFeatures(); 1642 ~safe_VkPhysicalDeviceMultiviewFeatures(); 1643 void initialize(const VkPhysicalDeviceMultiviewFeatures* in_struct); 1644 void initialize(const safe_VkPhysicalDeviceMultiviewFeatures* copy_src); ptrsafe_VkPhysicalDeviceMultiviewFeatures1645 VkPhysicalDeviceMultiviewFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceMultiviewFeatures *>(this); } ptrsafe_VkPhysicalDeviceMultiviewFeatures1646 VkPhysicalDeviceMultiviewFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMultiviewFeatures const *>(this); } 1647 }; 1648 1649 struct safe_VkPhysicalDeviceMultiviewProperties { 1650 VkStructureType sType; 1651 void* pNext; 1652 uint32_t maxMultiviewViewCount; 1653 uint32_t maxMultiviewInstanceIndex; 1654 safe_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties* in_struct); 1655 safe_VkPhysicalDeviceMultiviewProperties(const safe_VkPhysicalDeviceMultiviewProperties& copy_src); 1656 safe_VkPhysicalDeviceMultiviewProperties& operator=(const safe_VkPhysicalDeviceMultiviewProperties& copy_src); 1657 safe_VkPhysicalDeviceMultiviewProperties(); 1658 ~safe_VkPhysicalDeviceMultiviewProperties(); 1659 void initialize(const VkPhysicalDeviceMultiviewProperties* in_struct); 1660 void initialize(const safe_VkPhysicalDeviceMultiviewProperties* copy_src); ptrsafe_VkPhysicalDeviceMultiviewProperties1661 VkPhysicalDeviceMultiviewProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceMultiviewProperties *>(this); } ptrsafe_VkPhysicalDeviceMultiviewProperties1662 VkPhysicalDeviceMultiviewProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMultiviewProperties const *>(this); } 1663 }; 1664 1665 struct safe_VkPhysicalDeviceVariablePointersFeatures { 1666 VkStructureType sType; 1667 void* pNext; 1668 VkBool32 variablePointersStorageBuffer; 1669 VkBool32 variablePointers; 1670 safe_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures* in_struct); 1671 safe_VkPhysicalDeviceVariablePointersFeatures(const safe_VkPhysicalDeviceVariablePointersFeatures& copy_src); 1672 safe_VkPhysicalDeviceVariablePointersFeatures& operator=(const safe_VkPhysicalDeviceVariablePointersFeatures& copy_src); 1673 safe_VkPhysicalDeviceVariablePointersFeatures(); 1674 ~safe_VkPhysicalDeviceVariablePointersFeatures(); 1675 void initialize(const VkPhysicalDeviceVariablePointersFeatures* in_struct); 1676 void initialize(const safe_VkPhysicalDeviceVariablePointersFeatures* copy_src); ptrsafe_VkPhysicalDeviceVariablePointersFeatures1677 VkPhysicalDeviceVariablePointersFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures *>(this); } ptrsafe_VkPhysicalDeviceVariablePointersFeatures1678 VkPhysicalDeviceVariablePointersFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures const *>(this); } 1679 }; 1680 1681 struct safe_VkPhysicalDeviceProtectedMemoryFeatures { 1682 VkStructureType sType; 1683 void* pNext; 1684 VkBool32 protectedMemory; 1685 safe_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct); 1686 safe_VkPhysicalDeviceProtectedMemoryFeatures(const safe_VkPhysicalDeviceProtectedMemoryFeatures& copy_src); 1687 safe_VkPhysicalDeviceProtectedMemoryFeatures& operator=(const safe_VkPhysicalDeviceProtectedMemoryFeatures& copy_src); 1688 safe_VkPhysicalDeviceProtectedMemoryFeatures(); 1689 ~safe_VkPhysicalDeviceProtectedMemoryFeatures(); 1690 void initialize(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct); 1691 void initialize(const safe_VkPhysicalDeviceProtectedMemoryFeatures* copy_src); ptrsafe_VkPhysicalDeviceProtectedMemoryFeatures1692 VkPhysicalDeviceProtectedMemoryFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures *>(this); } ptrsafe_VkPhysicalDeviceProtectedMemoryFeatures1693 VkPhysicalDeviceProtectedMemoryFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures const *>(this); } 1694 }; 1695 1696 struct safe_VkPhysicalDeviceProtectedMemoryProperties { 1697 VkStructureType sType; 1698 void* pNext; 1699 VkBool32 protectedNoFault; 1700 safe_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties* in_struct); 1701 safe_VkPhysicalDeviceProtectedMemoryProperties(const safe_VkPhysicalDeviceProtectedMemoryProperties& copy_src); 1702 safe_VkPhysicalDeviceProtectedMemoryProperties& operator=(const safe_VkPhysicalDeviceProtectedMemoryProperties& copy_src); 1703 safe_VkPhysicalDeviceProtectedMemoryProperties(); 1704 ~safe_VkPhysicalDeviceProtectedMemoryProperties(); 1705 void initialize(const VkPhysicalDeviceProtectedMemoryProperties* in_struct); 1706 void initialize(const safe_VkPhysicalDeviceProtectedMemoryProperties* copy_src); ptrsafe_VkPhysicalDeviceProtectedMemoryProperties1707 VkPhysicalDeviceProtectedMemoryProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties *>(this); } ptrsafe_VkPhysicalDeviceProtectedMemoryProperties1708 VkPhysicalDeviceProtectedMemoryProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties const *>(this); } 1709 }; 1710 1711 struct safe_VkDeviceQueueInfo2 { 1712 VkStructureType sType; 1713 const void* pNext; 1714 VkDeviceQueueCreateFlags flags; 1715 uint32_t queueFamilyIndex; 1716 uint32_t queueIndex; 1717 safe_VkDeviceQueueInfo2(const VkDeviceQueueInfo2* in_struct); 1718 safe_VkDeviceQueueInfo2(const safe_VkDeviceQueueInfo2& copy_src); 1719 safe_VkDeviceQueueInfo2& operator=(const safe_VkDeviceQueueInfo2& copy_src); 1720 safe_VkDeviceQueueInfo2(); 1721 ~safe_VkDeviceQueueInfo2(); 1722 void initialize(const VkDeviceQueueInfo2* in_struct); 1723 void initialize(const safe_VkDeviceQueueInfo2* copy_src); ptrsafe_VkDeviceQueueInfo21724 VkDeviceQueueInfo2 *ptr() { return reinterpret_cast<VkDeviceQueueInfo2 *>(this); } ptrsafe_VkDeviceQueueInfo21725 VkDeviceQueueInfo2 const *ptr() const { return reinterpret_cast<VkDeviceQueueInfo2 const *>(this); } 1726 }; 1727 1728 struct safe_VkProtectedSubmitInfo { 1729 VkStructureType sType; 1730 const void* pNext; 1731 VkBool32 protectedSubmit; 1732 safe_VkProtectedSubmitInfo(const VkProtectedSubmitInfo* in_struct); 1733 safe_VkProtectedSubmitInfo(const safe_VkProtectedSubmitInfo& copy_src); 1734 safe_VkProtectedSubmitInfo& operator=(const safe_VkProtectedSubmitInfo& copy_src); 1735 safe_VkProtectedSubmitInfo(); 1736 ~safe_VkProtectedSubmitInfo(); 1737 void initialize(const VkProtectedSubmitInfo* in_struct); 1738 void initialize(const safe_VkProtectedSubmitInfo* copy_src); ptrsafe_VkProtectedSubmitInfo1739 VkProtectedSubmitInfo *ptr() { return reinterpret_cast<VkProtectedSubmitInfo *>(this); } ptrsafe_VkProtectedSubmitInfo1740 VkProtectedSubmitInfo const *ptr() const { return reinterpret_cast<VkProtectedSubmitInfo const *>(this); } 1741 }; 1742 1743 struct safe_VkSamplerYcbcrConversionCreateInfo { 1744 VkStructureType sType; 1745 const void* pNext; 1746 VkFormat format; 1747 VkSamplerYcbcrModelConversion ycbcrModel; 1748 VkSamplerYcbcrRange ycbcrRange; 1749 VkComponentMapping components; 1750 VkChromaLocation xChromaOffset; 1751 VkChromaLocation yChromaOffset; 1752 VkFilter chromaFilter; 1753 VkBool32 forceExplicitReconstruction; 1754 safe_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo* in_struct); 1755 safe_VkSamplerYcbcrConversionCreateInfo(const safe_VkSamplerYcbcrConversionCreateInfo& copy_src); 1756 safe_VkSamplerYcbcrConversionCreateInfo& operator=(const safe_VkSamplerYcbcrConversionCreateInfo& copy_src); 1757 safe_VkSamplerYcbcrConversionCreateInfo(); 1758 ~safe_VkSamplerYcbcrConversionCreateInfo(); 1759 void initialize(const VkSamplerYcbcrConversionCreateInfo* in_struct); 1760 void initialize(const safe_VkSamplerYcbcrConversionCreateInfo* copy_src); ptrsafe_VkSamplerYcbcrConversionCreateInfo1761 VkSamplerYcbcrConversionCreateInfo *ptr() { return reinterpret_cast<VkSamplerYcbcrConversionCreateInfo *>(this); } ptrsafe_VkSamplerYcbcrConversionCreateInfo1762 VkSamplerYcbcrConversionCreateInfo const *ptr() const { return reinterpret_cast<VkSamplerYcbcrConversionCreateInfo const *>(this); } 1763 }; 1764 1765 struct safe_VkSamplerYcbcrConversionInfo { 1766 VkStructureType sType; 1767 const void* pNext; 1768 VkSamplerYcbcrConversion conversion; 1769 safe_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo* in_struct); 1770 safe_VkSamplerYcbcrConversionInfo(const safe_VkSamplerYcbcrConversionInfo& copy_src); 1771 safe_VkSamplerYcbcrConversionInfo& operator=(const safe_VkSamplerYcbcrConversionInfo& copy_src); 1772 safe_VkSamplerYcbcrConversionInfo(); 1773 ~safe_VkSamplerYcbcrConversionInfo(); 1774 void initialize(const VkSamplerYcbcrConversionInfo* in_struct); 1775 void initialize(const safe_VkSamplerYcbcrConversionInfo* copy_src); ptrsafe_VkSamplerYcbcrConversionInfo1776 VkSamplerYcbcrConversionInfo *ptr() { return reinterpret_cast<VkSamplerYcbcrConversionInfo *>(this); } ptrsafe_VkSamplerYcbcrConversionInfo1777 VkSamplerYcbcrConversionInfo const *ptr() const { return reinterpret_cast<VkSamplerYcbcrConversionInfo const *>(this); } 1778 }; 1779 1780 struct safe_VkBindImagePlaneMemoryInfo { 1781 VkStructureType sType; 1782 const void* pNext; 1783 VkImageAspectFlagBits planeAspect; 1784 safe_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo* in_struct); 1785 safe_VkBindImagePlaneMemoryInfo(const safe_VkBindImagePlaneMemoryInfo& copy_src); 1786 safe_VkBindImagePlaneMemoryInfo& operator=(const safe_VkBindImagePlaneMemoryInfo& copy_src); 1787 safe_VkBindImagePlaneMemoryInfo(); 1788 ~safe_VkBindImagePlaneMemoryInfo(); 1789 void initialize(const VkBindImagePlaneMemoryInfo* in_struct); 1790 void initialize(const safe_VkBindImagePlaneMemoryInfo* copy_src); ptrsafe_VkBindImagePlaneMemoryInfo1791 VkBindImagePlaneMemoryInfo *ptr() { return reinterpret_cast<VkBindImagePlaneMemoryInfo *>(this); } ptrsafe_VkBindImagePlaneMemoryInfo1792 VkBindImagePlaneMemoryInfo const *ptr() const { return reinterpret_cast<VkBindImagePlaneMemoryInfo const *>(this); } 1793 }; 1794 1795 struct safe_VkImagePlaneMemoryRequirementsInfo { 1796 VkStructureType sType; 1797 const void* pNext; 1798 VkImageAspectFlagBits planeAspect; 1799 safe_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo* in_struct); 1800 safe_VkImagePlaneMemoryRequirementsInfo(const safe_VkImagePlaneMemoryRequirementsInfo& copy_src); 1801 safe_VkImagePlaneMemoryRequirementsInfo& operator=(const safe_VkImagePlaneMemoryRequirementsInfo& copy_src); 1802 safe_VkImagePlaneMemoryRequirementsInfo(); 1803 ~safe_VkImagePlaneMemoryRequirementsInfo(); 1804 void initialize(const VkImagePlaneMemoryRequirementsInfo* in_struct); 1805 void initialize(const safe_VkImagePlaneMemoryRequirementsInfo* copy_src); ptrsafe_VkImagePlaneMemoryRequirementsInfo1806 VkImagePlaneMemoryRequirementsInfo *ptr() { return reinterpret_cast<VkImagePlaneMemoryRequirementsInfo *>(this); } ptrsafe_VkImagePlaneMemoryRequirementsInfo1807 VkImagePlaneMemoryRequirementsInfo const *ptr() const { return reinterpret_cast<VkImagePlaneMemoryRequirementsInfo const *>(this); } 1808 }; 1809 1810 struct safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures { 1811 VkStructureType sType; 1812 void* pNext; 1813 VkBool32 samplerYcbcrConversion; 1814 safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct); 1815 safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& copy_src); 1816 safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& operator=(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& copy_src); 1817 safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(); 1818 ~safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(); 1819 void initialize(const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct); 1820 void initialize(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures* copy_src); ptrsafe_VkPhysicalDeviceSamplerYcbcrConversionFeatures1821 VkPhysicalDeviceSamplerYcbcrConversionFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(this); } ptrsafe_VkPhysicalDeviceSamplerYcbcrConversionFeatures1822 VkPhysicalDeviceSamplerYcbcrConversionFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures const *>(this); } 1823 }; 1824 1825 struct safe_VkSamplerYcbcrConversionImageFormatProperties { 1826 VkStructureType sType; 1827 void* pNext; 1828 uint32_t combinedImageSamplerDescriptorCount; 1829 safe_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties* in_struct); 1830 safe_VkSamplerYcbcrConversionImageFormatProperties(const safe_VkSamplerYcbcrConversionImageFormatProperties& copy_src); 1831 safe_VkSamplerYcbcrConversionImageFormatProperties& operator=(const safe_VkSamplerYcbcrConversionImageFormatProperties& copy_src); 1832 safe_VkSamplerYcbcrConversionImageFormatProperties(); 1833 ~safe_VkSamplerYcbcrConversionImageFormatProperties(); 1834 void initialize(const VkSamplerYcbcrConversionImageFormatProperties* in_struct); 1835 void initialize(const safe_VkSamplerYcbcrConversionImageFormatProperties* copy_src); ptrsafe_VkSamplerYcbcrConversionImageFormatProperties1836 VkSamplerYcbcrConversionImageFormatProperties *ptr() { return reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties *>(this); } ptrsafe_VkSamplerYcbcrConversionImageFormatProperties1837 VkSamplerYcbcrConversionImageFormatProperties const *ptr() const { return reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties const *>(this); } 1838 }; 1839 1840 struct safe_VkDescriptorUpdateTemplateCreateInfo { 1841 VkStructureType sType; 1842 const void* pNext; 1843 VkDescriptorUpdateTemplateCreateFlags flags; 1844 uint32_t descriptorUpdateEntryCount; 1845 const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; 1846 VkDescriptorUpdateTemplateType templateType; 1847 VkDescriptorSetLayout descriptorSetLayout; 1848 VkPipelineBindPoint pipelineBindPoint; 1849 VkPipelineLayout pipelineLayout; 1850 uint32_t set; 1851 safe_VkDescriptorUpdateTemplateCreateInfo(const VkDescriptorUpdateTemplateCreateInfo* in_struct); 1852 safe_VkDescriptorUpdateTemplateCreateInfo(const safe_VkDescriptorUpdateTemplateCreateInfo& copy_src); 1853 safe_VkDescriptorUpdateTemplateCreateInfo& operator=(const safe_VkDescriptorUpdateTemplateCreateInfo& copy_src); 1854 safe_VkDescriptorUpdateTemplateCreateInfo(); 1855 ~safe_VkDescriptorUpdateTemplateCreateInfo(); 1856 void initialize(const VkDescriptorUpdateTemplateCreateInfo* in_struct); 1857 void initialize(const safe_VkDescriptorUpdateTemplateCreateInfo* copy_src); ptrsafe_VkDescriptorUpdateTemplateCreateInfo1858 VkDescriptorUpdateTemplateCreateInfo *ptr() { return reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo *>(this); } ptrsafe_VkDescriptorUpdateTemplateCreateInfo1859 VkDescriptorUpdateTemplateCreateInfo const *ptr() const { return reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo const *>(this); } 1860 }; 1861 1862 struct safe_VkPhysicalDeviceExternalImageFormatInfo { 1863 VkStructureType sType; 1864 const void* pNext; 1865 VkExternalMemoryHandleTypeFlagBits handleType; 1866 safe_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo* in_struct); 1867 safe_VkPhysicalDeviceExternalImageFormatInfo(const safe_VkPhysicalDeviceExternalImageFormatInfo& copy_src); 1868 safe_VkPhysicalDeviceExternalImageFormatInfo& operator=(const safe_VkPhysicalDeviceExternalImageFormatInfo& copy_src); 1869 safe_VkPhysicalDeviceExternalImageFormatInfo(); 1870 ~safe_VkPhysicalDeviceExternalImageFormatInfo(); 1871 void initialize(const VkPhysicalDeviceExternalImageFormatInfo* in_struct); 1872 void initialize(const safe_VkPhysicalDeviceExternalImageFormatInfo* copy_src); ptrsafe_VkPhysicalDeviceExternalImageFormatInfo1873 VkPhysicalDeviceExternalImageFormatInfo *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo *>(this); } ptrsafe_VkPhysicalDeviceExternalImageFormatInfo1874 VkPhysicalDeviceExternalImageFormatInfo const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo const *>(this); } 1875 }; 1876 1877 struct safe_VkExternalImageFormatProperties { 1878 VkStructureType sType; 1879 void* pNext; 1880 VkExternalMemoryProperties externalMemoryProperties; 1881 safe_VkExternalImageFormatProperties(const VkExternalImageFormatProperties* in_struct); 1882 safe_VkExternalImageFormatProperties(const safe_VkExternalImageFormatProperties& copy_src); 1883 safe_VkExternalImageFormatProperties& operator=(const safe_VkExternalImageFormatProperties& copy_src); 1884 safe_VkExternalImageFormatProperties(); 1885 ~safe_VkExternalImageFormatProperties(); 1886 void initialize(const VkExternalImageFormatProperties* in_struct); 1887 void initialize(const safe_VkExternalImageFormatProperties* copy_src); ptrsafe_VkExternalImageFormatProperties1888 VkExternalImageFormatProperties *ptr() { return reinterpret_cast<VkExternalImageFormatProperties *>(this); } ptrsafe_VkExternalImageFormatProperties1889 VkExternalImageFormatProperties const *ptr() const { return reinterpret_cast<VkExternalImageFormatProperties const *>(this); } 1890 }; 1891 1892 struct safe_VkPhysicalDeviceExternalBufferInfo { 1893 VkStructureType sType; 1894 const void* pNext; 1895 VkBufferCreateFlags flags; 1896 VkBufferUsageFlags usage; 1897 VkExternalMemoryHandleTypeFlagBits handleType; 1898 safe_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo* in_struct); 1899 safe_VkPhysicalDeviceExternalBufferInfo(const safe_VkPhysicalDeviceExternalBufferInfo& copy_src); 1900 safe_VkPhysicalDeviceExternalBufferInfo& operator=(const safe_VkPhysicalDeviceExternalBufferInfo& copy_src); 1901 safe_VkPhysicalDeviceExternalBufferInfo(); 1902 ~safe_VkPhysicalDeviceExternalBufferInfo(); 1903 void initialize(const VkPhysicalDeviceExternalBufferInfo* in_struct); 1904 void initialize(const safe_VkPhysicalDeviceExternalBufferInfo* copy_src); ptrsafe_VkPhysicalDeviceExternalBufferInfo1905 VkPhysicalDeviceExternalBufferInfo *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalBufferInfo *>(this); } ptrsafe_VkPhysicalDeviceExternalBufferInfo1906 VkPhysicalDeviceExternalBufferInfo const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalBufferInfo const *>(this); } 1907 }; 1908 1909 struct safe_VkExternalBufferProperties { 1910 VkStructureType sType; 1911 void* pNext; 1912 VkExternalMemoryProperties externalMemoryProperties; 1913 safe_VkExternalBufferProperties(const VkExternalBufferProperties* in_struct); 1914 safe_VkExternalBufferProperties(const safe_VkExternalBufferProperties& copy_src); 1915 safe_VkExternalBufferProperties& operator=(const safe_VkExternalBufferProperties& copy_src); 1916 safe_VkExternalBufferProperties(); 1917 ~safe_VkExternalBufferProperties(); 1918 void initialize(const VkExternalBufferProperties* in_struct); 1919 void initialize(const safe_VkExternalBufferProperties* copy_src); ptrsafe_VkExternalBufferProperties1920 VkExternalBufferProperties *ptr() { return reinterpret_cast<VkExternalBufferProperties *>(this); } ptrsafe_VkExternalBufferProperties1921 VkExternalBufferProperties const *ptr() const { return reinterpret_cast<VkExternalBufferProperties const *>(this); } 1922 }; 1923 1924 struct safe_VkPhysicalDeviceIDProperties { 1925 VkStructureType sType; 1926 void* pNext; 1927 uint8_t deviceUUID[VK_UUID_SIZE]; 1928 uint8_t driverUUID[VK_UUID_SIZE]; 1929 uint8_t deviceLUID[VK_LUID_SIZE]; 1930 uint32_t deviceNodeMask; 1931 VkBool32 deviceLUIDValid; 1932 safe_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties* in_struct); 1933 safe_VkPhysicalDeviceIDProperties(const safe_VkPhysicalDeviceIDProperties& copy_src); 1934 safe_VkPhysicalDeviceIDProperties& operator=(const safe_VkPhysicalDeviceIDProperties& copy_src); 1935 safe_VkPhysicalDeviceIDProperties(); 1936 ~safe_VkPhysicalDeviceIDProperties(); 1937 void initialize(const VkPhysicalDeviceIDProperties* in_struct); 1938 void initialize(const safe_VkPhysicalDeviceIDProperties* copy_src); ptrsafe_VkPhysicalDeviceIDProperties1939 VkPhysicalDeviceIDProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceIDProperties *>(this); } ptrsafe_VkPhysicalDeviceIDProperties1940 VkPhysicalDeviceIDProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceIDProperties const *>(this); } 1941 }; 1942 1943 struct safe_VkExternalMemoryImageCreateInfo { 1944 VkStructureType sType; 1945 const void* pNext; 1946 VkExternalMemoryHandleTypeFlags handleTypes; 1947 safe_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo* in_struct); 1948 safe_VkExternalMemoryImageCreateInfo(const safe_VkExternalMemoryImageCreateInfo& copy_src); 1949 safe_VkExternalMemoryImageCreateInfo& operator=(const safe_VkExternalMemoryImageCreateInfo& copy_src); 1950 safe_VkExternalMemoryImageCreateInfo(); 1951 ~safe_VkExternalMemoryImageCreateInfo(); 1952 void initialize(const VkExternalMemoryImageCreateInfo* in_struct); 1953 void initialize(const safe_VkExternalMemoryImageCreateInfo* copy_src); ptrsafe_VkExternalMemoryImageCreateInfo1954 VkExternalMemoryImageCreateInfo *ptr() { return reinterpret_cast<VkExternalMemoryImageCreateInfo *>(this); } ptrsafe_VkExternalMemoryImageCreateInfo1955 VkExternalMemoryImageCreateInfo const *ptr() const { return reinterpret_cast<VkExternalMemoryImageCreateInfo const *>(this); } 1956 }; 1957 1958 struct safe_VkExternalMemoryBufferCreateInfo { 1959 VkStructureType sType; 1960 const void* pNext; 1961 VkExternalMemoryHandleTypeFlags handleTypes; 1962 safe_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo* in_struct); 1963 safe_VkExternalMemoryBufferCreateInfo(const safe_VkExternalMemoryBufferCreateInfo& copy_src); 1964 safe_VkExternalMemoryBufferCreateInfo& operator=(const safe_VkExternalMemoryBufferCreateInfo& copy_src); 1965 safe_VkExternalMemoryBufferCreateInfo(); 1966 ~safe_VkExternalMemoryBufferCreateInfo(); 1967 void initialize(const VkExternalMemoryBufferCreateInfo* in_struct); 1968 void initialize(const safe_VkExternalMemoryBufferCreateInfo* copy_src); ptrsafe_VkExternalMemoryBufferCreateInfo1969 VkExternalMemoryBufferCreateInfo *ptr() { return reinterpret_cast<VkExternalMemoryBufferCreateInfo *>(this); } ptrsafe_VkExternalMemoryBufferCreateInfo1970 VkExternalMemoryBufferCreateInfo const *ptr() const { return reinterpret_cast<VkExternalMemoryBufferCreateInfo const *>(this); } 1971 }; 1972 1973 struct safe_VkExportMemoryAllocateInfo { 1974 VkStructureType sType; 1975 const void* pNext; 1976 VkExternalMemoryHandleTypeFlags handleTypes; 1977 safe_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo* in_struct); 1978 safe_VkExportMemoryAllocateInfo(const safe_VkExportMemoryAllocateInfo& copy_src); 1979 safe_VkExportMemoryAllocateInfo& operator=(const safe_VkExportMemoryAllocateInfo& copy_src); 1980 safe_VkExportMemoryAllocateInfo(); 1981 ~safe_VkExportMemoryAllocateInfo(); 1982 void initialize(const VkExportMemoryAllocateInfo* in_struct); 1983 void initialize(const safe_VkExportMemoryAllocateInfo* copy_src); ptrsafe_VkExportMemoryAllocateInfo1984 VkExportMemoryAllocateInfo *ptr() { return reinterpret_cast<VkExportMemoryAllocateInfo *>(this); } ptrsafe_VkExportMemoryAllocateInfo1985 VkExportMemoryAllocateInfo const *ptr() const { return reinterpret_cast<VkExportMemoryAllocateInfo const *>(this); } 1986 }; 1987 1988 struct safe_VkPhysicalDeviceExternalFenceInfo { 1989 VkStructureType sType; 1990 const void* pNext; 1991 VkExternalFenceHandleTypeFlagBits handleType; 1992 safe_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo* in_struct); 1993 safe_VkPhysicalDeviceExternalFenceInfo(const safe_VkPhysicalDeviceExternalFenceInfo& copy_src); 1994 safe_VkPhysicalDeviceExternalFenceInfo& operator=(const safe_VkPhysicalDeviceExternalFenceInfo& copy_src); 1995 safe_VkPhysicalDeviceExternalFenceInfo(); 1996 ~safe_VkPhysicalDeviceExternalFenceInfo(); 1997 void initialize(const VkPhysicalDeviceExternalFenceInfo* in_struct); 1998 void initialize(const safe_VkPhysicalDeviceExternalFenceInfo* copy_src); ptrsafe_VkPhysicalDeviceExternalFenceInfo1999 VkPhysicalDeviceExternalFenceInfo *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalFenceInfo *>(this); } ptrsafe_VkPhysicalDeviceExternalFenceInfo2000 VkPhysicalDeviceExternalFenceInfo const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalFenceInfo const *>(this); } 2001 }; 2002 2003 struct safe_VkExternalFenceProperties { 2004 VkStructureType sType; 2005 void* pNext; 2006 VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; 2007 VkExternalFenceHandleTypeFlags compatibleHandleTypes; 2008 VkExternalFenceFeatureFlags externalFenceFeatures; 2009 safe_VkExternalFenceProperties(const VkExternalFenceProperties* in_struct); 2010 safe_VkExternalFenceProperties(const safe_VkExternalFenceProperties& copy_src); 2011 safe_VkExternalFenceProperties& operator=(const safe_VkExternalFenceProperties& copy_src); 2012 safe_VkExternalFenceProperties(); 2013 ~safe_VkExternalFenceProperties(); 2014 void initialize(const VkExternalFenceProperties* in_struct); 2015 void initialize(const safe_VkExternalFenceProperties* copy_src); ptrsafe_VkExternalFenceProperties2016 VkExternalFenceProperties *ptr() { return reinterpret_cast<VkExternalFenceProperties *>(this); } ptrsafe_VkExternalFenceProperties2017 VkExternalFenceProperties const *ptr() const { return reinterpret_cast<VkExternalFenceProperties const *>(this); } 2018 }; 2019 2020 struct safe_VkExportFenceCreateInfo { 2021 VkStructureType sType; 2022 const void* pNext; 2023 VkExternalFenceHandleTypeFlags handleTypes; 2024 safe_VkExportFenceCreateInfo(const VkExportFenceCreateInfo* in_struct); 2025 safe_VkExportFenceCreateInfo(const safe_VkExportFenceCreateInfo& copy_src); 2026 safe_VkExportFenceCreateInfo& operator=(const safe_VkExportFenceCreateInfo& copy_src); 2027 safe_VkExportFenceCreateInfo(); 2028 ~safe_VkExportFenceCreateInfo(); 2029 void initialize(const VkExportFenceCreateInfo* in_struct); 2030 void initialize(const safe_VkExportFenceCreateInfo* copy_src); ptrsafe_VkExportFenceCreateInfo2031 VkExportFenceCreateInfo *ptr() { return reinterpret_cast<VkExportFenceCreateInfo *>(this); } ptrsafe_VkExportFenceCreateInfo2032 VkExportFenceCreateInfo const *ptr() const { return reinterpret_cast<VkExportFenceCreateInfo const *>(this); } 2033 }; 2034 2035 struct safe_VkExportSemaphoreCreateInfo { 2036 VkStructureType sType; 2037 const void* pNext; 2038 VkExternalSemaphoreHandleTypeFlags handleTypes; 2039 safe_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo* in_struct); 2040 safe_VkExportSemaphoreCreateInfo(const safe_VkExportSemaphoreCreateInfo& copy_src); 2041 safe_VkExportSemaphoreCreateInfo& operator=(const safe_VkExportSemaphoreCreateInfo& copy_src); 2042 safe_VkExportSemaphoreCreateInfo(); 2043 ~safe_VkExportSemaphoreCreateInfo(); 2044 void initialize(const VkExportSemaphoreCreateInfo* in_struct); 2045 void initialize(const safe_VkExportSemaphoreCreateInfo* copy_src); ptrsafe_VkExportSemaphoreCreateInfo2046 VkExportSemaphoreCreateInfo *ptr() { return reinterpret_cast<VkExportSemaphoreCreateInfo *>(this); } ptrsafe_VkExportSemaphoreCreateInfo2047 VkExportSemaphoreCreateInfo const *ptr() const { return reinterpret_cast<VkExportSemaphoreCreateInfo const *>(this); } 2048 }; 2049 2050 struct safe_VkPhysicalDeviceExternalSemaphoreInfo { 2051 VkStructureType sType; 2052 const void* pNext; 2053 VkExternalSemaphoreHandleTypeFlagBits handleType; 2054 safe_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct); 2055 safe_VkPhysicalDeviceExternalSemaphoreInfo(const safe_VkPhysicalDeviceExternalSemaphoreInfo& copy_src); 2056 safe_VkPhysicalDeviceExternalSemaphoreInfo& operator=(const safe_VkPhysicalDeviceExternalSemaphoreInfo& copy_src); 2057 safe_VkPhysicalDeviceExternalSemaphoreInfo(); 2058 ~safe_VkPhysicalDeviceExternalSemaphoreInfo(); 2059 void initialize(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct); 2060 void initialize(const safe_VkPhysicalDeviceExternalSemaphoreInfo* copy_src); ptrsafe_VkPhysicalDeviceExternalSemaphoreInfo2061 VkPhysicalDeviceExternalSemaphoreInfo *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo *>(this); } ptrsafe_VkPhysicalDeviceExternalSemaphoreInfo2062 VkPhysicalDeviceExternalSemaphoreInfo const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo const *>(this); } 2063 }; 2064 2065 struct safe_VkExternalSemaphoreProperties { 2066 VkStructureType sType; 2067 void* pNext; 2068 VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; 2069 VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; 2070 VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; 2071 safe_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties* in_struct); 2072 safe_VkExternalSemaphoreProperties(const safe_VkExternalSemaphoreProperties& copy_src); 2073 safe_VkExternalSemaphoreProperties& operator=(const safe_VkExternalSemaphoreProperties& copy_src); 2074 safe_VkExternalSemaphoreProperties(); 2075 ~safe_VkExternalSemaphoreProperties(); 2076 void initialize(const VkExternalSemaphoreProperties* in_struct); 2077 void initialize(const safe_VkExternalSemaphoreProperties* copy_src); ptrsafe_VkExternalSemaphoreProperties2078 VkExternalSemaphoreProperties *ptr() { return reinterpret_cast<VkExternalSemaphoreProperties *>(this); } ptrsafe_VkExternalSemaphoreProperties2079 VkExternalSemaphoreProperties const *ptr() const { return reinterpret_cast<VkExternalSemaphoreProperties const *>(this); } 2080 }; 2081 2082 struct safe_VkPhysicalDeviceMaintenance3Properties { 2083 VkStructureType sType; 2084 void* pNext; 2085 uint32_t maxPerSetDescriptors; 2086 VkDeviceSize maxMemoryAllocationSize; 2087 safe_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties* in_struct); 2088 safe_VkPhysicalDeviceMaintenance3Properties(const safe_VkPhysicalDeviceMaintenance3Properties& copy_src); 2089 safe_VkPhysicalDeviceMaintenance3Properties& operator=(const safe_VkPhysicalDeviceMaintenance3Properties& copy_src); 2090 safe_VkPhysicalDeviceMaintenance3Properties(); 2091 ~safe_VkPhysicalDeviceMaintenance3Properties(); 2092 void initialize(const VkPhysicalDeviceMaintenance3Properties* in_struct); 2093 void initialize(const safe_VkPhysicalDeviceMaintenance3Properties* copy_src); ptrsafe_VkPhysicalDeviceMaintenance3Properties2094 VkPhysicalDeviceMaintenance3Properties *ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance3Properties *>(this); } ptrsafe_VkPhysicalDeviceMaintenance3Properties2095 VkPhysicalDeviceMaintenance3Properties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMaintenance3Properties const *>(this); } 2096 }; 2097 2098 struct safe_VkDescriptorSetLayoutSupport { 2099 VkStructureType sType; 2100 void* pNext; 2101 VkBool32 supported; 2102 safe_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport* in_struct); 2103 safe_VkDescriptorSetLayoutSupport(const safe_VkDescriptorSetLayoutSupport& copy_src); 2104 safe_VkDescriptorSetLayoutSupport& operator=(const safe_VkDescriptorSetLayoutSupport& copy_src); 2105 safe_VkDescriptorSetLayoutSupport(); 2106 ~safe_VkDescriptorSetLayoutSupport(); 2107 void initialize(const VkDescriptorSetLayoutSupport* in_struct); 2108 void initialize(const safe_VkDescriptorSetLayoutSupport* copy_src); ptrsafe_VkDescriptorSetLayoutSupport2109 VkDescriptorSetLayoutSupport *ptr() { return reinterpret_cast<VkDescriptorSetLayoutSupport *>(this); } ptrsafe_VkDescriptorSetLayoutSupport2110 VkDescriptorSetLayoutSupport const *ptr() const { return reinterpret_cast<VkDescriptorSetLayoutSupport const *>(this); } 2111 }; 2112 2113 struct safe_VkPhysicalDeviceShaderDrawParametersFeatures { 2114 VkStructureType sType; 2115 void* pNext; 2116 VkBool32 shaderDrawParameters; 2117 safe_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct); 2118 safe_VkPhysicalDeviceShaderDrawParametersFeatures(const safe_VkPhysicalDeviceShaderDrawParametersFeatures& copy_src); 2119 safe_VkPhysicalDeviceShaderDrawParametersFeatures& operator=(const safe_VkPhysicalDeviceShaderDrawParametersFeatures& copy_src); 2120 safe_VkPhysicalDeviceShaderDrawParametersFeatures(); 2121 ~safe_VkPhysicalDeviceShaderDrawParametersFeatures(); 2122 void initialize(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct); 2123 void initialize(const safe_VkPhysicalDeviceShaderDrawParametersFeatures* copy_src); ptrsafe_VkPhysicalDeviceShaderDrawParametersFeatures2124 VkPhysicalDeviceShaderDrawParametersFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures *>(this); } ptrsafe_VkPhysicalDeviceShaderDrawParametersFeatures2125 VkPhysicalDeviceShaderDrawParametersFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures const *>(this); } 2126 }; 2127 2128 struct safe_VkPhysicalDeviceVulkan11Features { 2129 VkStructureType sType; 2130 void* pNext; 2131 VkBool32 storageBuffer16BitAccess; 2132 VkBool32 uniformAndStorageBuffer16BitAccess; 2133 VkBool32 storagePushConstant16; 2134 VkBool32 storageInputOutput16; 2135 VkBool32 multiview; 2136 VkBool32 multiviewGeometryShader; 2137 VkBool32 multiviewTessellationShader; 2138 VkBool32 variablePointersStorageBuffer; 2139 VkBool32 variablePointers; 2140 VkBool32 protectedMemory; 2141 VkBool32 samplerYcbcrConversion; 2142 VkBool32 shaderDrawParameters; 2143 safe_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features* in_struct); 2144 safe_VkPhysicalDeviceVulkan11Features(const safe_VkPhysicalDeviceVulkan11Features& copy_src); 2145 safe_VkPhysicalDeviceVulkan11Features& operator=(const safe_VkPhysicalDeviceVulkan11Features& copy_src); 2146 safe_VkPhysicalDeviceVulkan11Features(); 2147 ~safe_VkPhysicalDeviceVulkan11Features(); 2148 void initialize(const VkPhysicalDeviceVulkan11Features* in_struct); 2149 void initialize(const safe_VkPhysicalDeviceVulkan11Features* copy_src); ptrsafe_VkPhysicalDeviceVulkan11Features2150 VkPhysicalDeviceVulkan11Features *ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan11Features *>(this); } ptrsafe_VkPhysicalDeviceVulkan11Features2151 VkPhysicalDeviceVulkan11Features const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVulkan11Features const *>(this); } 2152 }; 2153 2154 struct safe_VkPhysicalDeviceVulkan11Properties { 2155 VkStructureType sType; 2156 void* pNext; 2157 uint8_t deviceUUID[VK_UUID_SIZE]; 2158 uint8_t driverUUID[VK_UUID_SIZE]; 2159 uint8_t deviceLUID[VK_LUID_SIZE]; 2160 uint32_t deviceNodeMask; 2161 VkBool32 deviceLUIDValid; 2162 uint32_t subgroupSize; 2163 VkShaderStageFlags subgroupSupportedStages; 2164 VkSubgroupFeatureFlags subgroupSupportedOperations; 2165 VkBool32 subgroupQuadOperationsInAllStages; 2166 VkPointClippingBehavior pointClippingBehavior; 2167 uint32_t maxMultiviewViewCount; 2168 uint32_t maxMultiviewInstanceIndex; 2169 VkBool32 protectedNoFault; 2170 uint32_t maxPerSetDescriptors; 2171 VkDeviceSize maxMemoryAllocationSize; 2172 safe_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties* in_struct); 2173 safe_VkPhysicalDeviceVulkan11Properties(const safe_VkPhysicalDeviceVulkan11Properties& copy_src); 2174 safe_VkPhysicalDeviceVulkan11Properties& operator=(const safe_VkPhysicalDeviceVulkan11Properties& copy_src); 2175 safe_VkPhysicalDeviceVulkan11Properties(); 2176 ~safe_VkPhysicalDeviceVulkan11Properties(); 2177 void initialize(const VkPhysicalDeviceVulkan11Properties* in_struct); 2178 void initialize(const safe_VkPhysicalDeviceVulkan11Properties* copy_src); ptrsafe_VkPhysicalDeviceVulkan11Properties2179 VkPhysicalDeviceVulkan11Properties *ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan11Properties *>(this); } ptrsafe_VkPhysicalDeviceVulkan11Properties2180 VkPhysicalDeviceVulkan11Properties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVulkan11Properties const *>(this); } 2181 }; 2182 2183 struct safe_VkPhysicalDeviceVulkan12Features { 2184 VkStructureType sType; 2185 void* pNext; 2186 VkBool32 samplerMirrorClampToEdge; 2187 VkBool32 drawIndirectCount; 2188 VkBool32 storageBuffer8BitAccess; 2189 VkBool32 uniformAndStorageBuffer8BitAccess; 2190 VkBool32 storagePushConstant8; 2191 VkBool32 shaderBufferInt64Atomics; 2192 VkBool32 shaderSharedInt64Atomics; 2193 VkBool32 shaderFloat16; 2194 VkBool32 shaderInt8; 2195 VkBool32 descriptorIndexing; 2196 VkBool32 shaderInputAttachmentArrayDynamicIndexing; 2197 VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; 2198 VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; 2199 VkBool32 shaderUniformBufferArrayNonUniformIndexing; 2200 VkBool32 shaderSampledImageArrayNonUniformIndexing; 2201 VkBool32 shaderStorageBufferArrayNonUniformIndexing; 2202 VkBool32 shaderStorageImageArrayNonUniformIndexing; 2203 VkBool32 shaderInputAttachmentArrayNonUniformIndexing; 2204 VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; 2205 VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; 2206 VkBool32 descriptorBindingUniformBufferUpdateAfterBind; 2207 VkBool32 descriptorBindingSampledImageUpdateAfterBind; 2208 VkBool32 descriptorBindingStorageImageUpdateAfterBind; 2209 VkBool32 descriptorBindingStorageBufferUpdateAfterBind; 2210 VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; 2211 VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; 2212 VkBool32 descriptorBindingUpdateUnusedWhilePending; 2213 VkBool32 descriptorBindingPartiallyBound; 2214 VkBool32 descriptorBindingVariableDescriptorCount; 2215 VkBool32 runtimeDescriptorArray; 2216 VkBool32 samplerFilterMinmax; 2217 VkBool32 scalarBlockLayout; 2218 VkBool32 imagelessFramebuffer; 2219 VkBool32 uniformBufferStandardLayout; 2220 VkBool32 shaderSubgroupExtendedTypes; 2221 VkBool32 separateDepthStencilLayouts; 2222 VkBool32 hostQueryReset; 2223 VkBool32 timelineSemaphore; 2224 VkBool32 bufferDeviceAddress; 2225 VkBool32 bufferDeviceAddressCaptureReplay; 2226 VkBool32 bufferDeviceAddressMultiDevice; 2227 VkBool32 vulkanMemoryModel; 2228 VkBool32 vulkanMemoryModelDeviceScope; 2229 VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; 2230 VkBool32 shaderOutputViewportIndex; 2231 VkBool32 shaderOutputLayer; 2232 VkBool32 subgroupBroadcastDynamicId; 2233 safe_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features* in_struct); 2234 safe_VkPhysicalDeviceVulkan12Features(const safe_VkPhysicalDeviceVulkan12Features& copy_src); 2235 safe_VkPhysicalDeviceVulkan12Features& operator=(const safe_VkPhysicalDeviceVulkan12Features& copy_src); 2236 safe_VkPhysicalDeviceVulkan12Features(); 2237 ~safe_VkPhysicalDeviceVulkan12Features(); 2238 void initialize(const VkPhysicalDeviceVulkan12Features* in_struct); 2239 void initialize(const safe_VkPhysicalDeviceVulkan12Features* copy_src); ptrsafe_VkPhysicalDeviceVulkan12Features2240 VkPhysicalDeviceVulkan12Features *ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan12Features *>(this); } ptrsafe_VkPhysicalDeviceVulkan12Features2241 VkPhysicalDeviceVulkan12Features const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVulkan12Features const *>(this); } 2242 }; 2243 2244 struct safe_VkPhysicalDeviceVulkan12Properties { 2245 VkStructureType sType; 2246 void* pNext; 2247 VkDriverId driverID; 2248 char driverName[VK_MAX_DRIVER_NAME_SIZE]; 2249 char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; 2250 VkConformanceVersion conformanceVersion; 2251 VkShaderFloatControlsIndependence denormBehaviorIndependence; 2252 VkShaderFloatControlsIndependence roundingModeIndependence; 2253 VkBool32 shaderSignedZeroInfNanPreserveFloat16; 2254 VkBool32 shaderSignedZeroInfNanPreserveFloat32; 2255 VkBool32 shaderSignedZeroInfNanPreserveFloat64; 2256 VkBool32 shaderDenormPreserveFloat16; 2257 VkBool32 shaderDenormPreserveFloat32; 2258 VkBool32 shaderDenormPreserveFloat64; 2259 VkBool32 shaderDenormFlushToZeroFloat16; 2260 VkBool32 shaderDenormFlushToZeroFloat32; 2261 VkBool32 shaderDenormFlushToZeroFloat64; 2262 VkBool32 shaderRoundingModeRTEFloat16; 2263 VkBool32 shaderRoundingModeRTEFloat32; 2264 VkBool32 shaderRoundingModeRTEFloat64; 2265 VkBool32 shaderRoundingModeRTZFloat16; 2266 VkBool32 shaderRoundingModeRTZFloat32; 2267 VkBool32 shaderRoundingModeRTZFloat64; 2268 uint32_t maxUpdateAfterBindDescriptorsInAllPools; 2269 VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; 2270 VkBool32 shaderSampledImageArrayNonUniformIndexingNative; 2271 VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; 2272 VkBool32 shaderStorageImageArrayNonUniformIndexingNative; 2273 VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; 2274 VkBool32 robustBufferAccessUpdateAfterBind; 2275 VkBool32 quadDivergentImplicitLod; 2276 uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; 2277 uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; 2278 uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; 2279 uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; 2280 uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; 2281 uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; 2282 uint32_t maxPerStageUpdateAfterBindResources; 2283 uint32_t maxDescriptorSetUpdateAfterBindSamplers; 2284 uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; 2285 uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; 2286 uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; 2287 uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; 2288 uint32_t maxDescriptorSetUpdateAfterBindSampledImages; 2289 uint32_t maxDescriptorSetUpdateAfterBindStorageImages; 2290 uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; 2291 VkResolveModeFlags supportedDepthResolveModes; 2292 VkResolveModeFlags supportedStencilResolveModes; 2293 VkBool32 independentResolveNone; 2294 VkBool32 independentResolve; 2295 VkBool32 filterMinmaxSingleComponentFormats; 2296 VkBool32 filterMinmaxImageComponentMapping; 2297 uint64_t maxTimelineSemaphoreValueDifference; 2298 VkSampleCountFlags framebufferIntegerColorSampleCounts; 2299 safe_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties* in_struct); 2300 safe_VkPhysicalDeviceVulkan12Properties(const safe_VkPhysicalDeviceVulkan12Properties& copy_src); 2301 safe_VkPhysicalDeviceVulkan12Properties& operator=(const safe_VkPhysicalDeviceVulkan12Properties& copy_src); 2302 safe_VkPhysicalDeviceVulkan12Properties(); 2303 ~safe_VkPhysicalDeviceVulkan12Properties(); 2304 void initialize(const VkPhysicalDeviceVulkan12Properties* in_struct); 2305 void initialize(const safe_VkPhysicalDeviceVulkan12Properties* copy_src); ptrsafe_VkPhysicalDeviceVulkan12Properties2306 VkPhysicalDeviceVulkan12Properties *ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan12Properties *>(this); } ptrsafe_VkPhysicalDeviceVulkan12Properties2307 VkPhysicalDeviceVulkan12Properties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVulkan12Properties const *>(this); } 2308 }; 2309 2310 struct safe_VkImageFormatListCreateInfo { 2311 VkStructureType sType; 2312 const void* pNext; 2313 uint32_t viewFormatCount; 2314 const VkFormat* pViewFormats; 2315 safe_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo* in_struct); 2316 safe_VkImageFormatListCreateInfo(const safe_VkImageFormatListCreateInfo& copy_src); 2317 safe_VkImageFormatListCreateInfo& operator=(const safe_VkImageFormatListCreateInfo& copy_src); 2318 safe_VkImageFormatListCreateInfo(); 2319 ~safe_VkImageFormatListCreateInfo(); 2320 void initialize(const VkImageFormatListCreateInfo* in_struct); 2321 void initialize(const safe_VkImageFormatListCreateInfo* copy_src); ptrsafe_VkImageFormatListCreateInfo2322 VkImageFormatListCreateInfo *ptr() { return reinterpret_cast<VkImageFormatListCreateInfo *>(this); } ptrsafe_VkImageFormatListCreateInfo2323 VkImageFormatListCreateInfo const *ptr() const { return reinterpret_cast<VkImageFormatListCreateInfo const *>(this); } 2324 }; 2325 2326 struct safe_VkAttachmentDescription2 { 2327 VkStructureType sType; 2328 const void* pNext; 2329 VkAttachmentDescriptionFlags flags; 2330 VkFormat format; 2331 VkSampleCountFlagBits samples; 2332 VkAttachmentLoadOp loadOp; 2333 VkAttachmentStoreOp storeOp; 2334 VkAttachmentLoadOp stencilLoadOp; 2335 VkAttachmentStoreOp stencilStoreOp; 2336 VkImageLayout initialLayout; 2337 VkImageLayout finalLayout; 2338 safe_VkAttachmentDescription2(const VkAttachmentDescription2* in_struct); 2339 safe_VkAttachmentDescription2(const safe_VkAttachmentDescription2& copy_src); 2340 safe_VkAttachmentDescription2& operator=(const safe_VkAttachmentDescription2& copy_src); 2341 safe_VkAttachmentDescription2(); 2342 ~safe_VkAttachmentDescription2(); 2343 void initialize(const VkAttachmentDescription2* in_struct); 2344 void initialize(const safe_VkAttachmentDescription2* copy_src); ptrsafe_VkAttachmentDescription22345 VkAttachmentDescription2 *ptr() { return reinterpret_cast<VkAttachmentDescription2 *>(this); } ptrsafe_VkAttachmentDescription22346 VkAttachmentDescription2 const *ptr() const { return reinterpret_cast<VkAttachmentDescription2 const *>(this); } 2347 }; 2348 2349 struct safe_VkAttachmentReference2 { 2350 VkStructureType sType; 2351 const void* pNext; 2352 uint32_t attachment; 2353 VkImageLayout layout; 2354 VkImageAspectFlags aspectMask; 2355 safe_VkAttachmentReference2(const VkAttachmentReference2* in_struct); 2356 safe_VkAttachmentReference2(const safe_VkAttachmentReference2& copy_src); 2357 safe_VkAttachmentReference2& operator=(const safe_VkAttachmentReference2& copy_src); 2358 safe_VkAttachmentReference2(); 2359 ~safe_VkAttachmentReference2(); 2360 void initialize(const VkAttachmentReference2* in_struct); 2361 void initialize(const safe_VkAttachmentReference2* copy_src); ptrsafe_VkAttachmentReference22362 VkAttachmentReference2 *ptr() { return reinterpret_cast<VkAttachmentReference2 *>(this); } ptrsafe_VkAttachmentReference22363 VkAttachmentReference2 const *ptr() const { return reinterpret_cast<VkAttachmentReference2 const *>(this); } 2364 }; 2365 2366 struct safe_VkSubpassDescription2 { 2367 VkStructureType sType; 2368 const void* pNext; 2369 VkSubpassDescriptionFlags flags; 2370 VkPipelineBindPoint pipelineBindPoint; 2371 uint32_t viewMask; 2372 uint32_t inputAttachmentCount; 2373 safe_VkAttachmentReference2* pInputAttachments; 2374 uint32_t colorAttachmentCount; 2375 safe_VkAttachmentReference2* pColorAttachments; 2376 safe_VkAttachmentReference2* pResolveAttachments; 2377 safe_VkAttachmentReference2* pDepthStencilAttachment; 2378 uint32_t preserveAttachmentCount; 2379 const uint32_t* pPreserveAttachments; 2380 safe_VkSubpassDescription2(const VkSubpassDescription2* in_struct); 2381 safe_VkSubpassDescription2(const safe_VkSubpassDescription2& copy_src); 2382 safe_VkSubpassDescription2& operator=(const safe_VkSubpassDescription2& copy_src); 2383 safe_VkSubpassDescription2(); 2384 ~safe_VkSubpassDescription2(); 2385 void initialize(const VkSubpassDescription2* in_struct); 2386 void initialize(const safe_VkSubpassDescription2* copy_src); ptrsafe_VkSubpassDescription22387 VkSubpassDescription2 *ptr() { return reinterpret_cast<VkSubpassDescription2 *>(this); } ptrsafe_VkSubpassDescription22388 VkSubpassDescription2 const *ptr() const { return reinterpret_cast<VkSubpassDescription2 const *>(this); } 2389 }; 2390 2391 struct safe_VkSubpassDependency2 { 2392 VkStructureType sType; 2393 const void* pNext; 2394 uint32_t srcSubpass; 2395 uint32_t dstSubpass; 2396 VkPipelineStageFlags srcStageMask; 2397 VkPipelineStageFlags dstStageMask; 2398 VkAccessFlags srcAccessMask; 2399 VkAccessFlags dstAccessMask; 2400 VkDependencyFlags dependencyFlags; 2401 int32_t viewOffset; 2402 safe_VkSubpassDependency2(const VkSubpassDependency2* in_struct); 2403 safe_VkSubpassDependency2(const safe_VkSubpassDependency2& copy_src); 2404 safe_VkSubpassDependency2& operator=(const safe_VkSubpassDependency2& copy_src); 2405 safe_VkSubpassDependency2(); 2406 ~safe_VkSubpassDependency2(); 2407 void initialize(const VkSubpassDependency2* in_struct); 2408 void initialize(const safe_VkSubpassDependency2* copy_src); ptrsafe_VkSubpassDependency22409 VkSubpassDependency2 *ptr() { return reinterpret_cast<VkSubpassDependency2 *>(this); } ptrsafe_VkSubpassDependency22410 VkSubpassDependency2 const *ptr() const { return reinterpret_cast<VkSubpassDependency2 const *>(this); } 2411 }; 2412 2413 struct safe_VkRenderPassCreateInfo2 { 2414 VkStructureType sType; 2415 const void* pNext; 2416 VkRenderPassCreateFlags flags; 2417 uint32_t attachmentCount; 2418 safe_VkAttachmentDescription2* pAttachments; 2419 uint32_t subpassCount; 2420 safe_VkSubpassDescription2* pSubpasses; 2421 uint32_t dependencyCount; 2422 safe_VkSubpassDependency2* pDependencies; 2423 uint32_t correlatedViewMaskCount; 2424 const uint32_t* pCorrelatedViewMasks; 2425 safe_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2* in_struct); 2426 safe_VkRenderPassCreateInfo2(const safe_VkRenderPassCreateInfo2& copy_src); 2427 safe_VkRenderPassCreateInfo2& operator=(const safe_VkRenderPassCreateInfo2& copy_src); 2428 safe_VkRenderPassCreateInfo2(); 2429 ~safe_VkRenderPassCreateInfo2(); 2430 void initialize(const VkRenderPassCreateInfo2* in_struct); 2431 void initialize(const safe_VkRenderPassCreateInfo2* copy_src); ptrsafe_VkRenderPassCreateInfo22432 VkRenderPassCreateInfo2 *ptr() { return reinterpret_cast<VkRenderPassCreateInfo2 *>(this); } ptrsafe_VkRenderPassCreateInfo22433 VkRenderPassCreateInfo2 const *ptr() const { return reinterpret_cast<VkRenderPassCreateInfo2 const *>(this); } 2434 }; 2435 2436 struct safe_VkSubpassBeginInfo { 2437 VkStructureType sType; 2438 const void* pNext; 2439 VkSubpassContents contents; 2440 safe_VkSubpassBeginInfo(const VkSubpassBeginInfo* in_struct); 2441 safe_VkSubpassBeginInfo(const safe_VkSubpassBeginInfo& copy_src); 2442 safe_VkSubpassBeginInfo& operator=(const safe_VkSubpassBeginInfo& copy_src); 2443 safe_VkSubpassBeginInfo(); 2444 ~safe_VkSubpassBeginInfo(); 2445 void initialize(const VkSubpassBeginInfo* in_struct); 2446 void initialize(const safe_VkSubpassBeginInfo* copy_src); ptrsafe_VkSubpassBeginInfo2447 VkSubpassBeginInfo *ptr() { return reinterpret_cast<VkSubpassBeginInfo *>(this); } ptrsafe_VkSubpassBeginInfo2448 VkSubpassBeginInfo const *ptr() const { return reinterpret_cast<VkSubpassBeginInfo const *>(this); } 2449 }; 2450 2451 struct safe_VkSubpassEndInfo { 2452 VkStructureType sType; 2453 const void* pNext; 2454 safe_VkSubpassEndInfo(const VkSubpassEndInfo* in_struct); 2455 safe_VkSubpassEndInfo(const safe_VkSubpassEndInfo& copy_src); 2456 safe_VkSubpassEndInfo& operator=(const safe_VkSubpassEndInfo& copy_src); 2457 safe_VkSubpassEndInfo(); 2458 ~safe_VkSubpassEndInfo(); 2459 void initialize(const VkSubpassEndInfo* in_struct); 2460 void initialize(const safe_VkSubpassEndInfo* copy_src); ptrsafe_VkSubpassEndInfo2461 VkSubpassEndInfo *ptr() { return reinterpret_cast<VkSubpassEndInfo *>(this); } ptrsafe_VkSubpassEndInfo2462 VkSubpassEndInfo const *ptr() const { return reinterpret_cast<VkSubpassEndInfo const *>(this); } 2463 }; 2464 2465 struct safe_VkPhysicalDevice8BitStorageFeatures { 2466 VkStructureType sType; 2467 void* pNext; 2468 VkBool32 storageBuffer8BitAccess; 2469 VkBool32 uniformAndStorageBuffer8BitAccess; 2470 VkBool32 storagePushConstant8; 2471 safe_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures* in_struct); 2472 safe_VkPhysicalDevice8BitStorageFeatures(const safe_VkPhysicalDevice8BitStorageFeatures& copy_src); 2473 safe_VkPhysicalDevice8BitStorageFeatures& operator=(const safe_VkPhysicalDevice8BitStorageFeatures& copy_src); 2474 safe_VkPhysicalDevice8BitStorageFeatures(); 2475 ~safe_VkPhysicalDevice8BitStorageFeatures(); 2476 void initialize(const VkPhysicalDevice8BitStorageFeatures* in_struct); 2477 void initialize(const safe_VkPhysicalDevice8BitStorageFeatures* copy_src); ptrsafe_VkPhysicalDevice8BitStorageFeatures2478 VkPhysicalDevice8BitStorageFeatures *ptr() { return reinterpret_cast<VkPhysicalDevice8BitStorageFeatures *>(this); } ptrsafe_VkPhysicalDevice8BitStorageFeatures2479 VkPhysicalDevice8BitStorageFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDevice8BitStorageFeatures const *>(this); } 2480 }; 2481 2482 struct safe_VkPhysicalDeviceDriverProperties { 2483 VkStructureType sType; 2484 void* pNext; 2485 VkDriverId driverID; 2486 char driverName[VK_MAX_DRIVER_NAME_SIZE]; 2487 char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; 2488 VkConformanceVersion conformanceVersion; 2489 safe_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties* in_struct); 2490 safe_VkPhysicalDeviceDriverProperties(const safe_VkPhysicalDeviceDriverProperties& copy_src); 2491 safe_VkPhysicalDeviceDriverProperties& operator=(const safe_VkPhysicalDeviceDriverProperties& copy_src); 2492 safe_VkPhysicalDeviceDriverProperties(); 2493 ~safe_VkPhysicalDeviceDriverProperties(); 2494 void initialize(const VkPhysicalDeviceDriverProperties* in_struct); 2495 void initialize(const safe_VkPhysicalDeviceDriverProperties* copy_src); ptrsafe_VkPhysicalDeviceDriverProperties2496 VkPhysicalDeviceDriverProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceDriverProperties *>(this); } ptrsafe_VkPhysicalDeviceDriverProperties2497 VkPhysicalDeviceDriverProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDriverProperties const *>(this); } 2498 }; 2499 2500 struct safe_VkPhysicalDeviceShaderAtomicInt64Features { 2501 VkStructureType sType; 2502 void* pNext; 2503 VkBool32 shaderBufferInt64Atomics; 2504 VkBool32 shaderSharedInt64Atomics; 2505 safe_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features* in_struct); 2506 safe_VkPhysicalDeviceShaderAtomicInt64Features(const safe_VkPhysicalDeviceShaderAtomicInt64Features& copy_src); 2507 safe_VkPhysicalDeviceShaderAtomicInt64Features& operator=(const safe_VkPhysicalDeviceShaderAtomicInt64Features& copy_src); 2508 safe_VkPhysicalDeviceShaderAtomicInt64Features(); 2509 ~safe_VkPhysicalDeviceShaderAtomicInt64Features(); 2510 void initialize(const VkPhysicalDeviceShaderAtomicInt64Features* in_struct); 2511 void initialize(const safe_VkPhysicalDeviceShaderAtomicInt64Features* copy_src); ptrsafe_VkPhysicalDeviceShaderAtomicInt64Features2512 VkPhysicalDeviceShaderAtomicInt64Features *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features *>(this); } ptrsafe_VkPhysicalDeviceShaderAtomicInt64Features2513 VkPhysicalDeviceShaderAtomicInt64Features const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features const *>(this); } 2514 }; 2515 2516 struct safe_VkPhysicalDeviceShaderFloat16Int8Features { 2517 VkStructureType sType; 2518 void* pNext; 2519 VkBool32 shaderFloat16; 2520 VkBool32 shaderInt8; 2521 safe_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features* in_struct); 2522 safe_VkPhysicalDeviceShaderFloat16Int8Features(const safe_VkPhysicalDeviceShaderFloat16Int8Features& copy_src); 2523 safe_VkPhysicalDeviceShaderFloat16Int8Features& operator=(const safe_VkPhysicalDeviceShaderFloat16Int8Features& copy_src); 2524 safe_VkPhysicalDeviceShaderFloat16Int8Features(); 2525 ~safe_VkPhysicalDeviceShaderFloat16Int8Features(); 2526 void initialize(const VkPhysicalDeviceShaderFloat16Int8Features* in_struct); 2527 void initialize(const safe_VkPhysicalDeviceShaderFloat16Int8Features* copy_src); ptrsafe_VkPhysicalDeviceShaderFloat16Int8Features2528 VkPhysicalDeviceShaderFloat16Int8Features *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features *>(this); } ptrsafe_VkPhysicalDeviceShaderFloat16Int8Features2529 VkPhysicalDeviceShaderFloat16Int8Features const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features const *>(this); } 2530 }; 2531 2532 struct safe_VkPhysicalDeviceFloatControlsProperties { 2533 VkStructureType sType; 2534 void* pNext; 2535 VkShaderFloatControlsIndependence denormBehaviorIndependence; 2536 VkShaderFloatControlsIndependence roundingModeIndependence; 2537 VkBool32 shaderSignedZeroInfNanPreserveFloat16; 2538 VkBool32 shaderSignedZeroInfNanPreserveFloat32; 2539 VkBool32 shaderSignedZeroInfNanPreserveFloat64; 2540 VkBool32 shaderDenormPreserveFloat16; 2541 VkBool32 shaderDenormPreserveFloat32; 2542 VkBool32 shaderDenormPreserveFloat64; 2543 VkBool32 shaderDenormFlushToZeroFloat16; 2544 VkBool32 shaderDenormFlushToZeroFloat32; 2545 VkBool32 shaderDenormFlushToZeroFloat64; 2546 VkBool32 shaderRoundingModeRTEFloat16; 2547 VkBool32 shaderRoundingModeRTEFloat32; 2548 VkBool32 shaderRoundingModeRTEFloat64; 2549 VkBool32 shaderRoundingModeRTZFloat16; 2550 VkBool32 shaderRoundingModeRTZFloat32; 2551 VkBool32 shaderRoundingModeRTZFloat64; 2552 safe_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties* in_struct); 2553 safe_VkPhysicalDeviceFloatControlsProperties(const safe_VkPhysicalDeviceFloatControlsProperties& copy_src); 2554 safe_VkPhysicalDeviceFloatControlsProperties& operator=(const safe_VkPhysicalDeviceFloatControlsProperties& copy_src); 2555 safe_VkPhysicalDeviceFloatControlsProperties(); 2556 ~safe_VkPhysicalDeviceFloatControlsProperties(); 2557 void initialize(const VkPhysicalDeviceFloatControlsProperties* in_struct); 2558 void initialize(const safe_VkPhysicalDeviceFloatControlsProperties* copy_src); ptrsafe_VkPhysicalDeviceFloatControlsProperties2559 VkPhysicalDeviceFloatControlsProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceFloatControlsProperties *>(this); } ptrsafe_VkPhysicalDeviceFloatControlsProperties2560 VkPhysicalDeviceFloatControlsProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFloatControlsProperties const *>(this); } 2561 }; 2562 2563 struct safe_VkDescriptorSetLayoutBindingFlagsCreateInfo { 2564 VkStructureType sType; 2565 const void* pNext; 2566 uint32_t bindingCount; 2567 const VkDescriptorBindingFlags* pBindingFlags; 2568 safe_VkDescriptorSetLayoutBindingFlagsCreateInfo(const VkDescriptorSetLayoutBindingFlagsCreateInfo* in_struct); 2569 safe_VkDescriptorSetLayoutBindingFlagsCreateInfo(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& copy_src); 2570 safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& operator=(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& copy_src); 2571 safe_VkDescriptorSetLayoutBindingFlagsCreateInfo(); 2572 ~safe_VkDescriptorSetLayoutBindingFlagsCreateInfo(); 2573 void initialize(const VkDescriptorSetLayoutBindingFlagsCreateInfo* in_struct); 2574 void initialize(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo* copy_src); ptrsafe_VkDescriptorSetLayoutBindingFlagsCreateInfo2575 VkDescriptorSetLayoutBindingFlagsCreateInfo *ptr() { return reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo *>(this); } ptrsafe_VkDescriptorSetLayoutBindingFlagsCreateInfo2576 VkDescriptorSetLayoutBindingFlagsCreateInfo const *ptr() const { return reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo const *>(this); } 2577 }; 2578 2579 struct safe_VkPhysicalDeviceDescriptorIndexingFeatures { 2580 VkStructureType sType; 2581 void* pNext; 2582 VkBool32 shaderInputAttachmentArrayDynamicIndexing; 2583 VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; 2584 VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; 2585 VkBool32 shaderUniformBufferArrayNonUniformIndexing; 2586 VkBool32 shaderSampledImageArrayNonUniformIndexing; 2587 VkBool32 shaderStorageBufferArrayNonUniformIndexing; 2588 VkBool32 shaderStorageImageArrayNonUniformIndexing; 2589 VkBool32 shaderInputAttachmentArrayNonUniformIndexing; 2590 VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; 2591 VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; 2592 VkBool32 descriptorBindingUniformBufferUpdateAfterBind; 2593 VkBool32 descriptorBindingSampledImageUpdateAfterBind; 2594 VkBool32 descriptorBindingStorageImageUpdateAfterBind; 2595 VkBool32 descriptorBindingStorageBufferUpdateAfterBind; 2596 VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; 2597 VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; 2598 VkBool32 descriptorBindingUpdateUnusedWhilePending; 2599 VkBool32 descriptorBindingPartiallyBound; 2600 VkBool32 descriptorBindingVariableDescriptorCount; 2601 VkBool32 runtimeDescriptorArray; 2602 safe_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures* in_struct); 2603 safe_VkPhysicalDeviceDescriptorIndexingFeatures(const safe_VkPhysicalDeviceDescriptorIndexingFeatures& copy_src); 2604 safe_VkPhysicalDeviceDescriptorIndexingFeatures& operator=(const safe_VkPhysicalDeviceDescriptorIndexingFeatures& copy_src); 2605 safe_VkPhysicalDeviceDescriptorIndexingFeatures(); 2606 ~safe_VkPhysicalDeviceDescriptorIndexingFeatures(); 2607 void initialize(const VkPhysicalDeviceDescriptorIndexingFeatures* in_struct); 2608 void initialize(const safe_VkPhysicalDeviceDescriptorIndexingFeatures* copy_src); ptrsafe_VkPhysicalDeviceDescriptorIndexingFeatures2609 VkPhysicalDeviceDescriptorIndexingFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(this); } ptrsafe_VkPhysicalDeviceDescriptorIndexingFeatures2610 VkPhysicalDeviceDescriptorIndexingFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures const *>(this); } 2611 }; 2612 2613 struct safe_VkPhysicalDeviceDescriptorIndexingProperties { 2614 VkStructureType sType; 2615 void* pNext; 2616 uint32_t maxUpdateAfterBindDescriptorsInAllPools; 2617 VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; 2618 VkBool32 shaderSampledImageArrayNonUniformIndexingNative; 2619 VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; 2620 VkBool32 shaderStorageImageArrayNonUniformIndexingNative; 2621 VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; 2622 VkBool32 robustBufferAccessUpdateAfterBind; 2623 VkBool32 quadDivergentImplicitLod; 2624 uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; 2625 uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; 2626 uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; 2627 uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; 2628 uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; 2629 uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; 2630 uint32_t maxPerStageUpdateAfterBindResources; 2631 uint32_t maxDescriptorSetUpdateAfterBindSamplers; 2632 uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; 2633 uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; 2634 uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; 2635 uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; 2636 uint32_t maxDescriptorSetUpdateAfterBindSampledImages; 2637 uint32_t maxDescriptorSetUpdateAfterBindStorageImages; 2638 uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; 2639 safe_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties* in_struct); 2640 safe_VkPhysicalDeviceDescriptorIndexingProperties(const safe_VkPhysicalDeviceDescriptorIndexingProperties& copy_src); 2641 safe_VkPhysicalDeviceDescriptorIndexingProperties& operator=(const safe_VkPhysicalDeviceDescriptorIndexingProperties& copy_src); 2642 safe_VkPhysicalDeviceDescriptorIndexingProperties(); 2643 ~safe_VkPhysicalDeviceDescriptorIndexingProperties(); 2644 void initialize(const VkPhysicalDeviceDescriptorIndexingProperties* in_struct); 2645 void initialize(const safe_VkPhysicalDeviceDescriptorIndexingProperties* copy_src); ptrsafe_VkPhysicalDeviceDescriptorIndexingProperties2646 VkPhysicalDeviceDescriptorIndexingProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties *>(this); } ptrsafe_VkPhysicalDeviceDescriptorIndexingProperties2647 VkPhysicalDeviceDescriptorIndexingProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties const *>(this); } 2648 }; 2649 2650 struct safe_VkDescriptorSetVariableDescriptorCountAllocateInfo { 2651 VkStructureType sType; 2652 const void* pNext; 2653 uint32_t descriptorSetCount; 2654 const uint32_t* pDescriptorCounts; 2655 safe_VkDescriptorSetVariableDescriptorCountAllocateInfo(const VkDescriptorSetVariableDescriptorCountAllocateInfo* in_struct); 2656 safe_VkDescriptorSetVariableDescriptorCountAllocateInfo(const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& copy_src); 2657 safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& operator=(const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& copy_src); 2658 safe_VkDescriptorSetVariableDescriptorCountAllocateInfo(); 2659 ~safe_VkDescriptorSetVariableDescriptorCountAllocateInfo(); 2660 void initialize(const VkDescriptorSetVariableDescriptorCountAllocateInfo* in_struct); 2661 void initialize(const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo* copy_src); ptrsafe_VkDescriptorSetVariableDescriptorCountAllocateInfo2662 VkDescriptorSetVariableDescriptorCountAllocateInfo *ptr() { return reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo *>(this); } ptrsafe_VkDescriptorSetVariableDescriptorCountAllocateInfo2663 VkDescriptorSetVariableDescriptorCountAllocateInfo const *ptr() const { return reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo const *>(this); } 2664 }; 2665 2666 struct safe_VkDescriptorSetVariableDescriptorCountLayoutSupport { 2667 VkStructureType sType; 2668 void* pNext; 2669 uint32_t maxVariableDescriptorCount; 2670 safe_VkDescriptorSetVariableDescriptorCountLayoutSupport(const VkDescriptorSetVariableDescriptorCountLayoutSupport* in_struct); 2671 safe_VkDescriptorSetVariableDescriptorCountLayoutSupport(const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& copy_src); 2672 safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& operator=(const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& copy_src); 2673 safe_VkDescriptorSetVariableDescriptorCountLayoutSupport(); 2674 ~safe_VkDescriptorSetVariableDescriptorCountLayoutSupport(); 2675 void initialize(const VkDescriptorSetVariableDescriptorCountLayoutSupport* in_struct); 2676 void initialize(const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport* copy_src); ptrsafe_VkDescriptorSetVariableDescriptorCountLayoutSupport2677 VkDescriptorSetVariableDescriptorCountLayoutSupport *ptr() { return reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport *>(this); } ptrsafe_VkDescriptorSetVariableDescriptorCountLayoutSupport2678 VkDescriptorSetVariableDescriptorCountLayoutSupport const *ptr() const { return reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport const *>(this); } 2679 }; 2680 2681 struct safe_VkSubpassDescriptionDepthStencilResolve { 2682 VkStructureType sType; 2683 const void* pNext; 2684 VkResolveModeFlagBits depthResolveMode; 2685 VkResolveModeFlagBits stencilResolveMode; 2686 safe_VkAttachmentReference2* pDepthStencilResolveAttachment; 2687 safe_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve* in_struct); 2688 safe_VkSubpassDescriptionDepthStencilResolve(const safe_VkSubpassDescriptionDepthStencilResolve& copy_src); 2689 safe_VkSubpassDescriptionDepthStencilResolve& operator=(const safe_VkSubpassDescriptionDepthStencilResolve& copy_src); 2690 safe_VkSubpassDescriptionDepthStencilResolve(); 2691 ~safe_VkSubpassDescriptionDepthStencilResolve(); 2692 void initialize(const VkSubpassDescriptionDepthStencilResolve* in_struct); 2693 void initialize(const safe_VkSubpassDescriptionDepthStencilResolve* copy_src); ptrsafe_VkSubpassDescriptionDepthStencilResolve2694 VkSubpassDescriptionDepthStencilResolve *ptr() { return reinterpret_cast<VkSubpassDescriptionDepthStencilResolve *>(this); } ptrsafe_VkSubpassDescriptionDepthStencilResolve2695 VkSubpassDescriptionDepthStencilResolve const *ptr() const { return reinterpret_cast<VkSubpassDescriptionDepthStencilResolve const *>(this); } 2696 }; 2697 2698 struct safe_VkPhysicalDeviceDepthStencilResolveProperties { 2699 VkStructureType sType; 2700 void* pNext; 2701 VkResolveModeFlags supportedDepthResolveModes; 2702 VkResolveModeFlags supportedStencilResolveModes; 2703 VkBool32 independentResolveNone; 2704 VkBool32 independentResolve; 2705 safe_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties* in_struct); 2706 safe_VkPhysicalDeviceDepthStencilResolveProperties(const safe_VkPhysicalDeviceDepthStencilResolveProperties& copy_src); 2707 safe_VkPhysicalDeviceDepthStencilResolveProperties& operator=(const safe_VkPhysicalDeviceDepthStencilResolveProperties& copy_src); 2708 safe_VkPhysicalDeviceDepthStencilResolveProperties(); 2709 ~safe_VkPhysicalDeviceDepthStencilResolveProperties(); 2710 void initialize(const VkPhysicalDeviceDepthStencilResolveProperties* in_struct); 2711 void initialize(const safe_VkPhysicalDeviceDepthStencilResolveProperties* copy_src); ptrsafe_VkPhysicalDeviceDepthStencilResolveProperties2712 VkPhysicalDeviceDepthStencilResolveProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties *>(this); } ptrsafe_VkPhysicalDeviceDepthStencilResolveProperties2713 VkPhysicalDeviceDepthStencilResolveProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties const *>(this); } 2714 }; 2715 2716 struct safe_VkPhysicalDeviceScalarBlockLayoutFeatures { 2717 VkStructureType sType; 2718 void* pNext; 2719 VkBool32 scalarBlockLayout; 2720 safe_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures* in_struct); 2721 safe_VkPhysicalDeviceScalarBlockLayoutFeatures(const safe_VkPhysicalDeviceScalarBlockLayoutFeatures& copy_src); 2722 safe_VkPhysicalDeviceScalarBlockLayoutFeatures& operator=(const safe_VkPhysicalDeviceScalarBlockLayoutFeatures& copy_src); 2723 safe_VkPhysicalDeviceScalarBlockLayoutFeatures(); 2724 ~safe_VkPhysicalDeviceScalarBlockLayoutFeatures(); 2725 void initialize(const VkPhysicalDeviceScalarBlockLayoutFeatures* in_struct); 2726 void initialize(const safe_VkPhysicalDeviceScalarBlockLayoutFeatures* copy_src); ptrsafe_VkPhysicalDeviceScalarBlockLayoutFeatures2727 VkPhysicalDeviceScalarBlockLayoutFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures *>(this); } ptrsafe_VkPhysicalDeviceScalarBlockLayoutFeatures2728 VkPhysicalDeviceScalarBlockLayoutFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures const *>(this); } 2729 }; 2730 2731 struct safe_VkImageStencilUsageCreateInfo { 2732 VkStructureType sType; 2733 const void* pNext; 2734 VkImageUsageFlags stencilUsage; 2735 safe_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo* in_struct); 2736 safe_VkImageStencilUsageCreateInfo(const safe_VkImageStencilUsageCreateInfo& copy_src); 2737 safe_VkImageStencilUsageCreateInfo& operator=(const safe_VkImageStencilUsageCreateInfo& copy_src); 2738 safe_VkImageStencilUsageCreateInfo(); 2739 ~safe_VkImageStencilUsageCreateInfo(); 2740 void initialize(const VkImageStencilUsageCreateInfo* in_struct); 2741 void initialize(const safe_VkImageStencilUsageCreateInfo* copy_src); ptrsafe_VkImageStencilUsageCreateInfo2742 VkImageStencilUsageCreateInfo *ptr() { return reinterpret_cast<VkImageStencilUsageCreateInfo *>(this); } ptrsafe_VkImageStencilUsageCreateInfo2743 VkImageStencilUsageCreateInfo const *ptr() const { return reinterpret_cast<VkImageStencilUsageCreateInfo const *>(this); } 2744 }; 2745 2746 struct safe_VkSamplerReductionModeCreateInfo { 2747 VkStructureType sType; 2748 const void* pNext; 2749 VkSamplerReductionMode reductionMode; 2750 safe_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo* in_struct); 2751 safe_VkSamplerReductionModeCreateInfo(const safe_VkSamplerReductionModeCreateInfo& copy_src); 2752 safe_VkSamplerReductionModeCreateInfo& operator=(const safe_VkSamplerReductionModeCreateInfo& copy_src); 2753 safe_VkSamplerReductionModeCreateInfo(); 2754 ~safe_VkSamplerReductionModeCreateInfo(); 2755 void initialize(const VkSamplerReductionModeCreateInfo* in_struct); 2756 void initialize(const safe_VkSamplerReductionModeCreateInfo* copy_src); ptrsafe_VkSamplerReductionModeCreateInfo2757 VkSamplerReductionModeCreateInfo *ptr() { return reinterpret_cast<VkSamplerReductionModeCreateInfo *>(this); } ptrsafe_VkSamplerReductionModeCreateInfo2758 VkSamplerReductionModeCreateInfo const *ptr() const { return reinterpret_cast<VkSamplerReductionModeCreateInfo const *>(this); } 2759 }; 2760 2761 struct safe_VkPhysicalDeviceSamplerFilterMinmaxProperties { 2762 VkStructureType sType; 2763 void* pNext; 2764 VkBool32 filterMinmaxSingleComponentFormats; 2765 VkBool32 filterMinmaxImageComponentMapping; 2766 safe_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties* in_struct); 2767 safe_VkPhysicalDeviceSamplerFilterMinmaxProperties(const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& copy_src); 2768 safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& operator=(const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& copy_src); 2769 safe_VkPhysicalDeviceSamplerFilterMinmaxProperties(); 2770 ~safe_VkPhysicalDeviceSamplerFilterMinmaxProperties(); 2771 void initialize(const VkPhysicalDeviceSamplerFilterMinmaxProperties* in_struct); 2772 void initialize(const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties* copy_src); ptrsafe_VkPhysicalDeviceSamplerFilterMinmaxProperties2773 VkPhysicalDeviceSamplerFilterMinmaxProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties *>(this); } ptrsafe_VkPhysicalDeviceSamplerFilterMinmaxProperties2774 VkPhysicalDeviceSamplerFilterMinmaxProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties const *>(this); } 2775 }; 2776 2777 struct safe_VkPhysicalDeviceVulkanMemoryModelFeatures { 2778 VkStructureType sType; 2779 void* pNext; 2780 VkBool32 vulkanMemoryModel; 2781 VkBool32 vulkanMemoryModelDeviceScope; 2782 VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; 2783 safe_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures* in_struct); 2784 safe_VkPhysicalDeviceVulkanMemoryModelFeatures(const safe_VkPhysicalDeviceVulkanMemoryModelFeatures& copy_src); 2785 safe_VkPhysicalDeviceVulkanMemoryModelFeatures& operator=(const safe_VkPhysicalDeviceVulkanMemoryModelFeatures& copy_src); 2786 safe_VkPhysicalDeviceVulkanMemoryModelFeatures(); 2787 ~safe_VkPhysicalDeviceVulkanMemoryModelFeatures(); 2788 void initialize(const VkPhysicalDeviceVulkanMemoryModelFeatures* in_struct); 2789 void initialize(const safe_VkPhysicalDeviceVulkanMemoryModelFeatures* copy_src); ptrsafe_VkPhysicalDeviceVulkanMemoryModelFeatures2790 VkPhysicalDeviceVulkanMemoryModelFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures *>(this); } ptrsafe_VkPhysicalDeviceVulkanMemoryModelFeatures2791 VkPhysicalDeviceVulkanMemoryModelFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures const *>(this); } 2792 }; 2793 2794 struct safe_VkPhysicalDeviceImagelessFramebufferFeatures { 2795 VkStructureType sType; 2796 void* pNext; 2797 VkBool32 imagelessFramebuffer; 2798 safe_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures* in_struct); 2799 safe_VkPhysicalDeviceImagelessFramebufferFeatures(const safe_VkPhysicalDeviceImagelessFramebufferFeatures& copy_src); 2800 safe_VkPhysicalDeviceImagelessFramebufferFeatures& operator=(const safe_VkPhysicalDeviceImagelessFramebufferFeatures& copy_src); 2801 safe_VkPhysicalDeviceImagelessFramebufferFeatures(); 2802 ~safe_VkPhysicalDeviceImagelessFramebufferFeatures(); 2803 void initialize(const VkPhysicalDeviceImagelessFramebufferFeatures* in_struct); 2804 void initialize(const safe_VkPhysicalDeviceImagelessFramebufferFeatures* copy_src); ptrsafe_VkPhysicalDeviceImagelessFramebufferFeatures2805 VkPhysicalDeviceImagelessFramebufferFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures *>(this); } ptrsafe_VkPhysicalDeviceImagelessFramebufferFeatures2806 VkPhysicalDeviceImagelessFramebufferFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures const *>(this); } 2807 }; 2808 2809 struct safe_VkFramebufferAttachmentImageInfo { 2810 VkStructureType sType; 2811 const void* pNext; 2812 VkImageCreateFlags flags; 2813 VkImageUsageFlags usage; 2814 uint32_t width; 2815 uint32_t height; 2816 uint32_t layerCount; 2817 uint32_t viewFormatCount; 2818 const VkFormat* pViewFormats; 2819 safe_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo* in_struct); 2820 safe_VkFramebufferAttachmentImageInfo(const safe_VkFramebufferAttachmentImageInfo& copy_src); 2821 safe_VkFramebufferAttachmentImageInfo& operator=(const safe_VkFramebufferAttachmentImageInfo& copy_src); 2822 safe_VkFramebufferAttachmentImageInfo(); 2823 ~safe_VkFramebufferAttachmentImageInfo(); 2824 void initialize(const VkFramebufferAttachmentImageInfo* in_struct); 2825 void initialize(const safe_VkFramebufferAttachmentImageInfo* copy_src); ptrsafe_VkFramebufferAttachmentImageInfo2826 VkFramebufferAttachmentImageInfo *ptr() { return reinterpret_cast<VkFramebufferAttachmentImageInfo *>(this); } ptrsafe_VkFramebufferAttachmentImageInfo2827 VkFramebufferAttachmentImageInfo const *ptr() const { return reinterpret_cast<VkFramebufferAttachmentImageInfo const *>(this); } 2828 }; 2829 2830 struct safe_VkFramebufferAttachmentsCreateInfo { 2831 VkStructureType sType; 2832 const void* pNext; 2833 uint32_t attachmentImageInfoCount; 2834 safe_VkFramebufferAttachmentImageInfo* pAttachmentImageInfos; 2835 safe_VkFramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo* in_struct); 2836 safe_VkFramebufferAttachmentsCreateInfo(const safe_VkFramebufferAttachmentsCreateInfo& copy_src); 2837 safe_VkFramebufferAttachmentsCreateInfo& operator=(const safe_VkFramebufferAttachmentsCreateInfo& copy_src); 2838 safe_VkFramebufferAttachmentsCreateInfo(); 2839 ~safe_VkFramebufferAttachmentsCreateInfo(); 2840 void initialize(const VkFramebufferAttachmentsCreateInfo* in_struct); 2841 void initialize(const safe_VkFramebufferAttachmentsCreateInfo* copy_src); ptrsafe_VkFramebufferAttachmentsCreateInfo2842 VkFramebufferAttachmentsCreateInfo *ptr() { return reinterpret_cast<VkFramebufferAttachmentsCreateInfo *>(this); } ptrsafe_VkFramebufferAttachmentsCreateInfo2843 VkFramebufferAttachmentsCreateInfo const *ptr() const { return reinterpret_cast<VkFramebufferAttachmentsCreateInfo const *>(this); } 2844 }; 2845 2846 struct safe_VkRenderPassAttachmentBeginInfo { 2847 VkStructureType sType; 2848 const void* pNext; 2849 uint32_t attachmentCount; 2850 VkImageView* pAttachments; 2851 safe_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo* in_struct); 2852 safe_VkRenderPassAttachmentBeginInfo(const safe_VkRenderPassAttachmentBeginInfo& copy_src); 2853 safe_VkRenderPassAttachmentBeginInfo& operator=(const safe_VkRenderPassAttachmentBeginInfo& copy_src); 2854 safe_VkRenderPassAttachmentBeginInfo(); 2855 ~safe_VkRenderPassAttachmentBeginInfo(); 2856 void initialize(const VkRenderPassAttachmentBeginInfo* in_struct); 2857 void initialize(const safe_VkRenderPassAttachmentBeginInfo* copy_src); ptrsafe_VkRenderPassAttachmentBeginInfo2858 VkRenderPassAttachmentBeginInfo *ptr() { return reinterpret_cast<VkRenderPassAttachmentBeginInfo *>(this); } ptrsafe_VkRenderPassAttachmentBeginInfo2859 VkRenderPassAttachmentBeginInfo const *ptr() const { return reinterpret_cast<VkRenderPassAttachmentBeginInfo const *>(this); } 2860 }; 2861 2862 struct safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures { 2863 VkStructureType sType; 2864 void* pNext; 2865 VkBool32 uniformBufferStandardLayout; 2866 safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* in_struct); 2867 safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& copy_src); 2868 safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& operator=(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& copy_src); 2869 safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(); 2870 ~safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(); 2871 void initialize(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* in_struct); 2872 void initialize(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures* copy_src); ptrsafe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures2873 VkPhysicalDeviceUniformBufferStandardLayoutFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>(this); } ptrsafe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures2874 VkPhysicalDeviceUniformBufferStandardLayoutFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures const *>(this); } 2875 }; 2876 2877 struct safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures { 2878 VkStructureType sType; 2879 void* pNext; 2880 VkBool32 shaderSubgroupExtendedTypes; 2881 safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* in_struct); 2882 safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& copy_src); 2883 safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& operator=(const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& copy_src); 2884 safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(); 2885 ~safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(); 2886 void initialize(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* in_struct); 2887 void initialize(const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* copy_src); ptrsafe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures2888 VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>(this); } ptrsafe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures2889 VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const *>(this); } 2890 }; 2891 2892 struct safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures { 2893 VkStructureType sType; 2894 void* pNext; 2895 VkBool32 separateDepthStencilLayouts; 2896 safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* in_struct); 2897 safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& copy_src); 2898 safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& operator=(const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& copy_src); 2899 safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(); 2900 ~safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(); 2901 void initialize(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* in_struct); 2902 void initialize(const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* copy_src); ptrsafe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures2903 VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>(this); } ptrsafe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures2904 VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const *>(this); } 2905 }; 2906 2907 struct safe_VkAttachmentReferenceStencilLayout { 2908 VkStructureType sType; 2909 void* pNext; 2910 VkImageLayout stencilLayout; 2911 safe_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout* in_struct); 2912 safe_VkAttachmentReferenceStencilLayout(const safe_VkAttachmentReferenceStencilLayout& copy_src); 2913 safe_VkAttachmentReferenceStencilLayout& operator=(const safe_VkAttachmentReferenceStencilLayout& copy_src); 2914 safe_VkAttachmentReferenceStencilLayout(); 2915 ~safe_VkAttachmentReferenceStencilLayout(); 2916 void initialize(const VkAttachmentReferenceStencilLayout* in_struct); 2917 void initialize(const safe_VkAttachmentReferenceStencilLayout* copy_src); ptrsafe_VkAttachmentReferenceStencilLayout2918 VkAttachmentReferenceStencilLayout *ptr() { return reinterpret_cast<VkAttachmentReferenceStencilLayout *>(this); } ptrsafe_VkAttachmentReferenceStencilLayout2919 VkAttachmentReferenceStencilLayout const *ptr() const { return reinterpret_cast<VkAttachmentReferenceStencilLayout const *>(this); } 2920 }; 2921 2922 struct safe_VkAttachmentDescriptionStencilLayout { 2923 VkStructureType sType; 2924 void* pNext; 2925 VkImageLayout stencilInitialLayout; 2926 VkImageLayout stencilFinalLayout; 2927 safe_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout* in_struct); 2928 safe_VkAttachmentDescriptionStencilLayout(const safe_VkAttachmentDescriptionStencilLayout& copy_src); 2929 safe_VkAttachmentDescriptionStencilLayout& operator=(const safe_VkAttachmentDescriptionStencilLayout& copy_src); 2930 safe_VkAttachmentDescriptionStencilLayout(); 2931 ~safe_VkAttachmentDescriptionStencilLayout(); 2932 void initialize(const VkAttachmentDescriptionStencilLayout* in_struct); 2933 void initialize(const safe_VkAttachmentDescriptionStencilLayout* copy_src); ptrsafe_VkAttachmentDescriptionStencilLayout2934 VkAttachmentDescriptionStencilLayout *ptr() { return reinterpret_cast<VkAttachmentDescriptionStencilLayout *>(this); } ptrsafe_VkAttachmentDescriptionStencilLayout2935 VkAttachmentDescriptionStencilLayout const *ptr() const { return reinterpret_cast<VkAttachmentDescriptionStencilLayout const *>(this); } 2936 }; 2937 2938 struct safe_VkPhysicalDeviceHostQueryResetFeatures { 2939 VkStructureType sType; 2940 void* pNext; 2941 VkBool32 hostQueryReset; 2942 safe_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures* in_struct); 2943 safe_VkPhysicalDeviceHostQueryResetFeatures(const safe_VkPhysicalDeviceHostQueryResetFeatures& copy_src); 2944 safe_VkPhysicalDeviceHostQueryResetFeatures& operator=(const safe_VkPhysicalDeviceHostQueryResetFeatures& copy_src); 2945 safe_VkPhysicalDeviceHostQueryResetFeatures(); 2946 ~safe_VkPhysicalDeviceHostQueryResetFeatures(); 2947 void initialize(const VkPhysicalDeviceHostQueryResetFeatures* in_struct); 2948 void initialize(const safe_VkPhysicalDeviceHostQueryResetFeatures* copy_src); ptrsafe_VkPhysicalDeviceHostQueryResetFeatures2949 VkPhysicalDeviceHostQueryResetFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures *>(this); } ptrsafe_VkPhysicalDeviceHostQueryResetFeatures2950 VkPhysicalDeviceHostQueryResetFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures const *>(this); } 2951 }; 2952 2953 struct safe_VkPhysicalDeviceTimelineSemaphoreFeatures { 2954 VkStructureType sType; 2955 void* pNext; 2956 VkBool32 timelineSemaphore; 2957 safe_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures* in_struct); 2958 safe_VkPhysicalDeviceTimelineSemaphoreFeatures(const safe_VkPhysicalDeviceTimelineSemaphoreFeatures& copy_src); 2959 safe_VkPhysicalDeviceTimelineSemaphoreFeatures& operator=(const safe_VkPhysicalDeviceTimelineSemaphoreFeatures& copy_src); 2960 safe_VkPhysicalDeviceTimelineSemaphoreFeatures(); 2961 ~safe_VkPhysicalDeviceTimelineSemaphoreFeatures(); 2962 void initialize(const VkPhysicalDeviceTimelineSemaphoreFeatures* in_struct); 2963 void initialize(const safe_VkPhysicalDeviceTimelineSemaphoreFeatures* copy_src); ptrsafe_VkPhysicalDeviceTimelineSemaphoreFeatures2964 VkPhysicalDeviceTimelineSemaphoreFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures *>(this); } ptrsafe_VkPhysicalDeviceTimelineSemaphoreFeatures2965 VkPhysicalDeviceTimelineSemaphoreFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures const *>(this); } 2966 }; 2967 2968 struct safe_VkPhysicalDeviceTimelineSemaphoreProperties { 2969 VkStructureType sType; 2970 void* pNext; 2971 uint64_t maxTimelineSemaphoreValueDifference; 2972 safe_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties* in_struct); 2973 safe_VkPhysicalDeviceTimelineSemaphoreProperties(const safe_VkPhysicalDeviceTimelineSemaphoreProperties& copy_src); 2974 safe_VkPhysicalDeviceTimelineSemaphoreProperties& operator=(const safe_VkPhysicalDeviceTimelineSemaphoreProperties& copy_src); 2975 safe_VkPhysicalDeviceTimelineSemaphoreProperties(); 2976 ~safe_VkPhysicalDeviceTimelineSemaphoreProperties(); 2977 void initialize(const VkPhysicalDeviceTimelineSemaphoreProperties* in_struct); 2978 void initialize(const safe_VkPhysicalDeviceTimelineSemaphoreProperties* copy_src); ptrsafe_VkPhysicalDeviceTimelineSemaphoreProperties2979 VkPhysicalDeviceTimelineSemaphoreProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties *>(this); } ptrsafe_VkPhysicalDeviceTimelineSemaphoreProperties2980 VkPhysicalDeviceTimelineSemaphoreProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties const *>(this); } 2981 }; 2982 2983 struct safe_VkSemaphoreTypeCreateInfo { 2984 VkStructureType sType; 2985 const void* pNext; 2986 VkSemaphoreType semaphoreType; 2987 uint64_t initialValue; 2988 safe_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo* in_struct); 2989 safe_VkSemaphoreTypeCreateInfo(const safe_VkSemaphoreTypeCreateInfo& copy_src); 2990 safe_VkSemaphoreTypeCreateInfo& operator=(const safe_VkSemaphoreTypeCreateInfo& copy_src); 2991 safe_VkSemaphoreTypeCreateInfo(); 2992 ~safe_VkSemaphoreTypeCreateInfo(); 2993 void initialize(const VkSemaphoreTypeCreateInfo* in_struct); 2994 void initialize(const safe_VkSemaphoreTypeCreateInfo* copy_src); ptrsafe_VkSemaphoreTypeCreateInfo2995 VkSemaphoreTypeCreateInfo *ptr() { return reinterpret_cast<VkSemaphoreTypeCreateInfo *>(this); } ptrsafe_VkSemaphoreTypeCreateInfo2996 VkSemaphoreTypeCreateInfo const *ptr() const { return reinterpret_cast<VkSemaphoreTypeCreateInfo const *>(this); } 2997 }; 2998 2999 struct safe_VkTimelineSemaphoreSubmitInfo { 3000 VkStructureType sType; 3001 const void* pNext; 3002 uint32_t waitSemaphoreValueCount; 3003 const uint64_t* pWaitSemaphoreValues; 3004 uint32_t signalSemaphoreValueCount; 3005 const uint64_t* pSignalSemaphoreValues; 3006 safe_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo* in_struct); 3007 safe_VkTimelineSemaphoreSubmitInfo(const safe_VkTimelineSemaphoreSubmitInfo& copy_src); 3008 safe_VkTimelineSemaphoreSubmitInfo& operator=(const safe_VkTimelineSemaphoreSubmitInfo& copy_src); 3009 safe_VkTimelineSemaphoreSubmitInfo(); 3010 ~safe_VkTimelineSemaphoreSubmitInfo(); 3011 void initialize(const VkTimelineSemaphoreSubmitInfo* in_struct); 3012 void initialize(const safe_VkTimelineSemaphoreSubmitInfo* copy_src); ptrsafe_VkTimelineSemaphoreSubmitInfo3013 VkTimelineSemaphoreSubmitInfo *ptr() { return reinterpret_cast<VkTimelineSemaphoreSubmitInfo *>(this); } ptrsafe_VkTimelineSemaphoreSubmitInfo3014 VkTimelineSemaphoreSubmitInfo const *ptr() const { return reinterpret_cast<VkTimelineSemaphoreSubmitInfo const *>(this); } 3015 }; 3016 3017 struct safe_VkSemaphoreWaitInfo { 3018 VkStructureType sType; 3019 const void* pNext; 3020 VkSemaphoreWaitFlags flags; 3021 uint32_t semaphoreCount; 3022 VkSemaphore* pSemaphores; 3023 const uint64_t* pValues; 3024 safe_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo* in_struct); 3025 safe_VkSemaphoreWaitInfo(const safe_VkSemaphoreWaitInfo& copy_src); 3026 safe_VkSemaphoreWaitInfo& operator=(const safe_VkSemaphoreWaitInfo& copy_src); 3027 safe_VkSemaphoreWaitInfo(); 3028 ~safe_VkSemaphoreWaitInfo(); 3029 void initialize(const VkSemaphoreWaitInfo* in_struct); 3030 void initialize(const safe_VkSemaphoreWaitInfo* copy_src); ptrsafe_VkSemaphoreWaitInfo3031 VkSemaphoreWaitInfo *ptr() { return reinterpret_cast<VkSemaphoreWaitInfo *>(this); } ptrsafe_VkSemaphoreWaitInfo3032 VkSemaphoreWaitInfo const *ptr() const { return reinterpret_cast<VkSemaphoreWaitInfo const *>(this); } 3033 }; 3034 3035 struct safe_VkSemaphoreSignalInfo { 3036 VkStructureType sType; 3037 const void* pNext; 3038 VkSemaphore semaphore; 3039 uint64_t value; 3040 safe_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo* in_struct); 3041 safe_VkSemaphoreSignalInfo(const safe_VkSemaphoreSignalInfo& copy_src); 3042 safe_VkSemaphoreSignalInfo& operator=(const safe_VkSemaphoreSignalInfo& copy_src); 3043 safe_VkSemaphoreSignalInfo(); 3044 ~safe_VkSemaphoreSignalInfo(); 3045 void initialize(const VkSemaphoreSignalInfo* in_struct); 3046 void initialize(const safe_VkSemaphoreSignalInfo* copy_src); ptrsafe_VkSemaphoreSignalInfo3047 VkSemaphoreSignalInfo *ptr() { return reinterpret_cast<VkSemaphoreSignalInfo *>(this); } ptrsafe_VkSemaphoreSignalInfo3048 VkSemaphoreSignalInfo const *ptr() const { return reinterpret_cast<VkSemaphoreSignalInfo const *>(this); } 3049 }; 3050 3051 struct safe_VkPhysicalDeviceBufferDeviceAddressFeatures { 3052 VkStructureType sType; 3053 void* pNext; 3054 VkBool32 bufferDeviceAddress; 3055 VkBool32 bufferDeviceAddressCaptureReplay; 3056 VkBool32 bufferDeviceAddressMultiDevice; 3057 safe_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures* in_struct); 3058 safe_VkPhysicalDeviceBufferDeviceAddressFeatures(const safe_VkPhysicalDeviceBufferDeviceAddressFeatures& copy_src); 3059 safe_VkPhysicalDeviceBufferDeviceAddressFeatures& operator=(const safe_VkPhysicalDeviceBufferDeviceAddressFeatures& copy_src); 3060 safe_VkPhysicalDeviceBufferDeviceAddressFeatures(); 3061 ~safe_VkPhysicalDeviceBufferDeviceAddressFeatures(); 3062 void initialize(const VkPhysicalDeviceBufferDeviceAddressFeatures* in_struct); 3063 void initialize(const safe_VkPhysicalDeviceBufferDeviceAddressFeatures* copy_src); ptrsafe_VkPhysicalDeviceBufferDeviceAddressFeatures3064 VkPhysicalDeviceBufferDeviceAddressFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures *>(this); } ptrsafe_VkPhysicalDeviceBufferDeviceAddressFeatures3065 VkPhysicalDeviceBufferDeviceAddressFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures const *>(this); } 3066 }; 3067 3068 struct safe_VkBufferDeviceAddressInfo { 3069 VkStructureType sType; 3070 const void* pNext; 3071 VkBuffer buffer; 3072 safe_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo* in_struct); 3073 safe_VkBufferDeviceAddressInfo(const safe_VkBufferDeviceAddressInfo& copy_src); 3074 safe_VkBufferDeviceAddressInfo& operator=(const safe_VkBufferDeviceAddressInfo& copy_src); 3075 safe_VkBufferDeviceAddressInfo(); 3076 ~safe_VkBufferDeviceAddressInfo(); 3077 void initialize(const VkBufferDeviceAddressInfo* in_struct); 3078 void initialize(const safe_VkBufferDeviceAddressInfo* copy_src); ptrsafe_VkBufferDeviceAddressInfo3079 VkBufferDeviceAddressInfo *ptr() { return reinterpret_cast<VkBufferDeviceAddressInfo *>(this); } ptrsafe_VkBufferDeviceAddressInfo3080 VkBufferDeviceAddressInfo const *ptr() const { return reinterpret_cast<VkBufferDeviceAddressInfo const *>(this); } 3081 }; 3082 3083 struct safe_VkBufferOpaqueCaptureAddressCreateInfo { 3084 VkStructureType sType; 3085 const void* pNext; 3086 uint64_t opaqueCaptureAddress; 3087 safe_VkBufferOpaqueCaptureAddressCreateInfo(const VkBufferOpaqueCaptureAddressCreateInfo* in_struct); 3088 safe_VkBufferOpaqueCaptureAddressCreateInfo(const safe_VkBufferOpaqueCaptureAddressCreateInfo& copy_src); 3089 safe_VkBufferOpaqueCaptureAddressCreateInfo& operator=(const safe_VkBufferOpaqueCaptureAddressCreateInfo& copy_src); 3090 safe_VkBufferOpaqueCaptureAddressCreateInfo(); 3091 ~safe_VkBufferOpaqueCaptureAddressCreateInfo(); 3092 void initialize(const VkBufferOpaqueCaptureAddressCreateInfo* in_struct); 3093 void initialize(const safe_VkBufferOpaqueCaptureAddressCreateInfo* copy_src); ptrsafe_VkBufferOpaqueCaptureAddressCreateInfo3094 VkBufferOpaqueCaptureAddressCreateInfo *ptr() { return reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo *>(this); } ptrsafe_VkBufferOpaqueCaptureAddressCreateInfo3095 VkBufferOpaqueCaptureAddressCreateInfo const *ptr() const { return reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo const *>(this); } 3096 }; 3097 3098 struct safe_VkMemoryOpaqueCaptureAddressAllocateInfo { 3099 VkStructureType sType; 3100 const void* pNext; 3101 uint64_t opaqueCaptureAddress; 3102 safe_VkMemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo* in_struct); 3103 safe_VkMemoryOpaqueCaptureAddressAllocateInfo(const safe_VkMemoryOpaqueCaptureAddressAllocateInfo& copy_src); 3104 safe_VkMemoryOpaqueCaptureAddressAllocateInfo& operator=(const safe_VkMemoryOpaqueCaptureAddressAllocateInfo& copy_src); 3105 safe_VkMemoryOpaqueCaptureAddressAllocateInfo(); 3106 ~safe_VkMemoryOpaqueCaptureAddressAllocateInfo(); 3107 void initialize(const VkMemoryOpaqueCaptureAddressAllocateInfo* in_struct); 3108 void initialize(const safe_VkMemoryOpaqueCaptureAddressAllocateInfo* copy_src); ptrsafe_VkMemoryOpaqueCaptureAddressAllocateInfo3109 VkMemoryOpaqueCaptureAddressAllocateInfo *ptr() { return reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo *>(this); } ptrsafe_VkMemoryOpaqueCaptureAddressAllocateInfo3110 VkMemoryOpaqueCaptureAddressAllocateInfo const *ptr() const { return reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo const *>(this); } 3111 }; 3112 3113 struct safe_VkDeviceMemoryOpaqueCaptureAddressInfo { 3114 VkStructureType sType; 3115 const void* pNext; 3116 VkDeviceMemory memory; 3117 safe_VkDeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo* in_struct); 3118 safe_VkDeviceMemoryOpaqueCaptureAddressInfo(const safe_VkDeviceMemoryOpaqueCaptureAddressInfo& copy_src); 3119 safe_VkDeviceMemoryOpaqueCaptureAddressInfo& operator=(const safe_VkDeviceMemoryOpaqueCaptureAddressInfo& copy_src); 3120 safe_VkDeviceMemoryOpaqueCaptureAddressInfo(); 3121 ~safe_VkDeviceMemoryOpaqueCaptureAddressInfo(); 3122 void initialize(const VkDeviceMemoryOpaqueCaptureAddressInfo* in_struct); 3123 void initialize(const safe_VkDeviceMemoryOpaqueCaptureAddressInfo* copy_src); ptrsafe_VkDeviceMemoryOpaqueCaptureAddressInfo3124 VkDeviceMemoryOpaqueCaptureAddressInfo *ptr() { return reinterpret_cast<VkDeviceMemoryOpaqueCaptureAddressInfo *>(this); } ptrsafe_VkDeviceMemoryOpaqueCaptureAddressInfo3125 VkDeviceMemoryOpaqueCaptureAddressInfo const *ptr() const { return reinterpret_cast<VkDeviceMemoryOpaqueCaptureAddressInfo const *>(this); } 3126 }; 3127 3128 struct safe_VkSwapchainCreateInfoKHR { 3129 VkStructureType sType; 3130 const void* pNext; 3131 VkSwapchainCreateFlagsKHR flags; 3132 VkSurfaceKHR surface; 3133 uint32_t minImageCount; 3134 VkFormat imageFormat; 3135 VkColorSpaceKHR imageColorSpace; 3136 VkExtent2D imageExtent; 3137 uint32_t imageArrayLayers; 3138 VkImageUsageFlags imageUsage; 3139 VkSharingMode imageSharingMode; 3140 uint32_t queueFamilyIndexCount; 3141 const uint32_t* pQueueFamilyIndices; 3142 VkSurfaceTransformFlagBitsKHR preTransform; 3143 VkCompositeAlphaFlagBitsKHR compositeAlpha; 3144 VkPresentModeKHR presentMode; 3145 VkBool32 clipped; 3146 VkSwapchainKHR oldSwapchain; 3147 safe_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR* in_struct); 3148 safe_VkSwapchainCreateInfoKHR(const safe_VkSwapchainCreateInfoKHR& copy_src); 3149 safe_VkSwapchainCreateInfoKHR& operator=(const safe_VkSwapchainCreateInfoKHR& copy_src); 3150 safe_VkSwapchainCreateInfoKHR(); 3151 ~safe_VkSwapchainCreateInfoKHR(); 3152 void initialize(const VkSwapchainCreateInfoKHR* in_struct); 3153 void initialize(const safe_VkSwapchainCreateInfoKHR* copy_src); ptrsafe_VkSwapchainCreateInfoKHR3154 VkSwapchainCreateInfoKHR *ptr() { return reinterpret_cast<VkSwapchainCreateInfoKHR *>(this); } ptrsafe_VkSwapchainCreateInfoKHR3155 VkSwapchainCreateInfoKHR const *ptr() const { return reinterpret_cast<VkSwapchainCreateInfoKHR const *>(this); } 3156 }; 3157 3158 struct safe_VkPresentInfoKHR { 3159 VkStructureType sType; 3160 const void* pNext; 3161 uint32_t waitSemaphoreCount; 3162 VkSemaphore* pWaitSemaphores; 3163 uint32_t swapchainCount; 3164 VkSwapchainKHR* pSwapchains; 3165 const uint32_t* pImageIndices; 3166 VkResult* pResults; 3167 safe_VkPresentInfoKHR(const VkPresentInfoKHR* in_struct); 3168 safe_VkPresentInfoKHR(const safe_VkPresentInfoKHR& copy_src); 3169 safe_VkPresentInfoKHR& operator=(const safe_VkPresentInfoKHR& copy_src); 3170 safe_VkPresentInfoKHR(); 3171 ~safe_VkPresentInfoKHR(); 3172 void initialize(const VkPresentInfoKHR* in_struct); 3173 void initialize(const safe_VkPresentInfoKHR* copy_src); ptrsafe_VkPresentInfoKHR3174 VkPresentInfoKHR *ptr() { return reinterpret_cast<VkPresentInfoKHR *>(this); } ptrsafe_VkPresentInfoKHR3175 VkPresentInfoKHR const *ptr() const { return reinterpret_cast<VkPresentInfoKHR const *>(this); } 3176 }; 3177 3178 struct safe_VkImageSwapchainCreateInfoKHR { 3179 VkStructureType sType; 3180 const void* pNext; 3181 VkSwapchainKHR swapchain; 3182 safe_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR* in_struct); 3183 safe_VkImageSwapchainCreateInfoKHR(const safe_VkImageSwapchainCreateInfoKHR& copy_src); 3184 safe_VkImageSwapchainCreateInfoKHR& operator=(const safe_VkImageSwapchainCreateInfoKHR& copy_src); 3185 safe_VkImageSwapchainCreateInfoKHR(); 3186 ~safe_VkImageSwapchainCreateInfoKHR(); 3187 void initialize(const VkImageSwapchainCreateInfoKHR* in_struct); 3188 void initialize(const safe_VkImageSwapchainCreateInfoKHR* copy_src); ptrsafe_VkImageSwapchainCreateInfoKHR3189 VkImageSwapchainCreateInfoKHR *ptr() { return reinterpret_cast<VkImageSwapchainCreateInfoKHR *>(this); } ptrsafe_VkImageSwapchainCreateInfoKHR3190 VkImageSwapchainCreateInfoKHR const *ptr() const { return reinterpret_cast<VkImageSwapchainCreateInfoKHR const *>(this); } 3191 }; 3192 3193 struct safe_VkBindImageMemorySwapchainInfoKHR { 3194 VkStructureType sType; 3195 const void* pNext; 3196 VkSwapchainKHR swapchain; 3197 uint32_t imageIndex; 3198 safe_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR* in_struct); 3199 safe_VkBindImageMemorySwapchainInfoKHR(const safe_VkBindImageMemorySwapchainInfoKHR& copy_src); 3200 safe_VkBindImageMemorySwapchainInfoKHR& operator=(const safe_VkBindImageMemorySwapchainInfoKHR& copy_src); 3201 safe_VkBindImageMemorySwapchainInfoKHR(); 3202 ~safe_VkBindImageMemorySwapchainInfoKHR(); 3203 void initialize(const VkBindImageMemorySwapchainInfoKHR* in_struct); 3204 void initialize(const safe_VkBindImageMemorySwapchainInfoKHR* copy_src); ptrsafe_VkBindImageMemorySwapchainInfoKHR3205 VkBindImageMemorySwapchainInfoKHR *ptr() { return reinterpret_cast<VkBindImageMemorySwapchainInfoKHR *>(this); } ptrsafe_VkBindImageMemorySwapchainInfoKHR3206 VkBindImageMemorySwapchainInfoKHR const *ptr() const { return reinterpret_cast<VkBindImageMemorySwapchainInfoKHR const *>(this); } 3207 }; 3208 3209 struct safe_VkAcquireNextImageInfoKHR { 3210 VkStructureType sType; 3211 const void* pNext; 3212 VkSwapchainKHR swapchain; 3213 uint64_t timeout; 3214 VkSemaphore semaphore; 3215 VkFence fence; 3216 uint32_t deviceMask; 3217 safe_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR* in_struct); 3218 safe_VkAcquireNextImageInfoKHR(const safe_VkAcquireNextImageInfoKHR& copy_src); 3219 safe_VkAcquireNextImageInfoKHR& operator=(const safe_VkAcquireNextImageInfoKHR& copy_src); 3220 safe_VkAcquireNextImageInfoKHR(); 3221 ~safe_VkAcquireNextImageInfoKHR(); 3222 void initialize(const VkAcquireNextImageInfoKHR* in_struct); 3223 void initialize(const safe_VkAcquireNextImageInfoKHR* copy_src); ptrsafe_VkAcquireNextImageInfoKHR3224 VkAcquireNextImageInfoKHR *ptr() { return reinterpret_cast<VkAcquireNextImageInfoKHR *>(this); } ptrsafe_VkAcquireNextImageInfoKHR3225 VkAcquireNextImageInfoKHR const *ptr() const { return reinterpret_cast<VkAcquireNextImageInfoKHR const *>(this); } 3226 }; 3227 3228 struct safe_VkDeviceGroupPresentCapabilitiesKHR { 3229 VkStructureType sType; 3230 const void* pNext; 3231 uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; 3232 VkDeviceGroupPresentModeFlagsKHR modes; 3233 safe_VkDeviceGroupPresentCapabilitiesKHR(const VkDeviceGroupPresentCapabilitiesKHR* in_struct); 3234 safe_VkDeviceGroupPresentCapabilitiesKHR(const safe_VkDeviceGroupPresentCapabilitiesKHR& copy_src); 3235 safe_VkDeviceGroupPresentCapabilitiesKHR& operator=(const safe_VkDeviceGroupPresentCapabilitiesKHR& copy_src); 3236 safe_VkDeviceGroupPresentCapabilitiesKHR(); 3237 ~safe_VkDeviceGroupPresentCapabilitiesKHR(); 3238 void initialize(const VkDeviceGroupPresentCapabilitiesKHR* in_struct); 3239 void initialize(const safe_VkDeviceGroupPresentCapabilitiesKHR* copy_src); ptrsafe_VkDeviceGroupPresentCapabilitiesKHR3240 VkDeviceGroupPresentCapabilitiesKHR *ptr() { return reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>(this); } ptrsafe_VkDeviceGroupPresentCapabilitiesKHR3241 VkDeviceGroupPresentCapabilitiesKHR const *ptr() const { return reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR const *>(this); } 3242 }; 3243 3244 struct safe_VkDeviceGroupPresentInfoKHR { 3245 VkStructureType sType; 3246 const void* pNext; 3247 uint32_t swapchainCount; 3248 const uint32_t* pDeviceMasks; 3249 VkDeviceGroupPresentModeFlagBitsKHR mode; 3250 safe_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR* in_struct); 3251 safe_VkDeviceGroupPresentInfoKHR(const safe_VkDeviceGroupPresentInfoKHR& copy_src); 3252 safe_VkDeviceGroupPresentInfoKHR& operator=(const safe_VkDeviceGroupPresentInfoKHR& copy_src); 3253 safe_VkDeviceGroupPresentInfoKHR(); 3254 ~safe_VkDeviceGroupPresentInfoKHR(); 3255 void initialize(const VkDeviceGroupPresentInfoKHR* in_struct); 3256 void initialize(const safe_VkDeviceGroupPresentInfoKHR* copy_src); ptrsafe_VkDeviceGroupPresentInfoKHR3257 VkDeviceGroupPresentInfoKHR *ptr() { return reinterpret_cast<VkDeviceGroupPresentInfoKHR *>(this); } ptrsafe_VkDeviceGroupPresentInfoKHR3258 VkDeviceGroupPresentInfoKHR const *ptr() const { return reinterpret_cast<VkDeviceGroupPresentInfoKHR const *>(this); } 3259 }; 3260 3261 struct safe_VkDeviceGroupSwapchainCreateInfoKHR { 3262 VkStructureType sType; 3263 const void* pNext; 3264 VkDeviceGroupPresentModeFlagsKHR modes; 3265 safe_VkDeviceGroupSwapchainCreateInfoKHR(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct); 3266 safe_VkDeviceGroupSwapchainCreateInfoKHR(const safe_VkDeviceGroupSwapchainCreateInfoKHR& copy_src); 3267 safe_VkDeviceGroupSwapchainCreateInfoKHR& operator=(const safe_VkDeviceGroupSwapchainCreateInfoKHR& copy_src); 3268 safe_VkDeviceGroupSwapchainCreateInfoKHR(); 3269 ~safe_VkDeviceGroupSwapchainCreateInfoKHR(); 3270 void initialize(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct); 3271 void initialize(const safe_VkDeviceGroupSwapchainCreateInfoKHR* copy_src); ptrsafe_VkDeviceGroupSwapchainCreateInfoKHR3272 VkDeviceGroupSwapchainCreateInfoKHR *ptr() { return reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR *>(this); } ptrsafe_VkDeviceGroupSwapchainCreateInfoKHR3273 VkDeviceGroupSwapchainCreateInfoKHR const *ptr() const { return reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR const *>(this); } 3274 }; 3275 3276 struct safe_VkDisplayModeCreateInfoKHR { 3277 VkStructureType sType; 3278 const void* pNext; 3279 VkDisplayModeCreateFlagsKHR flags; 3280 VkDisplayModeParametersKHR parameters; 3281 safe_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR* in_struct); 3282 safe_VkDisplayModeCreateInfoKHR(const safe_VkDisplayModeCreateInfoKHR& copy_src); 3283 safe_VkDisplayModeCreateInfoKHR& operator=(const safe_VkDisplayModeCreateInfoKHR& copy_src); 3284 safe_VkDisplayModeCreateInfoKHR(); 3285 ~safe_VkDisplayModeCreateInfoKHR(); 3286 void initialize(const VkDisplayModeCreateInfoKHR* in_struct); 3287 void initialize(const safe_VkDisplayModeCreateInfoKHR* copy_src); ptrsafe_VkDisplayModeCreateInfoKHR3288 VkDisplayModeCreateInfoKHR *ptr() { return reinterpret_cast<VkDisplayModeCreateInfoKHR *>(this); } ptrsafe_VkDisplayModeCreateInfoKHR3289 VkDisplayModeCreateInfoKHR const *ptr() const { return reinterpret_cast<VkDisplayModeCreateInfoKHR const *>(this); } 3290 }; 3291 3292 struct safe_VkDisplayPropertiesKHR { 3293 VkDisplayKHR display; 3294 const char* displayName; 3295 VkExtent2D physicalDimensions; 3296 VkExtent2D physicalResolution; 3297 VkSurfaceTransformFlagsKHR supportedTransforms; 3298 VkBool32 planeReorderPossible; 3299 VkBool32 persistentContent; 3300 safe_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR* in_struct); 3301 safe_VkDisplayPropertiesKHR(const safe_VkDisplayPropertiesKHR& copy_src); 3302 safe_VkDisplayPropertiesKHR& operator=(const safe_VkDisplayPropertiesKHR& copy_src); 3303 safe_VkDisplayPropertiesKHR(); 3304 ~safe_VkDisplayPropertiesKHR(); 3305 void initialize(const VkDisplayPropertiesKHR* in_struct); 3306 void initialize(const safe_VkDisplayPropertiesKHR* copy_src); ptrsafe_VkDisplayPropertiesKHR3307 VkDisplayPropertiesKHR *ptr() { return reinterpret_cast<VkDisplayPropertiesKHR *>(this); } ptrsafe_VkDisplayPropertiesKHR3308 VkDisplayPropertiesKHR const *ptr() const { return reinterpret_cast<VkDisplayPropertiesKHR const *>(this); } 3309 }; 3310 3311 struct safe_VkDisplaySurfaceCreateInfoKHR { 3312 VkStructureType sType; 3313 const void* pNext; 3314 VkDisplaySurfaceCreateFlagsKHR flags; 3315 VkDisplayModeKHR displayMode; 3316 uint32_t planeIndex; 3317 uint32_t planeStackIndex; 3318 VkSurfaceTransformFlagBitsKHR transform; 3319 float globalAlpha; 3320 VkDisplayPlaneAlphaFlagBitsKHR alphaMode; 3321 VkExtent2D imageExtent; 3322 safe_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR* in_struct); 3323 safe_VkDisplaySurfaceCreateInfoKHR(const safe_VkDisplaySurfaceCreateInfoKHR& copy_src); 3324 safe_VkDisplaySurfaceCreateInfoKHR& operator=(const safe_VkDisplaySurfaceCreateInfoKHR& copy_src); 3325 safe_VkDisplaySurfaceCreateInfoKHR(); 3326 ~safe_VkDisplaySurfaceCreateInfoKHR(); 3327 void initialize(const VkDisplaySurfaceCreateInfoKHR* in_struct); 3328 void initialize(const safe_VkDisplaySurfaceCreateInfoKHR* copy_src); ptrsafe_VkDisplaySurfaceCreateInfoKHR3329 VkDisplaySurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkDisplaySurfaceCreateInfoKHR *>(this); } ptrsafe_VkDisplaySurfaceCreateInfoKHR3330 VkDisplaySurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkDisplaySurfaceCreateInfoKHR const *>(this); } 3331 }; 3332 3333 struct safe_VkDisplayPresentInfoKHR { 3334 VkStructureType sType; 3335 const void* pNext; 3336 VkRect2D srcRect; 3337 VkRect2D dstRect; 3338 VkBool32 persistent; 3339 safe_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR* in_struct); 3340 safe_VkDisplayPresentInfoKHR(const safe_VkDisplayPresentInfoKHR& copy_src); 3341 safe_VkDisplayPresentInfoKHR& operator=(const safe_VkDisplayPresentInfoKHR& copy_src); 3342 safe_VkDisplayPresentInfoKHR(); 3343 ~safe_VkDisplayPresentInfoKHR(); 3344 void initialize(const VkDisplayPresentInfoKHR* in_struct); 3345 void initialize(const safe_VkDisplayPresentInfoKHR* copy_src); ptrsafe_VkDisplayPresentInfoKHR3346 VkDisplayPresentInfoKHR *ptr() { return reinterpret_cast<VkDisplayPresentInfoKHR *>(this); } ptrsafe_VkDisplayPresentInfoKHR3347 VkDisplayPresentInfoKHR const *ptr() const { return reinterpret_cast<VkDisplayPresentInfoKHR const *>(this); } 3348 }; 3349 3350 #ifdef VK_USE_PLATFORM_XLIB_KHR 3351 struct safe_VkXlibSurfaceCreateInfoKHR { 3352 VkStructureType sType; 3353 const void* pNext; 3354 VkXlibSurfaceCreateFlagsKHR flags; 3355 Display* dpy; 3356 Window window; 3357 safe_VkXlibSurfaceCreateInfoKHR(const VkXlibSurfaceCreateInfoKHR* in_struct); 3358 safe_VkXlibSurfaceCreateInfoKHR(const safe_VkXlibSurfaceCreateInfoKHR& copy_src); 3359 safe_VkXlibSurfaceCreateInfoKHR& operator=(const safe_VkXlibSurfaceCreateInfoKHR& copy_src); 3360 safe_VkXlibSurfaceCreateInfoKHR(); 3361 ~safe_VkXlibSurfaceCreateInfoKHR(); 3362 void initialize(const VkXlibSurfaceCreateInfoKHR* in_struct); 3363 void initialize(const safe_VkXlibSurfaceCreateInfoKHR* copy_src); ptrsafe_VkXlibSurfaceCreateInfoKHR3364 VkXlibSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkXlibSurfaceCreateInfoKHR *>(this); } ptrsafe_VkXlibSurfaceCreateInfoKHR3365 VkXlibSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkXlibSurfaceCreateInfoKHR const *>(this); } 3366 }; 3367 #endif // VK_USE_PLATFORM_XLIB_KHR 3368 3369 #ifdef VK_USE_PLATFORM_XCB_KHR 3370 struct safe_VkXcbSurfaceCreateInfoKHR { 3371 VkStructureType sType; 3372 const void* pNext; 3373 VkXcbSurfaceCreateFlagsKHR flags; 3374 xcb_connection_t* connection; 3375 xcb_window_t window; 3376 safe_VkXcbSurfaceCreateInfoKHR(const VkXcbSurfaceCreateInfoKHR* in_struct); 3377 safe_VkXcbSurfaceCreateInfoKHR(const safe_VkXcbSurfaceCreateInfoKHR& copy_src); 3378 safe_VkXcbSurfaceCreateInfoKHR& operator=(const safe_VkXcbSurfaceCreateInfoKHR& copy_src); 3379 safe_VkXcbSurfaceCreateInfoKHR(); 3380 ~safe_VkXcbSurfaceCreateInfoKHR(); 3381 void initialize(const VkXcbSurfaceCreateInfoKHR* in_struct); 3382 void initialize(const safe_VkXcbSurfaceCreateInfoKHR* copy_src); ptrsafe_VkXcbSurfaceCreateInfoKHR3383 VkXcbSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkXcbSurfaceCreateInfoKHR *>(this); } ptrsafe_VkXcbSurfaceCreateInfoKHR3384 VkXcbSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkXcbSurfaceCreateInfoKHR const *>(this); } 3385 }; 3386 #endif // VK_USE_PLATFORM_XCB_KHR 3387 3388 #ifdef VK_USE_PLATFORM_WAYLAND_KHR 3389 struct safe_VkWaylandSurfaceCreateInfoKHR { 3390 VkStructureType sType; 3391 const void* pNext; 3392 VkWaylandSurfaceCreateFlagsKHR flags; 3393 struct wl_display* display; 3394 struct wl_surface* surface; 3395 safe_VkWaylandSurfaceCreateInfoKHR(const VkWaylandSurfaceCreateInfoKHR* in_struct); 3396 safe_VkWaylandSurfaceCreateInfoKHR(const safe_VkWaylandSurfaceCreateInfoKHR& copy_src); 3397 safe_VkWaylandSurfaceCreateInfoKHR& operator=(const safe_VkWaylandSurfaceCreateInfoKHR& copy_src); 3398 safe_VkWaylandSurfaceCreateInfoKHR(); 3399 ~safe_VkWaylandSurfaceCreateInfoKHR(); 3400 void initialize(const VkWaylandSurfaceCreateInfoKHR* in_struct); 3401 void initialize(const safe_VkWaylandSurfaceCreateInfoKHR* copy_src); ptrsafe_VkWaylandSurfaceCreateInfoKHR3402 VkWaylandSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkWaylandSurfaceCreateInfoKHR *>(this); } ptrsafe_VkWaylandSurfaceCreateInfoKHR3403 VkWaylandSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkWaylandSurfaceCreateInfoKHR const *>(this); } 3404 }; 3405 #endif // VK_USE_PLATFORM_WAYLAND_KHR 3406 3407 #ifdef VK_USE_PLATFORM_ANDROID_KHR 3408 struct safe_VkAndroidSurfaceCreateInfoKHR { 3409 VkStructureType sType; 3410 const void* pNext; 3411 VkAndroidSurfaceCreateFlagsKHR flags; 3412 struct ANativeWindow* window; 3413 safe_VkAndroidSurfaceCreateInfoKHR(const VkAndroidSurfaceCreateInfoKHR* in_struct); 3414 safe_VkAndroidSurfaceCreateInfoKHR(const safe_VkAndroidSurfaceCreateInfoKHR& copy_src); 3415 safe_VkAndroidSurfaceCreateInfoKHR& operator=(const safe_VkAndroidSurfaceCreateInfoKHR& copy_src); 3416 safe_VkAndroidSurfaceCreateInfoKHR(); 3417 ~safe_VkAndroidSurfaceCreateInfoKHR(); 3418 void initialize(const VkAndroidSurfaceCreateInfoKHR* in_struct); 3419 void initialize(const safe_VkAndroidSurfaceCreateInfoKHR* copy_src); ptrsafe_VkAndroidSurfaceCreateInfoKHR3420 VkAndroidSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkAndroidSurfaceCreateInfoKHR *>(this); } ptrsafe_VkAndroidSurfaceCreateInfoKHR3421 VkAndroidSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkAndroidSurfaceCreateInfoKHR const *>(this); } 3422 }; 3423 #endif // VK_USE_PLATFORM_ANDROID_KHR 3424 3425 #ifdef VK_USE_PLATFORM_WIN32_KHR 3426 struct safe_VkWin32SurfaceCreateInfoKHR { 3427 VkStructureType sType; 3428 const void* pNext; 3429 VkWin32SurfaceCreateFlagsKHR flags; 3430 HINSTANCE hinstance; 3431 HWND hwnd; 3432 safe_VkWin32SurfaceCreateInfoKHR(const VkWin32SurfaceCreateInfoKHR* in_struct); 3433 safe_VkWin32SurfaceCreateInfoKHR(const safe_VkWin32SurfaceCreateInfoKHR& copy_src); 3434 safe_VkWin32SurfaceCreateInfoKHR& operator=(const safe_VkWin32SurfaceCreateInfoKHR& copy_src); 3435 safe_VkWin32SurfaceCreateInfoKHR(); 3436 ~safe_VkWin32SurfaceCreateInfoKHR(); 3437 void initialize(const VkWin32SurfaceCreateInfoKHR* in_struct); 3438 void initialize(const safe_VkWin32SurfaceCreateInfoKHR* copy_src); ptrsafe_VkWin32SurfaceCreateInfoKHR3439 VkWin32SurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkWin32SurfaceCreateInfoKHR *>(this); } ptrsafe_VkWin32SurfaceCreateInfoKHR3440 VkWin32SurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkWin32SurfaceCreateInfoKHR const *>(this); } 3441 }; 3442 #endif // VK_USE_PLATFORM_WIN32_KHR 3443 3444 #ifdef VK_USE_PLATFORM_WIN32_KHR 3445 struct safe_VkImportMemoryWin32HandleInfoKHR { 3446 VkStructureType sType; 3447 const void* pNext; 3448 VkExternalMemoryHandleTypeFlagBits handleType; 3449 HANDLE handle; 3450 LPCWSTR name; 3451 safe_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR* in_struct); 3452 safe_VkImportMemoryWin32HandleInfoKHR(const safe_VkImportMemoryWin32HandleInfoKHR& copy_src); 3453 safe_VkImportMemoryWin32HandleInfoKHR& operator=(const safe_VkImportMemoryWin32HandleInfoKHR& copy_src); 3454 safe_VkImportMemoryWin32HandleInfoKHR(); 3455 ~safe_VkImportMemoryWin32HandleInfoKHR(); 3456 void initialize(const VkImportMemoryWin32HandleInfoKHR* in_struct); 3457 void initialize(const safe_VkImportMemoryWin32HandleInfoKHR* copy_src); ptrsafe_VkImportMemoryWin32HandleInfoKHR3458 VkImportMemoryWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkImportMemoryWin32HandleInfoKHR *>(this); } ptrsafe_VkImportMemoryWin32HandleInfoKHR3459 VkImportMemoryWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkImportMemoryWin32HandleInfoKHR const *>(this); } 3460 }; 3461 #endif // VK_USE_PLATFORM_WIN32_KHR 3462 3463 #ifdef VK_USE_PLATFORM_WIN32_KHR 3464 struct safe_VkExportMemoryWin32HandleInfoKHR { 3465 VkStructureType sType; 3466 const void* pNext; 3467 const SECURITY_ATTRIBUTES* pAttributes; 3468 DWORD dwAccess; 3469 LPCWSTR name; 3470 safe_VkExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR* in_struct); 3471 safe_VkExportMemoryWin32HandleInfoKHR(const safe_VkExportMemoryWin32HandleInfoKHR& copy_src); 3472 safe_VkExportMemoryWin32HandleInfoKHR& operator=(const safe_VkExportMemoryWin32HandleInfoKHR& copy_src); 3473 safe_VkExportMemoryWin32HandleInfoKHR(); 3474 ~safe_VkExportMemoryWin32HandleInfoKHR(); 3475 void initialize(const VkExportMemoryWin32HandleInfoKHR* in_struct); 3476 void initialize(const safe_VkExportMemoryWin32HandleInfoKHR* copy_src); ptrsafe_VkExportMemoryWin32HandleInfoKHR3477 VkExportMemoryWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkExportMemoryWin32HandleInfoKHR *>(this); } ptrsafe_VkExportMemoryWin32HandleInfoKHR3478 VkExportMemoryWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkExportMemoryWin32HandleInfoKHR const *>(this); } 3479 }; 3480 #endif // VK_USE_PLATFORM_WIN32_KHR 3481 3482 #ifdef VK_USE_PLATFORM_WIN32_KHR 3483 struct safe_VkMemoryWin32HandlePropertiesKHR { 3484 VkStructureType sType; 3485 void* pNext; 3486 uint32_t memoryTypeBits; 3487 safe_VkMemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR* in_struct); 3488 safe_VkMemoryWin32HandlePropertiesKHR(const safe_VkMemoryWin32HandlePropertiesKHR& copy_src); 3489 safe_VkMemoryWin32HandlePropertiesKHR& operator=(const safe_VkMemoryWin32HandlePropertiesKHR& copy_src); 3490 safe_VkMemoryWin32HandlePropertiesKHR(); 3491 ~safe_VkMemoryWin32HandlePropertiesKHR(); 3492 void initialize(const VkMemoryWin32HandlePropertiesKHR* in_struct); 3493 void initialize(const safe_VkMemoryWin32HandlePropertiesKHR* copy_src); ptrsafe_VkMemoryWin32HandlePropertiesKHR3494 VkMemoryWin32HandlePropertiesKHR *ptr() { return reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>(this); } ptrsafe_VkMemoryWin32HandlePropertiesKHR3495 VkMemoryWin32HandlePropertiesKHR const *ptr() const { return reinterpret_cast<VkMemoryWin32HandlePropertiesKHR const *>(this); } 3496 }; 3497 #endif // VK_USE_PLATFORM_WIN32_KHR 3498 3499 #ifdef VK_USE_PLATFORM_WIN32_KHR 3500 struct safe_VkMemoryGetWin32HandleInfoKHR { 3501 VkStructureType sType; 3502 const void* pNext; 3503 VkDeviceMemory memory; 3504 VkExternalMemoryHandleTypeFlagBits handleType; 3505 safe_VkMemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR* in_struct); 3506 safe_VkMemoryGetWin32HandleInfoKHR(const safe_VkMemoryGetWin32HandleInfoKHR& copy_src); 3507 safe_VkMemoryGetWin32HandleInfoKHR& operator=(const safe_VkMemoryGetWin32HandleInfoKHR& copy_src); 3508 safe_VkMemoryGetWin32HandleInfoKHR(); 3509 ~safe_VkMemoryGetWin32HandleInfoKHR(); 3510 void initialize(const VkMemoryGetWin32HandleInfoKHR* in_struct); 3511 void initialize(const safe_VkMemoryGetWin32HandleInfoKHR* copy_src); ptrsafe_VkMemoryGetWin32HandleInfoKHR3512 VkMemoryGetWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkMemoryGetWin32HandleInfoKHR *>(this); } ptrsafe_VkMemoryGetWin32HandleInfoKHR3513 VkMemoryGetWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkMemoryGetWin32HandleInfoKHR const *>(this); } 3514 }; 3515 #endif // VK_USE_PLATFORM_WIN32_KHR 3516 3517 struct safe_VkImportMemoryFdInfoKHR { 3518 VkStructureType sType; 3519 const void* pNext; 3520 VkExternalMemoryHandleTypeFlagBits handleType; 3521 int fd; 3522 safe_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR* in_struct); 3523 safe_VkImportMemoryFdInfoKHR(const safe_VkImportMemoryFdInfoKHR& copy_src); 3524 safe_VkImportMemoryFdInfoKHR& operator=(const safe_VkImportMemoryFdInfoKHR& copy_src); 3525 safe_VkImportMemoryFdInfoKHR(); 3526 ~safe_VkImportMemoryFdInfoKHR(); 3527 void initialize(const VkImportMemoryFdInfoKHR* in_struct); 3528 void initialize(const safe_VkImportMemoryFdInfoKHR* copy_src); ptrsafe_VkImportMemoryFdInfoKHR3529 VkImportMemoryFdInfoKHR *ptr() { return reinterpret_cast<VkImportMemoryFdInfoKHR *>(this); } ptrsafe_VkImportMemoryFdInfoKHR3530 VkImportMemoryFdInfoKHR const *ptr() const { return reinterpret_cast<VkImportMemoryFdInfoKHR const *>(this); } 3531 }; 3532 3533 struct safe_VkMemoryFdPropertiesKHR { 3534 VkStructureType sType; 3535 void* pNext; 3536 uint32_t memoryTypeBits; 3537 safe_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR* in_struct); 3538 safe_VkMemoryFdPropertiesKHR(const safe_VkMemoryFdPropertiesKHR& copy_src); 3539 safe_VkMemoryFdPropertiesKHR& operator=(const safe_VkMemoryFdPropertiesKHR& copy_src); 3540 safe_VkMemoryFdPropertiesKHR(); 3541 ~safe_VkMemoryFdPropertiesKHR(); 3542 void initialize(const VkMemoryFdPropertiesKHR* in_struct); 3543 void initialize(const safe_VkMemoryFdPropertiesKHR* copy_src); ptrsafe_VkMemoryFdPropertiesKHR3544 VkMemoryFdPropertiesKHR *ptr() { return reinterpret_cast<VkMemoryFdPropertiesKHR *>(this); } ptrsafe_VkMemoryFdPropertiesKHR3545 VkMemoryFdPropertiesKHR const *ptr() const { return reinterpret_cast<VkMemoryFdPropertiesKHR const *>(this); } 3546 }; 3547 3548 struct safe_VkMemoryGetFdInfoKHR { 3549 VkStructureType sType; 3550 const void* pNext; 3551 VkDeviceMemory memory; 3552 VkExternalMemoryHandleTypeFlagBits handleType; 3553 safe_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR* in_struct); 3554 safe_VkMemoryGetFdInfoKHR(const safe_VkMemoryGetFdInfoKHR& copy_src); 3555 safe_VkMemoryGetFdInfoKHR& operator=(const safe_VkMemoryGetFdInfoKHR& copy_src); 3556 safe_VkMemoryGetFdInfoKHR(); 3557 ~safe_VkMemoryGetFdInfoKHR(); 3558 void initialize(const VkMemoryGetFdInfoKHR* in_struct); 3559 void initialize(const safe_VkMemoryGetFdInfoKHR* copy_src); ptrsafe_VkMemoryGetFdInfoKHR3560 VkMemoryGetFdInfoKHR *ptr() { return reinterpret_cast<VkMemoryGetFdInfoKHR *>(this); } ptrsafe_VkMemoryGetFdInfoKHR3561 VkMemoryGetFdInfoKHR const *ptr() const { return reinterpret_cast<VkMemoryGetFdInfoKHR const *>(this); } 3562 }; 3563 3564 #ifdef VK_USE_PLATFORM_WIN32_KHR 3565 struct safe_VkWin32KeyedMutexAcquireReleaseInfoKHR { 3566 VkStructureType sType; 3567 const void* pNext; 3568 uint32_t acquireCount; 3569 VkDeviceMemory* pAcquireSyncs; 3570 const uint64_t* pAcquireKeys; 3571 const uint32_t* pAcquireTimeouts; 3572 uint32_t releaseCount; 3573 VkDeviceMemory* pReleaseSyncs; 3574 const uint64_t* pReleaseKeys; 3575 safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct); 3576 safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src); 3577 safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& operator=(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src); 3578 safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(); 3579 ~safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(); 3580 void initialize(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct); 3581 void initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR* copy_src); ptrsafe_VkWin32KeyedMutexAcquireReleaseInfoKHR3582 VkWin32KeyedMutexAcquireReleaseInfoKHR *ptr() { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR *>(this); } ptrsafe_VkWin32KeyedMutexAcquireReleaseInfoKHR3583 VkWin32KeyedMutexAcquireReleaseInfoKHR const *ptr() const { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR const *>(this); } 3584 }; 3585 #endif // VK_USE_PLATFORM_WIN32_KHR 3586 3587 #ifdef VK_USE_PLATFORM_WIN32_KHR 3588 struct safe_VkImportSemaphoreWin32HandleInfoKHR { 3589 VkStructureType sType; 3590 const void* pNext; 3591 VkSemaphore semaphore; 3592 VkSemaphoreImportFlags flags; 3593 VkExternalSemaphoreHandleTypeFlagBits handleType; 3594 HANDLE handle; 3595 LPCWSTR name; 3596 safe_VkImportSemaphoreWin32HandleInfoKHR(const VkImportSemaphoreWin32HandleInfoKHR* in_struct); 3597 safe_VkImportSemaphoreWin32HandleInfoKHR(const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src); 3598 safe_VkImportSemaphoreWin32HandleInfoKHR& operator=(const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src); 3599 safe_VkImportSemaphoreWin32HandleInfoKHR(); 3600 ~safe_VkImportSemaphoreWin32HandleInfoKHR(); 3601 void initialize(const VkImportSemaphoreWin32HandleInfoKHR* in_struct); 3602 void initialize(const safe_VkImportSemaphoreWin32HandleInfoKHR* copy_src); ptrsafe_VkImportSemaphoreWin32HandleInfoKHR3603 VkImportSemaphoreWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR *>(this); } ptrsafe_VkImportSemaphoreWin32HandleInfoKHR3604 VkImportSemaphoreWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR const *>(this); } 3605 }; 3606 #endif // VK_USE_PLATFORM_WIN32_KHR 3607 3608 #ifdef VK_USE_PLATFORM_WIN32_KHR 3609 struct safe_VkExportSemaphoreWin32HandleInfoKHR { 3610 VkStructureType sType; 3611 const void* pNext; 3612 const SECURITY_ATTRIBUTES* pAttributes; 3613 DWORD dwAccess; 3614 LPCWSTR name; 3615 safe_VkExportSemaphoreWin32HandleInfoKHR(const VkExportSemaphoreWin32HandleInfoKHR* in_struct); 3616 safe_VkExportSemaphoreWin32HandleInfoKHR(const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src); 3617 safe_VkExportSemaphoreWin32HandleInfoKHR& operator=(const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src); 3618 safe_VkExportSemaphoreWin32HandleInfoKHR(); 3619 ~safe_VkExportSemaphoreWin32HandleInfoKHR(); 3620 void initialize(const VkExportSemaphoreWin32HandleInfoKHR* in_struct); 3621 void initialize(const safe_VkExportSemaphoreWin32HandleInfoKHR* copy_src); ptrsafe_VkExportSemaphoreWin32HandleInfoKHR3622 VkExportSemaphoreWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR *>(this); } ptrsafe_VkExportSemaphoreWin32HandleInfoKHR3623 VkExportSemaphoreWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR const *>(this); } 3624 }; 3625 #endif // VK_USE_PLATFORM_WIN32_KHR 3626 3627 #ifdef VK_USE_PLATFORM_WIN32_KHR 3628 struct safe_VkD3D12FenceSubmitInfoKHR { 3629 VkStructureType sType; 3630 const void* pNext; 3631 uint32_t waitSemaphoreValuesCount; 3632 const uint64_t* pWaitSemaphoreValues; 3633 uint32_t signalSemaphoreValuesCount; 3634 const uint64_t* pSignalSemaphoreValues; 3635 safe_VkD3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR* in_struct); 3636 safe_VkD3D12FenceSubmitInfoKHR(const safe_VkD3D12FenceSubmitInfoKHR& copy_src); 3637 safe_VkD3D12FenceSubmitInfoKHR& operator=(const safe_VkD3D12FenceSubmitInfoKHR& copy_src); 3638 safe_VkD3D12FenceSubmitInfoKHR(); 3639 ~safe_VkD3D12FenceSubmitInfoKHR(); 3640 void initialize(const VkD3D12FenceSubmitInfoKHR* in_struct); 3641 void initialize(const safe_VkD3D12FenceSubmitInfoKHR* copy_src); ptrsafe_VkD3D12FenceSubmitInfoKHR3642 VkD3D12FenceSubmitInfoKHR *ptr() { return reinterpret_cast<VkD3D12FenceSubmitInfoKHR *>(this); } ptrsafe_VkD3D12FenceSubmitInfoKHR3643 VkD3D12FenceSubmitInfoKHR const *ptr() const { return reinterpret_cast<VkD3D12FenceSubmitInfoKHR const *>(this); } 3644 }; 3645 #endif // VK_USE_PLATFORM_WIN32_KHR 3646 3647 #ifdef VK_USE_PLATFORM_WIN32_KHR 3648 struct safe_VkSemaphoreGetWin32HandleInfoKHR { 3649 VkStructureType sType; 3650 const void* pNext; 3651 VkSemaphore semaphore; 3652 VkExternalSemaphoreHandleTypeFlagBits handleType; 3653 safe_VkSemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR* in_struct); 3654 safe_VkSemaphoreGetWin32HandleInfoKHR(const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src); 3655 safe_VkSemaphoreGetWin32HandleInfoKHR& operator=(const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src); 3656 safe_VkSemaphoreGetWin32HandleInfoKHR(); 3657 ~safe_VkSemaphoreGetWin32HandleInfoKHR(); 3658 void initialize(const VkSemaphoreGetWin32HandleInfoKHR* in_struct); 3659 void initialize(const safe_VkSemaphoreGetWin32HandleInfoKHR* copy_src); ptrsafe_VkSemaphoreGetWin32HandleInfoKHR3660 VkSemaphoreGetWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR *>(this); } ptrsafe_VkSemaphoreGetWin32HandleInfoKHR3661 VkSemaphoreGetWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR const *>(this); } 3662 }; 3663 #endif // VK_USE_PLATFORM_WIN32_KHR 3664 3665 struct safe_VkImportSemaphoreFdInfoKHR { 3666 VkStructureType sType; 3667 const void* pNext; 3668 VkSemaphore semaphore; 3669 VkSemaphoreImportFlags flags; 3670 VkExternalSemaphoreHandleTypeFlagBits handleType; 3671 int fd; 3672 safe_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR* in_struct); 3673 safe_VkImportSemaphoreFdInfoKHR(const safe_VkImportSemaphoreFdInfoKHR& copy_src); 3674 safe_VkImportSemaphoreFdInfoKHR& operator=(const safe_VkImportSemaphoreFdInfoKHR& copy_src); 3675 safe_VkImportSemaphoreFdInfoKHR(); 3676 ~safe_VkImportSemaphoreFdInfoKHR(); 3677 void initialize(const VkImportSemaphoreFdInfoKHR* in_struct); 3678 void initialize(const safe_VkImportSemaphoreFdInfoKHR* copy_src); ptrsafe_VkImportSemaphoreFdInfoKHR3679 VkImportSemaphoreFdInfoKHR *ptr() { return reinterpret_cast<VkImportSemaphoreFdInfoKHR *>(this); } ptrsafe_VkImportSemaphoreFdInfoKHR3680 VkImportSemaphoreFdInfoKHR const *ptr() const { return reinterpret_cast<VkImportSemaphoreFdInfoKHR const *>(this); } 3681 }; 3682 3683 struct safe_VkSemaphoreGetFdInfoKHR { 3684 VkStructureType sType; 3685 const void* pNext; 3686 VkSemaphore semaphore; 3687 VkExternalSemaphoreHandleTypeFlagBits handleType; 3688 safe_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR* in_struct); 3689 safe_VkSemaphoreGetFdInfoKHR(const safe_VkSemaphoreGetFdInfoKHR& copy_src); 3690 safe_VkSemaphoreGetFdInfoKHR& operator=(const safe_VkSemaphoreGetFdInfoKHR& copy_src); 3691 safe_VkSemaphoreGetFdInfoKHR(); 3692 ~safe_VkSemaphoreGetFdInfoKHR(); 3693 void initialize(const VkSemaphoreGetFdInfoKHR* in_struct); 3694 void initialize(const safe_VkSemaphoreGetFdInfoKHR* copy_src); ptrsafe_VkSemaphoreGetFdInfoKHR3695 VkSemaphoreGetFdInfoKHR *ptr() { return reinterpret_cast<VkSemaphoreGetFdInfoKHR *>(this); } ptrsafe_VkSemaphoreGetFdInfoKHR3696 VkSemaphoreGetFdInfoKHR const *ptr() const { return reinterpret_cast<VkSemaphoreGetFdInfoKHR const *>(this); } 3697 }; 3698 3699 struct safe_VkPhysicalDevicePushDescriptorPropertiesKHR { 3700 VkStructureType sType; 3701 void* pNext; 3702 uint32_t maxPushDescriptors; 3703 safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct); 3704 safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src); 3705 safe_VkPhysicalDevicePushDescriptorPropertiesKHR& operator=(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src); 3706 safe_VkPhysicalDevicePushDescriptorPropertiesKHR(); 3707 ~safe_VkPhysicalDevicePushDescriptorPropertiesKHR(); 3708 void initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct); 3709 void initialize(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR* copy_src); ptrsafe_VkPhysicalDevicePushDescriptorPropertiesKHR3710 VkPhysicalDevicePushDescriptorPropertiesKHR *ptr() { return reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR *>(this); } ptrsafe_VkPhysicalDevicePushDescriptorPropertiesKHR3711 VkPhysicalDevicePushDescriptorPropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR const *>(this); } 3712 }; 3713 3714 struct safe_VkPresentRegionKHR { 3715 uint32_t rectangleCount; 3716 const VkRectLayerKHR* pRectangles; 3717 safe_VkPresentRegionKHR(const VkPresentRegionKHR* in_struct); 3718 safe_VkPresentRegionKHR(const safe_VkPresentRegionKHR& copy_src); 3719 safe_VkPresentRegionKHR& operator=(const safe_VkPresentRegionKHR& copy_src); 3720 safe_VkPresentRegionKHR(); 3721 ~safe_VkPresentRegionKHR(); 3722 void initialize(const VkPresentRegionKHR* in_struct); 3723 void initialize(const safe_VkPresentRegionKHR* copy_src); ptrsafe_VkPresentRegionKHR3724 VkPresentRegionKHR *ptr() { return reinterpret_cast<VkPresentRegionKHR *>(this); } ptrsafe_VkPresentRegionKHR3725 VkPresentRegionKHR const *ptr() const { return reinterpret_cast<VkPresentRegionKHR const *>(this); } 3726 }; 3727 3728 struct safe_VkPresentRegionsKHR { 3729 VkStructureType sType; 3730 const void* pNext; 3731 uint32_t swapchainCount; 3732 safe_VkPresentRegionKHR* pRegions; 3733 safe_VkPresentRegionsKHR(const VkPresentRegionsKHR* in_struct); 3734 safe_VkPresentRegionsKHR(const safe_VkPresentRegionsKHR& copy_src); 3735 safe_VkPresentRegionsKHR& operator=(const safe_VkPresentRegionsKHR& copy_src); 3736 safe_VkPresentRegionsKHR(); 3737 ~safe_VkPresentRegionsKHR(); 3738 void initialize(const VkPresentRegionsKHR* in_struct); 3739 void initialize(const safe_VkPresentRegionsKHR* copy_src); ptrsafe_VkPresentRegionsKHR3740 VkPresentRegionsKHR *ptr() { return reinterpret_cast<VkPresentRegionsKHR *>(this); } ptrsafe_VkPresentRegionsKHR3741 VkPresentRegionsKHR const *ptr() const { return reinterpret_cast<VkPresentRegionsKHR const *>(this); } 3742 }; 3743 3744 struct safe_VkSharedPresentSurfaceCapabilitiesKHR { 3745 VkStructureType sType; 3746 void* pNext; 3747 VkImageUsageFlags sharedPresentSupportedUsageFlags; 3748 safe_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct); 3749 safe_VkSharedPresentSurfaceCapabilitiesKHR(const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src); 3750 safe_VkSharedPresentSurfaceCapabilitiesKHR& operator=(const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src); 3751 safe_VkSharedPresentSurfaceCapabilitiesKHR(); 3752 ~safe_VkSharedPresentSurfaceCapabilitiesKHR(); 3753 void initialize(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct); 3754 void initialize(const safe_VkSharedPresentSurfaceCapabilitiesKHR* copy_src); ptrsafe_VkSharedPresentSurfaceCapabilitiesKHR3755 VkSharedPresentSurfaceCapabilitiesKHR *ptr() { return reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR *>(this); } ptrsafe_VkSharedPresentSurfaceCapabilitiesKHR3756 VkSharedPresentSurfaceCapabilitiesKHR const *ptr() const { return reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR const *>(this); } 3757 }; 3758 3759 #ifdef VK_USE_PLATFORM_WIN32_KHR 3760 struct safe_VkImportFenceWin32HandleInfoKHR { 3761 VkStructureType sType; 3762 const void* pNext; 3763 VkFence fence; 3764 VkFenceImportFlags flags; 3765 VkExternalFenceHandleTypeFlagBits handleType; 3766 HANDLE handle; 3767 LPCWSTR name; 3768 safe_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR* in_struct); 3769 safe_VkImportFenceWin32HandleInfoKHR(const safe_VkImportFenceWin32HandleInfoKHR& copy_src); 3770 safe_VkImportFenceWin32HandleInfoKHR& operator=(const safe_VkImportFenceWin32HandleInfoKHR& copy_src); 3771 safe_VkImportFenceWin32HandleInfoKHR(); 3772 ~safe_VkImportFenceWin32HandleInfoKHR(); 3773 void initialize(const VkImportFenceWin32HandleInfoKHR* in_struct); 3774 void initialize(const safe_VkImportFenceWin32HandleInfoKHR* copy_src); ptrsafe_VkImportFenceWin32HandleInfoKHR3775 VkImportFenceWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkImportFenceWin32HandleInfoKHR *>(this); } ptrsafe_VkImportFenceWin32HandleInfoKHR3776 VkImportFenceWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkImportFenceWin32HandleInfoKHR const *>(this); } 3777 }; 3778 #endif // VK_USE_PLATFORM_WIN32_KHR 3779 3780 #ifdef VK_USE_PLATFORM_WIN32_KHR 3781 struct safe_VkExportFenceWin32HandleInfoKHR { 3782 VkStructureType sType; 3783 const void* pNext; 3784 const SECURITY_ATTRIBUTES* pAttributes; 3785 DWORD dwAccess; 3786 LPCWSTR name; 3787 safe_VkExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR* in_struct); 3788 safe_VkExportFenceWin32HandleInfoKHR(const safe_VkExportFenceWin32HandleInfoKHR& copy_src); 3789 safe_VkExportFenceWin32HandleInfoKHR& operator=(const safe_VkExportFenceWin32HandleInfoKHR& copy_src); 3790 safe_VkExportFenceWin32HandleInfoKHR(); 3791 ~safe_VkExportFenceWin32HandleInfoKHR(); 3792 void initialize(const VkExportFenceWin32HandleInfoKHR* in_struct); 3793 void initialize(const safe_VkExportFenceWin32HandleInfoKHR* copy_src); ptrsafe_VkExportFenceWin32HandleInfoKHR3794 VkExportFenceWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkExportFenceWin32HandleInfoKHR *>(this); } ptrsafe_VkExportFenceWin32HandleInfoKHR3795 VkExportFenceWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkExportFenceWin32HandleInfoKHR const *>(this); } 3796 }; 3797 #endif // VK_USE_PLATFORM_WIN32_KHR 3798 3799 #ifdef VK_USE_PLATFORM_WIN32_KHR 3800 struct safe_VkFenceGetWin32HandleInfoKHR { 3801 VkStructureType sType; 3802 const void* pNext; 3803 VkFence fence; 3804 VkExternalFenceHandleTypeFlagBits handleType; 3805 safe_VkFenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR* in_struct); 3806 safe_VkFenceGetWin32HandleInfoKHR(const safe_VkFenceGetWin32HandleInfoKHR& copy_src); 3807 safe_VkFenceGetWin32HandleInfoKHR& operator=(const safe_VkFenceGetWin32HandleInfoKHR& copy_src); 3808 safe_VkFenceGetWin32HandleInfoKHR(); 3809 ~safe_VkFenceGetWin32HandleInfoKHR(); 3810 void initialize(const VkFenceGetWin32HandleInfoKHR* in_struct); 3811 void initialize(const safe_VkFenceGetWin32HandleInfoKHR* copy_src); ptrsafe_VkFenceGetWin32HandleInfoKHR3812 VkFenceGetWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkFenceGetWin32HandleInfoKHR *>(this); } ptrsafe_VkFenceGetWin32HandleInfoKHR3813 VkFenceGetWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkFenceGetWin32HandleInfoKHR const *>(this); } 3814 }; 3815 #endif // VK_USE_PLATFORM_WIN32_KHR 3816 3817 struct safe_VkImportFenceFdInfoKHR { 3818 VkStructureType sType; 3819 const void* pNext; 3820 VkFence fence; 3821 VkFenceImportFlags flags; 3822 VkExternalFenceHandleTypeFlagBits handleType; 3823 int fd; 3824 safe_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR* in_struct); 3825 safe_VkImportFenceFdInfoKHR(const safe_VkImportFenceFdInfoKHR& copy_src); 3826 safe_VkImportFenceFdInfoKHR& operator=(const safe_VkImportFenceFdInfoKHR& copy_src); 3827 safe_VkImportFenceFdInfoKHR(); 3828 ~safe_VkImportFenceFdInfoKHR(); 3829 void initialize(const VkImportFenceFdInfoKHR* in_struct); 3830 void initialize(const safe_VkImportFenceFdInfoKHR* copy_src); ptrsafe_VkImportFenceFdInfoKHR3831 VkImportFenceFdInfoKHR *ptr() { return reinterpret_cast<VkImportFenceFdInfoKHR *>(this); } ptrsafe_VkImportFenceFdInfoKHR3832 VkImportFenceFdInfoKHR const *ptr() const { return reinterpret_cast<VkImportFenceFdInfoKHR const *>(this); } 3833 }; 3834 3835 struct safe_VkFenceGetFdInfoKHR { 3836 VkStructureType sType; 3837 const void* pNext; 3838 VkFence fence; 3839 VkExternalFenceHandleTypeFlagBits handleType; 3840 safe_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR* in_struct); 3841 safe_VkFenceGetFdInfoKHR(const safe_VkFenceGetFdInfoKHR& copy_src); 3842 safe_VkFenceGetFdInfoKHR& operator=(const safe_VkFenceGetFdInfoKHR& copy_src); 3843 safe_VkFenceGetFdInfoKHR(); 3844 ~safe_VkFenceGetFdInfoKHR(); 3845 void initialize(const VkFenceGetFdInfoKHR* in_struct); 3846 void initialize(const safe_VkFenceGetFdInfoKHR* copy_src); ptrsafe_VkFenceGetFdInfoKHR3847 VkFenceGetFdInfoKHR *ptr() { return reinterpret_cast<VkFenceGetFdInfoKHR *>(this); } ptrsafe_VkFenceGetFdInfoKHR3848 VkFenceGetFdInfoKHR const *ptr() const { return reinterpret_cast<VkFenceGetFdInfoKHR const *>(this); } 3849 }; 3850 3851 struct safe_VkPhysicalDevicePerformanceQueryFeaturesKHR { 3852 VkStructureType sType; 3853 void* pNext; 3854 VkBool32 performanceCounterQueryPools; 3855 VkBool32 performanceCounterMultipleQueryPools; 3856 safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct); 3857 safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src); 3858 safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& operator=(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src); 3859 safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(); 3860 ~safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(); 3861 void initialize(const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct); 3862 void initialize(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR* copy_src); ptrsafe_VkPhysicalDevicePerformanceQueryFeaturesKHR3863 VkPhysicalDevicePerformanceQueryFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR *>(this); } ptrsafe_VkPhysicalDevicePerformanceQueryFeaturesKHR3864 VkPhysicalDevicePerformanceQueryFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR const *>(this); } 3865 }; 3866 3867 struct safe_VkPhysicalDevicePerformanceQueryPropertiesKHR { 3868 VkStructureType sType; 3869 void* pNext; 3870 VkBool32 allowCommandBufferQueryCopies; 3871 safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct); 3872 safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src); 3873 safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& operator=(const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src); 3874 safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(); 3875 ~safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(); 3876 void initialize(const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct); 3877 void initialize(const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR* copy_src); ptrsafe_VkPhysicalDevicePerformanceQueryPropertiesKHR3878 VkPhysicalDevicePerformanceQueryPropertiesKHR *ptr() { return reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR *>(this); } ptrsafe_VkPhysicalDevicePerformanceQueryPropertiesKHR3879 VkPhysicalDevicePerformanceQueryPropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR const *>(this); } 3880 }; 3881 3882 struct safe_VkPerformanceCounterKHR { 3883 VkStructureType sType; 3884 const void* pNext; 3885 VkPerformanceCounterUnitKHR unit; 3886 VkPerformanceCounterScopeKHR scope; 3887 VkPerformanceCounterStorageKHR storage; 3888 uint8_t uuid[VK_UUID_SIZE]; 3889 safe_VkPerformanceCounterKHR(const VkPerformanceCounterKHR* in_struct); 3890 safe_VkPerformanceCounterKHR(const safe_VkPerformanceCounterKHR& copy_src); 3891 safe_VkPerformanceCounterKHR& operator=(const safe_VkPerformanceCounterKHR& copy_src); 3892 safe_VkPerformanceCounterKHR(); 3893 ~safe_VkPerformanceCounterKHR(); 3894 void initialize(const VkPerformanceCounterKHR* in_struct); 3895 void initialize(const safe_VkPerformanceCounterKHR* copy_src); ptrsafe_VkPerformanceCounterKHR3896 VkPerformanceCounterKHR *ptr() { return reinterpret_cast<VkPerformanceCounterKHR *>(this); } ptrsafe_VkPerformanceCounterKHR3897 VkPerformanceCounterKHR const *ptr() const { return reinterpret_cast<VkPerformanceCounterKHR const *>(this); } 3898 }; 3899 3900 struct safe_VkPerformanceCounterDescriptionKHR { 3901 VkStructureType sType; 3902 const void* pNext; 3903 VkPerformanceCounterDescriptionFlagsKHR flags; 3904 char name[VK_MAX_DESCRIPTION_SIZE]; 3905 char category[VK_MAX_DESCRIPTION_SIZE]; 3906 char description[VK_MAX_DESCRIPTION_SIZE]; 3907 safe_VkPerformanceCounterDescriptionKHR(const VkPerformanceCounterDescriptionKHR* in_struct); 3908 safe_VkPerformanceCounterDescriptionKHR(const safe_VkPerformanceCounterDescriptionKHR& copy_src); 3909 safe_VkPerformanceCounterDescriptionKHR& operator=(const safe_VkPerformanceCounterDescriptionKHR& copy_src); 3910 safe_VkPerformanceCounterDescriptionKHR(); 3911 ~safe_VkPerformanceCounterDescriptionKHR(); 3912 void initialize(const VkPerformanceCounterDescriptionKHR* in_struct); 3913 void initialize(const safe_VkPerformanceCounterDescriptionKHR* copy_src); ptrsafe_VkPerformanceCounterDescriptionKHR3914 VkPerformanceCounterDescriptionKHR *ptr() { return reinterpret_cast<VkPerformanceCounterDescriptionKHR *>(this); } ptrsafe_VkPerformanceCounterDescriptionKHR3915 VkPerformanceCounterDescriptionKHR const *ptr() const { return reinterpret_cast<VkPerformanceCounterDescriptionKHR const *>(this); } 3916 }; 3917 3918 struct safe_VkQueryPoolPerformanceCreateInfoKHR { 3919 VkStructureType sType; 3920 const void* pNext; 3921 uint32_t queueFamilyIndex; 3922 uint32_t counterIndexCount; 3923 const uint32_t* pCounterIndices; 3924 safe_VkQueryPoolPerformanceCreateInfoKHR(const VkQueryPoolPerformanceCreateInfoKHR* in_struct); 3925 safe_VkQueryPoolPerformanceCreateInfoKHR(const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src); 3926 safe_VkQueryPoolPerformanceCreateInfoKHR& operator=(const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src); 3927 safe_VkQueryPoolPerformanceCreateInfoKHR(); 3928 ~safe_VkQueryPoolPerformanceCreateInfoKHR(); 3929 void initialize(const VkQueryPoolPerformanceCreateInfoKHR* in_struct); 3930 void initialize(const safe_VkQueryPoolPerformanceCreateInfoKHR* copy_src); ptrsafe_VkQueryPoolPerformanceCreateInfoKHR3931 VkQueryPoolPerformanceCreateInfoKHR *ptr() { return reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR *>(this); } ptrsafe_VkQueryPoolPerformanceCreateInfoKHR3932 VkQueryPoolPerformanceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR const *>(this); } 3933 }; 3934 3935 struct safe_VkAcquireProfilingLockInfoKHR { 3936 VkStructureType sType; 3937 const void* pNext; 3938 VkAcquireProfilingLockFlagsKHR flags; 3939 uint64_t timeout; 3940 safe_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR* in_struct); 3941 safe_VkAcquireProfilingLockInfoKHR(const safe_VkAcquireProfilingLockInfoKHR& copy_src); 3942 safe_VkAcquireProfilingLockInfoKHR& operator=(const safe_VkAcquireProfilingLockInfoKHR& copy_src); 3943 safe_VkAcquireProfilingLockInfoKHR(); 3944 ~safe_VkAcquireProfilingLockInfoKHR(); 3945 void initialize(const VkAcquireProfilingLockInfoKHR* in_struct); 3946 void initialize(const safe_VkAcquireProfilingLockInfoKHR* copy_src); ptrsafe_VkAcquireProfilingLockInfoKHR3947 VkAcquireProfilingLockInfoKHR *ptr() { return reinterpret_cast<VkAcquireProfilingLockInfoKHR *>(this); } ptrsafe_VkAcquireProfilingLockInfoKHR3948 VkAcquireProfilingLockInfoKHR const *ptr() const { return reinterpret_cast<VkAcquireProfilingLockInfoKHR const *>(this); } 3949 }; 3950 3951 struct safe_VkPerformanceQuerySubmitInfoKHR { 3952 VkStructureType sType; 3953 const void* pNext; 3954 uint32_t counterPassIndex; 3955 safe_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR* in_struct); 3956 safe_VkPerformanceQuerySubmitInfoKHR(const safe_VkPerformanceQuerySubmitInfoKHR& copy_src); 3957 safe_VkPerformanceQuerySubmitInfoKHR& operator=(const safe_VkPerformanceQuerySubmitInfoKHR& copy_src); 3958 safe_VkPerformanceQuerySubmitInfoKHR(); 3959 ~safe_VkPerformanceQuerySubmitInfoKHR(); 3960 void initialize(const VkPerformanceQuerySubmitInfoKHR* in_struct); 3961 void initialize(const safe_VkPerformanceQuerySubmitInfoKHR* copy_src); ptrsafe_VkPerformanceQuerySubmitInfoKHR3962 VkPerformanceQuerySubmitInfoKHR *ptr() { return reinterpret_cast<VkPerformanceQuerySubmitInfoKHR *>(this); } ptrsafe_VkPerformanceQuerySubmitInfoKHR3963 VkPerformanceQuerySubmitInfoKHR const *ptr() const { return reinterpret_cast<VkPerformanceQuerySubmitInfoKHR const *>(this); } 3964 }; 3965 3966 struct safe_VkPhysicalDeviceSurfaceInfo2KHR { 3967 VkStructureType sType; 3968 const void* pNext; 3969 VkSurfaceKHR surface; 3970 safe_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct); 3971 safe_VkPhysicalDeviceSurfaceInfo2KHR(const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src); 3972 safe_VkPhysicalDeviceSurfaceInfo2KHR& operator=(const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src); 3973 safe_VkPhysicalDeviceSurfaceInfo2KHR(); 3974 ~safe_VkPhysicalDeviceSurfaceInfo2KHR(); 3975 void initialize(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct); 3976 void initialize(const safe_VkPhysicalDeviceSurfaceInfo2KHR* copy_src); ptrsafe_VkPhysicalDeviceSurfaceInfo2KHR3977 VkPhysicalDeviceSurfaceInfo2KHR *ptr() { return reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR *>(this); } ptrsafe_VkPhysicalDeviceSurfaceInfo2KHR3978 VkPhysicalDeviceSurfaceInfo2KHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR const *>(this); } 3979 }; 3980 3981 struct safe_VkSurfaceCapabilities2KHR { 3982 VkStructureType sType; 3983 void* pNext; 3984 VkSurfaceCapabilitiesKHR surfaceCapabilities; 3985 safe_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR* in_struct); 3986 safe_VkSurfaceCapabilities2KHR(const safe_VkSurfaceCapabilities2KHR& copy_src); 3987 safe_VkSurfaceCapabilities2KHR& operator=(const safe_VkSurfaceCapabilities2KHR& copy_src); 3988 safe_VkSurfaceCapabilities2KHR(); 3989 ~safe_VkSurfaceCapabilities2KHR(); 3990 void initialize(const VkSurfaceCapabilities2KHR* in_struct); 3991 void initialize(const safe_VkSurfaceCapabilities2KHR* copy_src); ptrsafe_VkSurfaceCapabilities2KHR3992 VkSurfaceCapabilities2KHR *ptr() { return reinterpret_cast<VkSurfaceCapabilities2KHR *>(this); } ptrsafe_VkSurfaceCapabilities2KHR3993 VkSurfaceCapabilities2KHR const *ptr() const { return reinterpret_cast<VkSurfaceCapabilities2KHR const *>(this); } 3994 }; 3995 3996 struct safe_VkSurfaceFormat2KHR { 3997 VkStructureType sType; 3998 void* pNext; 3999 VkSurfaceFormatKHR surfaceFormat; 4000 safe_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR* in_struct); 4001 safe_VkSurfaceFormat2KHR(const safe_VkSurfaceFormat2KHR& copy_src); 4002 safe_VkSurfaceFormat2KHR& operator=(const safe_VkSurfaceFormat2KHR& copy_src); 4003 safe_VkSurfaceFormat2KHR(); 4004 ~safe_VkSurfaceFormat2KHR(); 4005 void initialize(const VkSurfaceFormat2KHR* in_struct); 4006 void initialize(const safe_VkSurfaceFormat2KHR* copy_src); ptrsafe_VkSurfaceFormat2KHR4007 VkSurfaceFormat2KHR *ptr() { return reinterpret_cast<VkSurfaceFormat2KHR *>(this); } ptrsafe_VkSurfaceFormat2KHR4008 VkSurfaceFormat2KHR const *ptr() const { return reinterpret_cast<VkSurfaceFormat2KHR const *>(this); } 4009 }; 4010 4011 struct safe_VkDisplayProperties2KHR { 4012 VkStructureType sType; 4013 void* pNext; 4014 safe_VkDisplayPropertiesKHR displayProperties; 4015 safe_VkDisplayProperties2KHR(const VkDisplayProperties2KHR* in_struct); 4016 safe_VkDisplayProperties2KHR(const safe_VkDisplayProperties2KHR& copy_src); 4017 safe_VkDisplayProperties2KHR& operator=(const safe_VkDisplayProperties2KHR& copy_src); 4018 safe_VkDisplayProperties2KHR(); 4019 ~safe_VkDisplayProperties2KHR(); 4020 void initialize(const VkDisplayProperties2KHR* in_struct); 4021 void initialize(const safe_VkDisplayProperties2KHR* copy_src); ptrsafe_VkDisplayProperties2KHR4022 VkDisplayProperties2KHR *ptr() { return reinterpret_cast<VkDisplayProperties2KHR *>(this); } ptrsafe_VkDisplayProperties2KHR4023 VkDisplayProperties2KHR const *ptr() const { return reinterpret_cast<VkDisplayProperties2KHR const *>(this); } 4024 }; 4025 4026 struct safe_VkDisplayPlaneProperties2KHR { 4027 VkStructureType sType; 4028 void* pNext; 4029 VkDisplayPlanePropertiesKHR displayPlaneProperties; 4030 safe_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR* in_struct); 4031 safe_VkDisplayPlaneProperties2KHR(const safe_VkDisplayPlaneProperties2KHR& copy_src); 4032 safe_VkDisplayPlaneProperties2KHR& operator=(const safe_VkDisplayPlaneProperties2KHR& copy_src); 4033 safe_VkDisplayPlaneProperties2KHR(); 4034 ~safe_VkDisplayPlaneProperties2KHR(); 4035 void initialize(const VkDisplayPlaneProperties2KHR* in_struct); 4036 void initialize(const safe_VkDisplayPlaneProperties2KHR* copy_src); ptrsafe_VkDisplayPlaneProperties2KHR4037 VkDisplayPlaneProperties2KHR *ptr() { return reinterpret_cast<VkDisplayPlaneProperties2KHR *>(this); } ptrsafe_VkDisplayPlaneProperties2KHR4038 VkDisplayPlaneProperties2KHR const *ptr() const { return reinterpret_cast<VkDisplayPlaneProperties2KHR const *>(this); } 4039 }; 4040 4041 struct safe_VkDisplayModeProperties2KHR { 4042 VkStructureType sType; 4043 void* pNext; 4044 VkDisplayModePropertiesKHR displayModeProperties; 4045 safe_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR* in_struct); 4046 safe_VkDisplayModeProperties2KHR(const safe_VkDisplayModeProperties2KHR& copy_src); 4047 safe_VkDisplayModeProperties2KHR& operator=(const safe_VkDisplayModeProperties2KHR& copy_src); 4048 safe_VkDisplayModeProperties2KHR(); 4049 ~safe_VkDisplayModeProperties2KHR(); 4050 void initialize(const VkDisplayModeProperties2KHR* in_struct); 4051 void initialize(const safe_VkDisplayModeProperties2KHR* copy_src); ptrsafe_VkDisplayModeProperties2KHR4052 VkDisplayModeProperties2KHR *ptr() { return reinterpret_cast<VkDisplayModeProperties2KHR *>(this); } ptrsafe_VkDisplayModeProperties2KHR4053 VkDisplayModeProperties2KHR const *ptr() const { return reinterpret_cast<VkDisplayModeProperties2KHR const *>(this); } 4054 }; 4055 4056 struct safe_VkDisplayPlaneInfo2KHR { 4057 VkStructureType sType; 4058 const void* pNext; 4059 VkDisplayModeKHR mode; 4060 uint32_t planeIndex; 4061 safe_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR* in_struct); 4062 safe_VkDisplayPlaneInfo2KHR(const safe_VkDisplayPlaneInfo2KHR& copy_src); 4063 safe_VkDisplayPlaneInfo2KHR& operator=(const safe_VkDisplayPlaneInfo2KHR& copy_src); 4064 safe_VkDisplayPlaneInfo2KHR(); 4065 ~safe_VkDisplayPlaneInfo2KHR(); 4066 void initialize(const VkDisplayPlaneInfo2KHR* in_struct); 4067 void initialize(const safe_VkDisplayPlaneInfo2KHR* copy_src); ptrsafe_VkDisplayPlaneInfo2KHR4068 VkDisplayPlaneInfo2KHR *ptr() { return reinterpret_cast<VkDisplayPlaneInfo2KHR *>(this); } ptrsafe_VkDisplayPlaneInfo2KHR4069 VkDisplayPlaneInfo2KHR const *ptr() const { return reinterpret_cast<VkDisplayPlaneInfo2KHR const *>(this); } 4070 }; 4071 4072 struct safe_VkDisplayPlaneCapabilities2KHR { 4073 VkStructureType sType; 4074 void* pNext; 4075 VkDisplayPlaneCapabilitiesKHR capabilities; 4076 safe_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR* in_struct); 4077 safe_VkDisplayPlaneCapabilities2KHR(const safe_VkDisplayPlaneCapabilities2KHR& copy_src); 4078 safe_VkDisplayPlaneCapabilities2KHR& operator=(const safe_VkDisplayPlaneCapabilities2KHR& copy_src); 4079 safe_VkDisplayPlaneCapabilities2KHR(); 4080 ~safe_VkDisplayPlaneCapabilities2KHR(); 4081 void initialize(const VkDisplayPlaneCapabilities2KHR* in_struct); 4082 void initialize(const safe_VkDisplayPlaneCapabilities2KHR* copy_src); ptrsafe_VkDisplayPlaneCapabilities2KHR4083 VkDisplayPlaneCapabilities2KHR *ptr() { return reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>(this); } ptrsafe_VkDisplayPlaneCapabilities2KHR4084 VkDisplayPlaneCapabilities2KHR const *ptr() const { return reinterpret_cast<VkDisplayPlaneCapabilities2KHR const *>(this); } 4085 }; 4086 4087 #ifdef VK_ENABLE_BETA_EXTENSIONS 4088 struct safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR { 4089 VkStructureType sType; 4090 void* pNext; 4091 VkBool32 constantAlphaColorBlendFactors; 4092 VkBool32 events; 4093 VkBool32 imageViewFormatReinterpretation; 4094 VkBool32 imageViewFormatSwizzle; 4095 VkBool32 imageView2DOn3DImage; 4096 VkBool32 multisampleArrayImage; 4097 VkBool32 mutableComparisonSamplers; 4098 VkBool32 pointPolygons; 4099 VkBool32 samplerMipLodBias; 4100 VkBool32 separateStencilMaskRef; 4101 VkBool32 shaderSampleRateInterpolationFunctions; 4102 VkBool32 tessellationIsolines; 4103 VkBool32 tessellationPointMode; 4104 VkBool32 triangleFans; 4105 VkBool32 vertexAttributeAccessBeyondStride; 4106 safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct); 4107 safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src); 4108 safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& operator=(const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src); 4109 safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(); 4110 ~safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(); 4111 void initialize(const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct); 4112 void initialize(const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR* copy_src); ptrsafe_VkPhysicalDevicePortabilitySubsetFeaturesKHR4113 VkPhysicalDevicePortabilitySubsetFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(this); } ptrsafe_VkPhysicalDevicePortabilitySubsetFeaturesKHR4114 VkPhysicalDevicePortabilitySubsetFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR const *>(this); } 4115 }; 4116 #endif // VK_ENABLE_BETA_EXTENSIONS 4117 4118 #ifdef VK_ENABLE_BETA_EXTENSIONS 4119 struct safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR { 4120 VkStructureType sType; 4121 void* pNext; 4122 uint32_t minVertexInputBindingStrideAlignment; 4123 safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct); 4124 safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src); 4125 safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& operator=(const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src); 4126 safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(); 4127 ~safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(); 4128 void initialize(const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct); 4129 void initialize(const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR* copy_src); ptrsafe_VkPhysicalDevicePortabilitySubsetPropertiesKHR4130 VkPhysicalDevicePortabilitySubsetPropertiesKHR *ptr() { return reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR *>(this); } ptrsafe_VkPhysicalDevicePortabilitySubsetPropertiesKHR4131 VkPhysicalDevicePortabilitySubsetPropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR const *>(this); } 4132 }; 4133 #endif // VK_ENABLE_BETA_EXTENSIONS 4134 4135 struct safe_VkPhysicalDeviceShaderClockFeaturesKHR { 4136 VkStructureType sType; 4137 void* pNext; 4138 VkBool32 shaderSubgroupClock; 4139 VkBool32 shaderDeviceClock; 4140 safe_VkPhysicalDeviceShaderClockFeaturesKHR(const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct); 4141 safe_VkPhysicalDeviceShaderClockFeaturesKHR(const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src); 4142 safe_VkPhysicalDeviceShaderClockFeaturesKHR& operator=(const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src); 4143 safe_VkPhysicalDeviceShaderClockFeaturesKHR(); 4144 ~safe_VkPhysicalDeviceShaderClockFeaturesKHR(); 4145 void initialize(const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct); 4146 void initialize(const safe_VkPhysicalDeviceShaderClockFeaturesKHR* copy_src); ptrsafe_VkPhysicalDeviceShaderClockFeaturesKHR4147 VkPhysicalDeviceShaderClockFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR *>(this); } ptrsafe_VkPhysicalDeviceShaderClockFeaturesKHR4148 VkPhysicalDeviceShaderClockFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR const *>(this); } 4149 }; 4150 4151 struct safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR { 4152 VkStructureType sType; 4153 void* pNext; 4154 VkBool32 shaderTerminateInvocation; 4155 safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* in_struct); 4156 safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(const safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR& copy_src); 4157 safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR& operator=(const safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR& copy_src); 4158 safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(); 4159 ~safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(); 4160 void initialize(const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* in_struct); 4161 void initialize(const safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* copy_src); ptrsafe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR4162 VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *>(this); } ptrsafe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR4163 VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR const *>(this); } 4164 }; 4165 4166 struct safe_VkFragmentShadingRateAttachmentInfoKHR { 4167 VkStructureType sType; 4168 const void* pNext; 4169 safe_VkAttachmentReference2* pFragmentShadingRateAttachment; 4170 VkExtent2D shadingRateAttachmentTexelSize; 4171 safe_VkFragmentShadingRateAttachmentInfoKHR(const VkFragmentShadingRateAttachmentInfoKHR* in_struct); 4172 safe_VkFragmentShadingRateAttachmentInfoKHR(const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src); 4173 safe_VkFragmentShadingRateAttachmentInfoKHR& operator=(const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src); 4174 safe_VkFragmentShadingRateAttachmentInfoKHR(); 4175 ~safe_VkFragmentShadingRateAttachmentInfoKHR(); 4176 void initialize(const VkFragmentShadingRateAttachmentInfoKHR* in_struct); 4177 void initialize(const safe_VkFragmentShadingRateAttachmentInfoKHR* copy_src); ptrsafe_VkFragmentShadingRateAttachmentInfoKHR4178 VkFragmentShadingRateAttachmentInfoKHR *ptr() { return reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR *>(this); } ptrsafe_VkFragmentShadingRateAttachmentInfoKHR4179 VkFragmentShadingRateAttachmentInfoKHR const *ptr() const { return reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR const *>(this); } 4180 }; 4181 4182 struct safe_VkPipelineFragmentShadingRateStateCreateInfoKHR { 4183 VkStructureType sType; 4184 const void* pNext; 4185 VkExtent2D fragmentSize; 4186 VkFragmentShadingRateCombinerOpKHR combinerOps[2]; 4187 safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct); 4188 safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src); 4189 safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& operator=(const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src); 4190 safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(); 4191 ~safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(); 4192 void initialize(const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct); 4193 void initialize(const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR* copy_src); ptrsafe_VkPipelineFragmentShadingRateStateCreateInfoKHR4194 VkPipelineFragmentShadingRateStateCreateInfoKHR *ptr() { return reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR *>(this); } ptrsafe_VkPipelineFragmentShadingRateStateCreateInfoKHR4195 VkPipelineFragmentShadingRateStateCreateInfoKHR const *ptr() const { return reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR const *>(this); } 4196 }; 4197 4198 struct safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR { 4199 VkStructureType sType; 4200 void* pNext; 4201 VkBool32 pipelineFragmentShadingRate; 4202 VkBool32 primitiveFragmentShadingRate; 4203 VkBool32 attachmentFragmentShadingRate; 4204 safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct); 4205 safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src); 4206 safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& operator=(const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src); 4207 safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(); 4208 ~safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(); 4209 void initialize(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct); 4210 void initialize(const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR* copy_src); ptrsafe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR4211 VkPhysicalDeviceFragmentShadingRateFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>(this); } ptrsafe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR4212 VkPhysicalDeviceFragmentShadingRateFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR const *>(this); } 4213 }; 4214 4215 struct safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR { 4216 VkStructureType sType; 4217 void* pNext; 4218 VkExtent2D minFragmentShadingRateAttachmentTexelSize; 4219 VkExtent2D maxFragmentShadingRateAttachmentTexelSize; 4220 uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio; 4221 VkBool32 primitiveFragmentShadingRateWithMultipleViewports; 4222 VkBool32 layeredShadingRateAttachments; 4223 VkBool32 fragmentShadingRateNonTrivialCombinerOps; 4224 VkExtent2D maxFragmentSize; 4225 uint32_t maxFragmentSizeAspectRatio; 4226 uint32_t maxFragmentShadingRateCoverageSamples; 4227 VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples; 4228 VkBool32 fragmentShadingRateWithShaderDepthStencilWrites; 4229 VkBool32 fragmentShadingRateWithSampleMask; 4230 VkBool32 fragmentShadingRateWithShaderSampleMask; 4231 VkBool32 fragmentShadingRateWithConservativeRasterization; 4232 VkBool32 fragmentShadingRateWithFragmentShaderInterlock; 4233 VkBool32 fragmentShadingRateWithCustomSampleLocations; 4234 VkBool32 fragmentShadingRateStrictMultiplyCombiner; 4235 safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct); 4236 safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src); 4237 safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& operator=(const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src); 4238 safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(); 4239 ~safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(); 4240 void initialize(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct); 4241 void initialize(const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR* copy_src); ptrsafe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR4242 VkPhysicalDeviceFragmentShadingRatePropertiesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR *>(this); } ptrsafe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR4243 VkPhysicalDeviceFragmentShadingRatePropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR const *>(this); } 4244 }; 4245 4246 struct safe_VkPhysicalDeviceFragmentShadingRateKHR { 4247 VkStructureType sType; 4248 void* pNext; 4249 VkSampleCountFlags sampleCounts; 4250 VkExtent2D fragmentSize; 4251 safe_VkPhysicalDeviceFragmentShadingRateKHR(const VkPhysicalDeviceFragmentShadingRateKHR* in_struct); 4252 safe_VkPhysicalDeviceFragmentShadingRateKHR(const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src); 4253 safe_VkPhysicalDeviceFragmentShadingRateKHR& operator=(const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src); 4254 safe_VkPhysicalDeviceFragmentShadingRateKHR(); 4255 ~safe_VkPhysicalDeviceFragmentShadingRateKHR(); 4256 void initialize(const VkPhysicalDeviceFragmentShadingRateKHR* in_struct); 4257 void initialize(const safe_VkPhysicalDeviceFragmentShadingRateKHR* copy_src); ptrsafe_VkPhysicalDeviceFragmentShadingRateKHR4258 VkPhysicalDeviceFragmentShadingRateKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>(this); } ptrsafe_VkPhysicalDeviceFragmentShadingRateKHR4259 VkPhysicalDeviceFragmentShadingRateKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR const *>(this); } 4260 }; 4261 4262 struct safe_VkSurfaceProtectedCapabilitiesKHR { 4263 VkStructureType sType; 4264 const void* pNext; 4265 VkBool32 supportsProtected; 4266 safe_VkSurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR* in_struct); 4267 safe_VkSurfaceProtectedCapabilitiesKHR(const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src); 4268 safe_VkSurfaceProtectedCapabilitiesKHR& operator=(const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src); 4269 safe_VkSurfaceProtectedCapabilitiesKHR(); 4270 ~safe_VkSurfaceProtectedCapabilitiesKHR(); 4271 void initialize(const VkSurfaceProtectedCapabilitiesKHR* in_struct); 4272 void initialize(const safe_VkSurfaceProtectedCapabilitiesKHR* copy_src); ptrsafe_VkSurfaceProtectedCapabilitiesKHR4273 VkSurfaceProtectedCapabilitiesKHR *ptr() { return reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR *>(this); } ptrsafe_VkSurfaceProtectedCapabilitiesKHR4274 VkSurfaceProtectedCapabilitiesKHR const *ptr() const { return reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR const *>(this); } 4275 }; 4276 4277 #ifdef VK_ENABLE_BETA_EXTENSIONS 4278 struct safe_VkDeferredOperationInfoKHR { 4279 VkStructureType sType; 4280 const void* pNext; 4281 VkDeferredOperationKHR operationHandle; 4282 safe_VkDeferredOperationInfoKHR(const VkDeferredOperationInfoKHR* in_struct); 4283 safe_VkDeferredOperationInfoKHR(const safe_VkDeferredOperationInfoKHR& copy_src); 4284 safe_VkDeferredOperationInfoKHR& operator=(const safe_VkDeferredOperationInfoKHR& copy_src); 4285 safe_VkDeferredOperationInfoKHR(); 4286 ~safe_VkDeferredOperationInfoKHR(); 4287 void initialize(const VkDeferredOperationInfoKHR* in_struct); 4288 void initialize(const safe_VkDeferredOperationInfoKHR* copy_src); ptrsafe_VkDeferredOperationInfoKHR4289 VkDeferredOperationInfoKHR *ptr() { return reinterpret_cast<VkDeferredOperationInfoKHR *>(this); } ptrsafe_VkDeferredOperationInfoKHR4290 VkDeferredOperationInfoKHR const *ptr() const { return reinterpret_cast<VkDeferredOperationInfoKHR const *>(this); } 4291 }; 4292 #endif // VK_ENABLE_BETA_EXTENSIONS 4293 4294 struct safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR { 4295 VkStructureType sType; 4296 void* pNext; 4297 VkBool32 pipelineExecutableInfo; 4298 safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct); 4299 safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src); 4300 safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src); 4301 safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(); 4302 ~safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(); 4303 void initialize(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct); 4304 void initialize(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* copy_src); ptrsafe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR4305 VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>(this); } ptrsafe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR4306 VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const *>(this); } 4307 }; 4308 4309 struct safe_VkPipelineInfoKHR { 4310 VkStructureType sType; 4311 const void* pNext; 4312 VkPipeline pipeline; 4313 safe_VkPipelineInfoKHR(const VkPipelineInfoKHR* in_struct); 4314 safe_VkPipelineInfoKHR(const safe_VkPipelineInfoKHR& copy_src); 4315 safe_VkPipelineInfoKHR& operator=(const safe_VkPipelineInfoKHR& copy_src); 4316 safe_VkPipelineInfoKHR(); 4317 ~safe_VkPipelineInfoKHR(); 4318 void initialize(const VkPipelineInfoKHR* in_struct); 4319 void initialize(const safe_VkPipelineInfoKHR* copy_src); ptrsafe_VkPipelineInfoKHR4320 VkPipelineInfoKHR *ptr() { return reinterpret_cast<VkPipelineInfoKHR *>(this); } ptrsafe_VkPipelineInfoKHR4321 VkPipelineInfoKHR const *ptr() const { return reinterpret_cast<VkPipelineInfoKHR const *>(this); } 4322 }; 4323 4324 struct safe_VkPipelineExecutablePropertiesKHR { 4325 VkStructureType sType; 4326 void* pNext; 4327 VkShaderStageFlags stages; 4328 char name[VK_MAX_DESCRIPTION_SIZE]; 4329 char description[VK_MAX_DESCRIPTION_SIZE]; 4330 uint32_t subgroupSize; 4331 safe_VkPipelineExecutablePropertiesKHR(const VkPipelineExecutablePropertiesKHR* in_struct); 4332 safe_VkPipelineExecutablePropertiesKHR(const safe_VkPipelineExecutablePropertiesKHR& copy_src); 4333 safe_VkPipelineExecutablePropertiesKHR& operator=(const safe_VkPipelineExecutablePropertiesKHR& copy_src); 4334 safe_VkPipelineExecutablePropertiesKHR(); 4335 ~safe_VkPipelineExecutablePropertiesKHR(); 4336 void initialize(const VkPipelineExecutablePropertiesKHR* in_struct); 4337 void initialize(const safe_VkPipelineExecutablePropertiesKHR* copy_src); ptrsafe_VkPipelineExecutablePropertiesKHR4338 VkPipelineExecutablePropertiesKHR *ptr() { return reinterpret_cast<VkPipelineExecutablePropertiesKHR *>(this); } ptrsafe_VkPipelineExecutablePropertiesKHR4339 VkPipelineExecutablePropertiesKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutablePropertiesKHR const *>(this); } 4340 }; 4341 4342 struct safe_VkPipelineExecutableInfoKHR { 4343 VkStructureType sType; 4344 const void* pNext; 4345 VkPipeline pipeline; 4346 uint32_t executableIndex; 4347 safe_VkPipelineExecutableInfoKHR(const VkPipelineExecutableInfoKHR* in_struct); 4348 safe_VkPipelineExecutableInfoKHR(const safe_VkPipelineExecutableInfoKHR& copy_src); 4349 safe_VkPipelineExecutableInfoKHR& operator=(const safe_VkPipelineExecutableInfoKHR& copy_src); 4350 safe_VkPipelineExecutableInfoKHR(); 4351 ~safe_VkPipelineExecutableInfoKHR(); 4352 void initialize(const VkPipelineExecutableInfoKHR* in_struct); 4353 void initialize(const safe_VkPipelineExecutableInfoKHR* copy_src); ptrsafe_VkPipelineExecutableInfoKHR4354 VkPipelineExecutableInfoKHR *ptr() { return reinterpret_cast<VkPipelineExecutableInfoKHR *>(this); } ptrsafe_VkPipelineExecutableInfoKHR4355 VkPipelineExecutableInfoKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutableInfoKHR const *>(this); } 4356 }; 4357 4358 struct safe_VkPipelineExecutableStatisticKHR { 4359 VkStructureType sType; 4360 void* pNext; 4361 char name[VK_MAX_DESCRIPTION_SIZE]; 4362 char description[VK_MAX_DESCRIPTION_SIZE]; 4363 VkPipelineExecutableStatisticFormatKHR format; 4364 VkPipelineExecutableStatisticValueKHR value; 4365 safe_VkPipelineExecutableStatisticKHR(const VkPipelineExecutableStatisticKHR* in_struct); 4366 safe_VkPipelineExecutableStatisticKHR(const safe_VkPipelineExecutableStatisticKHR& copy_src); 4367 safe_VkPipelineExecutableStatisticKHR& operator=(const safe_VkPipelineExecutableStatisticKHR& copy_src); 4368 safe_VkPipelineExecutableStatisticKHR(); 4369 ~safe_VkPipelineExecutableStatisticKHR(); 4370 void initialize(const VkPipelineExecutableStatisticKHR* in_struct); 4371 void initialize(const safe_VkPipelineExecutableStatisticKHR* copy_src); ptrsafe_VkPipelineExecutableStatisticKHR4372 VkPipelineExecutableStatisticKHR *ptr() { return reinterpret_cast<VkPipelineExecutableStatisticKHR *>(this); } ptrsafe_VkPipelineExecutableStatisticKHR4373 VkPipelineExecutableStatisticKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutableStatisticKHR const *>(this); } 4374 }; 4375 4376 struct safe_VkPipelineExecutableInternalRepresentationKHR { 4377 VkStructureType sType; 4378 void* pNext; 4379 char name[VK_MAX_DESCRIPTION_SIZE]; 4380 char description[VK_MAX_DESCRIPTION_SIZE]; 4381 VkBool32 isText; 4382 size_t dataSize; 4383 void* pData; 4384 safe_VkPipelineExecutableInternalRepresentationKHR(const VkPipelineExecutableInternalRepresentationKHR* in_struct); 4385 safe_VkPipelineExecutableInternalRepresentationKHR(const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src); 4386 safe_VkPipelineExecutableInternalRepresentationKHR& operator=(const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src); 4387 safe_VkPipelineExecutableInternalRepresentationKHR(); 4388 ~safe_VkPipelineExecutableInternalRepresentationKHR(); 4389 void initialize(const VkPipelineExecutableInternalRepresentationKHR* in_struct); 4390 void initialize(const safe_VkPipelineExecutableInternalRepresentationKHR* copy_src); ptrsafe_VkPipelineExecutableInternalRepresentationKHR4391 VkPipelineExecutableInternalRepresentationKHR *ptr() { return reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>(this); } ptrsafe_VkPipelineExecutableInternalRepresentationKHR4392 VkPipelineExecutableInternalRepresentationKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR const *>(this); } 4393 }; 4394 4395 #ifdef VK_ENABLE_BETA_EXTENSIONS 4396 struct safe_VkPipelineLibraryCreateInfoKHR { 4397 VkStructureType sType; 4398 const void* pNext; 4399 uint32_t libraryCount; 4400 VkPipeline* pLibraries; 4401 safe_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR* in_struct); 4402 safe_VkPipelineLibraryCreateInfoKHR(const safe_VkPipelineLibraryCreateInfoKHR& copy_src); 4403 safe_VkPipelineLibraryCreateInfoKHR& operator=(const safe_VkPipelineLibraryCreateInfoKHR& copy_src); 4404 safe_VkPipelineLibraryCreateInfoKHR(); 4405 ~safe_VkPipelineLibraryCreateInfoKHR(); 4406 void initialize(const VkPipelineLibraryCreateInfoKHR* in_struct); 4407 void initialize(const safe_VkPipelineLibraryCreateInfoKHR* copy_src); ptrsafe_VkPipelineLibraryCreateInfoKHR4408 VkPipelineLibraryCreateInfoKHR *ptr() { return reinterpret_cast<VkPipelineLibraryCreateInfoKHR *>(this); } ptrsafe_VkPipelineLibraryCreateInfoKHR4409 VkPipelineLibraryCreateInfoKHR const *ptr() const { return reinterpret_cast<VkPipelineLibraryCreateInfoKHR const *>(this); } 4410 }; 4411 #endif // VK_ENABLE_BETA_EXTENSIONS 4412 4413 struct safe_VkBufferCopy2KHR { 4414 VkStructureType sType; 4415 const void* pNext; 4416 VkDeviceSize srcOffset; 4417 VkDeviceSize dstOffset; 4418 VkDeviceSize size; 4419 safe_VkBufferCopy2KHR(const VkBufferCopy2KHR* in_struct); 4420 safe_VkBufferCopy2KHR(const safe_VkBufferCopy2KHR& copy_src); 4421 safe_VkBufferCopy2KHR& operator=(const safe_VkBufferCopy2KHR& copy_src); 4422 safe_VkBufferCopy2KHR(); 4423 ~safe_VkBufferCopy2KHR(); 4424 void initialize(const VkBufferCopy2KHR* in_struct); 4425 void initialize(const safe_VkBufferCopy2KHR* copy_src); ptrsafe_VkBufferCopy2KHR4426 VkBufferCopy2KHR *ptr() { return reinterpret_cast<VkBufferCopy2KHR *>(this); } ptrsafe_VkBufferCopy2KHR4427 VkBufferCopy2KHR const *ptr() const { return reinterpret_cast<VkBufferCopy2KHR const *>(this); } 4428 }; 4429 4430 struct safe_VkCopyBufferInfo2KHR { 4431 VkStructureType sType; 4432 const void* pNext; 4433 VkBuffer srcBuffer; 4434 VkBuffer dstBuffer; 4435 uint32_t regionCount; 4436 safe_VkBufferCopy2KHR* pRegions; 4437 safe_VkCopyBufferInfo2KHR(const VkCopyBufferInfo2KHR* in_struct); 4438 safe_VkCopyBufferInfo2KHR(const safe_VkCopyBufferInfo2KHR& copy_src); 4439 safe_VkCopyBufferInfo2KHR& operator=(const safe_VkCopyBufferInfo2KHR& copy_src); 4440 safe_VkCopyBufferInfo2KHR(); 4441 ~safe_VkCopyBufferInfo2KHR(); 4442 void initialize(const VkCopyBufferInfo2KHR* in_struct); 4443 void initialize(const safe_VkCopyBufferInfo2KHR* copy_src); ptrsafe_VkCopyBufferInfo2KHR4444 VkCopyBufferInfo2KHR *ptr() { return reinterpret_cast<VkCopyBufferInfo2KHR *>(this); } ptrsafe_VkCopyBufferInfo2KHR4445 VkCopyBufferInfo2KHR const *ptr() const { return reinterpret_cast<VkCopyBufferInfo2KHR const *>(this); } 4446 }; 4447 4448 struct safe_VkImageCopy2KHR { 4449 VkStructureType sType; 4450 const void* pNext; 4451 VkImageSubresourceLayers srcSubresource; 4452 VkOffset3D srcOffset; 4453 VkImageSubresourceLayers dstSubresource; 4454 VkOffset3D dstOffset; 4455 VkExtent3D extent; 4456 safe_VkImageCopy2KHR(const VkImageCopy2KHR* in_struct); 4457 safe_VkImageCopy2KHR(const safe_VkImageCopy2KHR& copy_src); 4458 safe_VkImageCopy2KHR& operator=(const safe_VkImageCopy2KHR& copy_src); 4459 safe_VkImageCopy2KHR(); 4460 ~safe_VkImageCopy2KHR(); 4461 void initialize(const VkImageCopy2KHR* in_struct); 4462 void initialize(const safe_VkImageCopy2KHR* copy_src); ptrsafe_VkImageCopy2KHR4463 VkImageCopy2KHR *ptr() { return reinterpret_cast<VkImageCopy2KHR *>(this); } ptrsafe_VkImageCopy2KHR4464 VkImageCopy2KHR const *ptr() const { return reinterpret_cast<VkImageCopy2KHR const *>(this); } 4465 }; 4466 4467 struct safe_VkCopyImageInfo2KHR { 4468 VkStructureType sType; 4469 const void* pNext; 4470 VkImage srcImage; 4471 VkImageLayout srcImageLayout; 4472 VkImage dstImage; 4473 VkImageLayout dstImageLayout; 4474 uint32_t regionCount; 4475 safe_VkImageCopy2KHR* pRegions; 4476 safe_VkCopyImageInfo2KHR(const VkCopyImageInfo2KHR* in_struct); 4477 safe_VkCopyImageInfo2KHR(const safe_VkCopyImageInfo2KHR& copy_src); 4478 safe_VkCopyImageInfo2KHR& operator=(const safe_VkCopyImageInfo2KHR& copy_src); 4479 safe_VkCopyImageInfo2KHR(); 4480 ~safe_VkCopyImageInfo2KHR(); 4481 void initialize(const VkCopyImageInfo2KHR* in_struct); 4482 void initialize(const safe_VkCopyImageInfo2KHR* copy_src); ptrsafe_VkCopyImageInfo2KHR4483 VkCopyImageInfo2KHR *ptr() { return reinterpret_cast<VkCopyImageInfo2KHR *>(this); } ptrsafe_VkCopyImageInfo2KHR4484 VkCopyImageInfo2KHR const *ptr() const { return reinterpret_cast<VkCopyImageInfo2KHR const *>(this); } 4485 }; 4486 4487 struct safe_VkBufferImageCopy2KHR { 4488 VkStructureType sType; 4489 const void* pNext; 4490 VkDeviceSize bufferOffset; 4491 uint32_t bufferRowLength; 4492 uint32_t bufferImageHeight; 4493 VkImageSubresourceLayers imageSubresource; 4494 VkOffset3D imageOffset; 4495 VkExtent3D imageExtent; 4496 safe_VkBufferImageCopy2KHR(const VkBufferImageCopy2KHR* in_struct); 4497 safe_VkBufferImageCopy2KHR(const safe_VkBufferImageCopy2KHR& copy_src); 4498 safe_VkBufferImageCopy2KHR& operator=(const safe_VkBufferImageCopy2KHR& copy_src); 4499 safe_VkBufferImageCopy2KHR(); 4500 ~safe_VkBufferImageCopy2KHR(); 4501 void initialize(const VkBufferImageCopy2KHR* in_struct); 4502 void initialize(const safe_VkBufferImageCopy2KHR* copy_src); ptrsafe_VkBufferImageCopy2KHR4503 VkBufferImageCopy2KHR *ptr() { return reinterpret_cast<VkBufferImageCopy2KHR *>(this); } ptrsafe_VkBufferImageCopy2KHR4504 VkBufferImageCopy2KHR const *ptr() const { return reinterpret_cast<VkBufferImageCopy2KHR const *>(this); } 4505 }; 4506 4507 struct safe_VkCopyBufferToImageInfo2KHR { 4508 VkStructureType sType; 4509 const void* pNext; 4510 VkBuffer srcBuffer; 4511 VkImage dstImage; 4512 VkImageLayout dstImageLayout; 4513 uint32_t regionCount; 4514 safe_VkBufferImageCopy2KHR* pRegions; 4515 safe_VkCopyBufferToImageInfo2KHR(const VkCopyBufferToImageInfo2KHR* in_struct); 4516 safe_VkCopyBufferToImageInfo2KHR(const safe_VkCopyBufferToImageInfo2KHR& copy_src); 4517 safe_VkCopyBufferToImageInfo2KHR& operator=(const safe_VkCopyBufferToImageInfo2KHR& copy_src); 4518 safe_VkCopyBufferToImageInfo2KHR(); 4519 ~safe_VkCopyBufferToImageInfo2KHR(); 4520 void initialize(const VkCopyBufferToImageInfo2KHR* in_struct); 4521 void initialize(const safe_VkCopyBufferToImageInfo2KHR* copy_src); ptrsafe_VkCopyBufferToImageInfo2KHR4522 VkCopyBufferToImageInfo2KHR *ptr() { return reinterpret_cast<VkCopyBufferToImageInfo2KHR *>(this); } ptrsafe_VkCopyBufferToImageInfo2KHR4523 VkCopyBufferToImageInfo2KHR const *ptr() const { return reinterpret_cast<VkCopyBufferToImageInfo2KHR const *>(this); } 4524 }; 4525 4526 struct safe_VkCopyImageToBufferInfo2KHR { 4527 VkStructureType sType; 4528 const void* pNext; 4529 VkImage srcImage; 4530 VkImageLayout srcImageLayout; 4531 VkBuffer dstBuffer; 4532 uint32_t regionCount; 4533 safe_VkBufferImageCopy2KHR* pRegions; 4534 safe_VkCopyImageToBufferInfo2KHR(const VkCopyImageToBufferInfo2KHR* in_struct); 4535 safe_VkCopyImageToBufferInfo2KHR(const safe_VkCopyImageToBufferInfo2KHR& copy_src); 4536 safe_VkCopyImageToBufferInfo2KHR& operator=(const safe_VkCopyImageToBufferInfo2KHR& copy_src); 4537 safe_VkCopyImageToBufferInfo2KHR(); 4538 ~safe_VkCopyImageToBufferInfo2KHR(); 4539 void initialize(const VkCopyImageToBufferInfo2KHR* in_struct); 4540 void initialize(const safe_VkCopyImageToBufferInfo2KHR* copy_src); ptrsafe_VkCopyImageToBufferInfo2KHR4541 VkCopyImageToBufferInfo2KHR *ptr() { return reinterpret_cast<VkCopyImageToBufferInfo2KHR *>(this); } ptrsafe_VkCopyImageToBufferInfo2KHR4542