1 // *** THIS FILE IS GENERATED - DO NOT EDIT *** 2 // See helper_file_generator.py for modifications 3 4 5 /*************************************************************************** 6 * 7 * Copyright (c) 2015-2019 The Khronos Group Inc. 8 * Copyright (c) 2015-2019 Valve Corporation 9 * Copyright (c) 2015-2019 LunarG, Inc. 10 * Copyright (c) 2015-2019 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 36 void *SafePnextCopy(const void *pNext); 37 void FreePnextChain(const void *pNext); 38 char *SafeStringCopy(const char *in_string); 39 40 41 struct safe_VkApplicationInfo { 42 VkStructureType sType; 43 const void* pNext; 44 const char* pApplicationName; 45 uint32_t applicationVersion; 46 const char* pEngineName; 47 uint32_t engineVersion; 48 uint32_t apiVersion; 49 safe_VkApplicationInfo(const VkApplicationInfo* in_struct); 50 safe_VkApplicationInfo(const safe_VkApplicationInfo& src); 51 safe_VkApplicationInfo& operator=(const safe_VkApplicationInfo& src); 52 safe_VkApplicationInfo(); 53 ~safe_VkApplicationInfo(); 54 void initialize(const VkApplicationInfo* in_struct); 55 void initialize(const safe_VkApplicationInfo* src); ptrsafe_VkApplicationInfo56 VkApplicationInfo *ptr() { return reinterpret_cast<VkApplicationInfo *>(this); } ptrsafe_VkApplicationInfo57 VkApplicationInfo const *ptr() const { return reinterpret_cast<VkApplicationInfo const *>(this); } 58 }; 59 60 struct safe_VkInstanceCreateInfo { 61 VkStructureType sType; 62 const void* pNext; 63 VkInstanceCreateFlags flags; 64 safe_VkApplicationInfo* pApplicationInfo; 65 uint32_t enabledLayerCount; 66 const char* const* ppEnabledLayerNames; 67 uint32_t enabledExtensionCount; 68 const char* const* ppEnabledExtensionNames; 69 safe_VkInstanceCreateInfo(const VkInstanceCreateInfo* in_struct); 70 safe_VkInstanceCreateInfo(const safe_VkInstanceCreateInfo& src); 71 safe_VkInstanceCreateInfo& operator=(const safe_VkInstanceCreateInfo& src); 72 safe_VkInstanceCreateInfo(); 73 ~safe_VkInstanceCreateInfo(); 74 void initialize(const VkInstanceCreateInfo* in_struct); 75 void initialize(const safe_VkInstanceCreateInfo* src); ptrsafe_VkInstanceCreateInfo76 VkInstanceCreateInfo *ptr() { return reinterpret_cast<VkInstanceCreateInfo *>(this); } ptrsafe_VkInstanceCreateInfo77 VkInstanceCreateInfo const *ptr() const { return reinterpret_cast<VkInstanceCreateInfo const *>(this); } 78 }; 79 80 struct safe_VkAllocationCallbacks { 81 void* pUserData; 82 PFN_vkAllocationFunction pfnAllocation; 83 PFN_vkReallocationFunction pfnReallocation; 84 PFN_vkFreeFunction pfnFree; 85 PFN_vkInternalAllocationNotification pfnInternalAllocation; 86 PFN_vkInternalFreeNotification pfnInternalFree; 87 safe_VkAllocationCallbacks(const VkAllocationCallbacks* in_struct); 88 safe_VkAllocationCallbacks(const safe_VkAllocationCallbacks& src); 89 safe_VkAllocationCallbacks& operator=(const safe_VkAllocationCallbacks& src); 90 safe_VkAllocationCallbacks(); 91 ~safe_VkAllocationCallbacks(); 92 void initialize(const VkAllocationCallbacks* in_struct); 93 void initialize(const safe_VkAllocationCallbacks* src); ptrsafe_VkAllocationCallbacks94 VkAllocationCallbacks *ptr() { return reinterpret_cast<VkAllocationCallbacks *>(this); } ptrsafe_VkAllocationCallbacks95 VkAllocationCallbacks const *ptr() const { return reinterpret_cast<VkAllocationCallbacks const *>(this); } 96 }; 97 98 struct safe_VkDeviceQueueCreateInfo { 99 VkStructureType sType; 100 const void* pNext; 101 VkDeviceQueueCreateFlags flags; 102 uint32_t queueFamilyIndex; 103 uint32_t queueCount; 104 const float* pQueuePriorities; 105 safe_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo* in_struct); 106 safe_VkDeviceQueueCreateInfo(const safe_VkDeviceQueueCreateInfo& src); 107 safe_VkDeviceQueueCreateInfo& operator=(const safe_VkDeviceQueueCreateInfo& src); 108 safe_VkDeviceQueueCreateInfo(); 109 ~safe_VkDeviceQueueCreateInfo(); 110 void initialize(const VkDeviceQueueCreateInfo* in_struct); 111 void initialize(const safe_VkDeviceQueueCreateInfo* src); ptrsafe_VkDeviceQueueCreateInfo112 VkDeviceQueueCreateInfo *ptr() { return reinterpret_cast<VkDeviceQueueCreateInfo *>(this); } ptrsafe_VkDeviceQueueCreateInfo113 VkDeviceQueueCreateInfo const *ptr() const { return reinterpret_cast<VkDeviceQueueCreateInfo const *>(this); } 114 }; 115 116 struct safe_VkDeviceCreateInfo { 117 VkStructureType sType; 118 const void* pNext; 119 VkDeviceCreateFlags flags; 120 uint32_t queueCreateInfoCount; 121 safe_VkDeviceQueueCreateInfo* pQueueCreateInfos; 122 uint32_t enabledLayerCount; 123 const char* const* ppEnabledLayerNames; 124 uint32_t enabledExtensionCount; 125 const char* const* ppEnabledExtensionNames; 126 const VkPhysicalDeviceFeatures* pEnabledFeatures; 127 safe_VkDeviceCreateInfo(const VkDeviceCreateInfo* in_struct); 128 safe_VkDeviceCreateInfo(const safe_VkDeviceCreateInfo& src); 129 safe_VkDeviceCreateInfo& operator=(const safe_VkDeviceCreateInfo& src); 130 safe_VkDeviceCreateInfo(); 131 ~safe_VkDeviceCreateInfo(); 132 void initialize(const VkDeviceCreateInfo* in_struct); 133 void initialize(const safe_VkDeviceCreateInfo* src); ptrsafe_VkDeviceCreateInfo134 VkDeviceCreateInfo *ptr() { return reinterpret_cast<VkDeviceCreateInfo *>(this); } ptrsafe_VkDeviceCreateInfo135 VkDeviceCreateInfo const *ptr() const { return reinterpret_cast<VkDeviceCreateInfo const *>(this); } 136 }; 137 138 struct safe_VkSubmitInfo { 139 VkStructureType sType; 140 const void* pNext; 141 uint32_t waitSemaphoreCount; 142 VkSemaphore* pWaitSemaphores; 143 const VkPipelineStageFlags* pWaitDstStageMask; 144 uint32_t commandBufferCount; 145 VkCommandBuffer* pCommandBuffers; 146 uint32_t signalSemaphoreCount; 147 VkSemaphore* pSignalSemaphores; 148 safe_VkSubmitInfo(const VkSubmitInfo* in_struct); 149 safe_VkSubmitInfo(const safe_VkSubmitInfo& src); 150 safe_VkSubmitInfo& operator=(const safe_VkSubmitInfo& src); 151 safe_VkSubmitInfo(); 152 ~safe_VkSubmitInfo(); 153 void initialize(const VkSubmitInfo* in_struct); 154 void initialize(const safe_VkSubmitInfo* src); ptrsafe_VkSubmitInfo155 VkSubmitInfo *ptr() { return reinterpret_cast<VkSubmitInfo *>(this); } ptrsafe_VkSubmitInfo156 VkSubmitInfo const *ptr() const { return reinterpret_cast<VkSubmitInfo const *>(this); } 157 }; 158 159 struct safe_VkMemoryAllocateInfo { 160 VkStructureType sType; 161 const void* pNext; 162 VkDeviceSize allocationSize; 163 uint32_t memoryTypeIndex; 164 safe_VkMemoryAllocateInfo(const VkMemoryAllocateInfo* in_struct); 165 safe_VkMemoryAllocateInfo(const safe_VkMemoryAllocateInfo& src); 166 safe_VkMemoryAllocateInfo& operator=(const safe_VkMemoryAllocateInfo& src); 167 safe_VkMemoryAllocateInfo(); 168 ~safe_VkMemoryAllocateInfo(); 169 void initialize(const VkMemoryAllocateInfo* in_struct); 170 void initialize(const safe_VkMemoryAllocateInfo* src); ptrsafe_VkMemoryAllocateInfo171 VkMemoryAllocateInfo *ptr() { return reinterpret_cast<VkMemoryAllocateInfo *>(this); } ptrsafe_VkMemoryAllocateInfo172 VkMemoryAllocateInfo const *ptr() const { return reinterpret_cast<VkMemoryAllocateInfo const *>(this); } 173 }; 174 175 struct safe_VkMappedMemoryRange { 176 VkStructureType sType; 177 const void* pNext; 178 VkDeviceMemory memory; 179 VkDeviceSize offset; 180 VkDeviceSize size; 181 safe_VkMappedMemoryRange(const VkMappedMemoryRange* in_struct); 182 safe_VkMappedMemoryRange(const safe_VkMappedMemoryRange& src); 183 safe_VkMappedMemoryRange& operator=(const safe_VkMappedMemoryRange& src); 184 safe_VkMappedMemoryRange(); 185 ~safe_VkMappedMemoryRange(); 186 void initialize(const VkMappedMemoryRange* in_struct); 187 void initialize(const safe_VkMappedMemoryRange* src); ptrsafe_VkMappedMemoryRange188 VkMappedMemoryRange *ptr() { return reinterpret_cast<VkMappedMemoryRange *>(this); } ptrsafe_VkMappedMemoryRange189 VkMappedMemoryRange const *ptr() const { return reinterpret_cast<VkMappedMemoryRange const *>(this); } 190 }; 191 192 struct safe_VkSparseBufferMemoryBindInfo { 193 VkBuffer buffer; 194 uint32_t bindCount; 195 VkSparseMemoryBind* pBinds; 196 safe_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo* in_struct); 197 safe_VkSparseBufferMemoryBindInfo(const safe_VkSparseBufferMemoryBindInfo& src); 198 safe_VkSparseBufferMemoryBindInfo& operator=(const safe_VkSparseBufferMemoryBindInfo& src); 199 safe_VkSparseBufferMemoryBindInfo(); 200 ~safe_VkSparseBufferMemoryBindInfo(); 201 void initialize(const VkSparseBufferMemoryBindInfo* in_struct); 202 void initialize(const safe_VkSparseBufferMemoryBindInfo* src); ptrsafe_VkSparseBufferMemoryBindInfo203 VkSparseBufferMemoryBindInfo *ptr() { return reinterpret_cast<VkSparseBufferMemoryBindInfo *>(this); } ptrsafe_VkSparseBufferMemoryBindInfo204 VkSparseBufferMemoryBindInfo const *ptr() const { return reinterpret_cast<VkSparseBufferMemoryBindInfo const *>(this); } 205 }; 206 207 struct safe_VkSparseImageOpaqueMemoryBindInfo { 208 VkImage image; 209 uint32_t bindCount; 210 VkSparseMemoryBind* pBinds; 211 safe_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo* in_struct); 212 safe_VkSparseImageOpaqueMemoryBindInfo(const safe_VkSparseImageOpaqueMemoryBindInfo& src); 213 safe_VkSparseImageOpaqueMemoryBindInfo& operator=(const safe_VkSparseImageOpaqueMemoryBindInfo& src); 214 safe_VkSparseImageOpaqueMemoryBindInfo(); 215 ~safe_VkSparseImageOpaqueMemoryBindInfo(); 216 void initialize(const VkSparseImageOpaqueMemoryBindInfo* in_struct); 217 void initialize(const safe_VkSparseImageOpaqueMemoryBindInfo* src); ptrsafe_VkSparseImageOpaqueMemoryBindInfo218 VkSparseImageOpaqueMemoryBindInfo *ptr() { return reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo *>(this); } ptrsafe_VkSparseImageOpaqueMemoryBindInfo219 VkSparseImageOpaqueMemoryBindInfo const *ptr() const { return reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo const *>(this); } 220 }; 221 222 struct safe_VkSparseImageMemoryBindInfo { 223 VkImage image; 224 uint32_t bindCount; 225 VkSparseImageMemoryBind* pBinds; 226 safe_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo* in_struct); 227 safe_VkSparseImageMemoryBindInfo(const safe_VkSparseImageMemoryBindInfo& src); 228 safe_VkSparseImageMemoryBindInfo& operator=(const safe_VkSparseImageMemoryBindInfo& src); 229 safe_VkSparseImageMemoryBindInfo(); 230 ~safe_VkSparseImageMemoryBindInfo(); 231 void initialize(const VkSparseImageMemoryBindInfo* in_struct); 232 void initialize(const safe_VkSparseImageMemoryBindInfo* src); ptrsafe_VkSparseImageMemoryBindInfo233 VkSparseImageMemoryBindInfo *ptr() { return reinterpret_cast<VkSparseImageMemoryBindInfo *>(this); } ptrsafe_VkSparseImageMemoryBindInfo234 VkSparseImageMemoryBindInfo const *ptr() const { return reinterpret_cast<VkSparseImageMemoryBindInfo const *>(this); } 235 }; 236 237 struct safe_VkBindSparseInfo { 238 VkStructureType sType; 239 const void* pNext; 240 uint32_t waitSemaphoreCount; 241 VkSemaphore* pWaitSemaphores; 242 uint32_t bufferBindCount; 243 safe_VkSparseBufferMemoryBindInfo* pBufferBinds; 244 uint32_t imageOpaqueBindCount; 245 safe_VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; 246 uint32_t imageBindCount; 247 safe_VkSparseImageMemoryBindInfo* pImageBinds; 248 uint32_t signalSemaphoreCount; 249 VkSemaphore* pSignalSemaphores; 250 safe_VkBindSparseInfo(const VkBindSparseInfo* in_struct); 251 safe_VkBindSparseInfo(const safe_VkBindSparseInfo& src); 252 safe_VkBindSparseInfo& operator=(const safe_VkBindSparseInfo& src); 253 safe_VkBindSparseInfo(); 254 ~safe_VkBindSparseInfo(); 255 void initialize(const VkBindSparseInfo* in_struct); 256 void initialize(const safe_VkBindSparseInfo* src); ptrsafe_VkBindSparseInfo257 VkBindSparseInfo *ptr() { return reinterpret_cast<VkBindSparseInfo *>(this); } ptrsafe_VkBindSparseInfo258 VkBindSparseInfo const *ptr() const { return reinterpret_cast<VkBindSparseInfo const *>(this); } 259 }; 260 261 struct safe_VkFenceCreateInfo { 262 VkStructureType sType; 263 const void* pNext; 264 VkFenceCreateFlags flags; 265 safe_VkFenceCreateInfo(const VkFenceCreateInfo* in_struct); 266 safe_VkFenceCreateInfo(const safe_VkFenceCreateInfo& src); 267 safe_VkFenceCreateInfo& operator=(const safe_VkFenceCreateInfo& src); 268 safe_VkFenceCreateInfo(); 269 ~safe_VkFenceCreateInfo(); 270 void initialize(const VkFenceCreateInfo* in_struct); 271 void initialize(const safe_VkFenceCreateInfo* src); ptrsafe_VkFenceCreateInfo272 VkFenceCreateInfo *ptr() { return reinterpret_cast<VkFenceCreateInfo *>(this); } ptrsafe_VkFenceCreateInfo273 VkFenceCreateInfo const *ptr() const { return reinterpret_cast<VkFenceCreateInfo const *>(this); } 274 }; 275 276 struct safe_VkSemaphoreCreateInfo { 277 VkStructureType sType; 278 const void* pNext; 279 VkSemaphoreCreateFlags flags; 280 safe_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo* in_struct); 281 safe_VkSemaphoreCreateInfo(const safe_VkSemaphoreCreateInfo& src); 282 safe_VkSemaphoreCreateInfo& operator=(const safe_VkSemaphoreCreateInfo& src); 283 safe_VkSemaphoreCreateInfo(); 284 ~safe_VkSemaphoreCreateInfo(); 285 void initialize(const VkSemaphoreCreateInfo* in_struct); 286 void initialize(const safe_VkSemaphoreCreateInfo* src); ptrsafe_VkSemaphoreCreateInfo287 VkSemaphoreCreateInfo *ptr() { return reinterpret_cast<VkSemaphoreCreateInfo *>(this); } ptrsafe_VkSemaphoreCreateInfo288 VkSemaphoreCreateInfo const *ptr() const { return reinterpret_cast<VkSemaphoreCreateInfo const *>(this); } 289 }; 290 291 struct safe_VkEventCreateInfo { 292 VkStructureType sType; 293 const void* pNext; 294 VkEventCreateFlags flags; 295 safe_VkEventCreateInfo(const VkEventCreateInfo* in_struct); 296 safe_VkEventCreateInfo(const safe_VkEventCreateInfo& src); 297 safe_VkEventCreateInfo& operator=(const safe_VkEventCreateInfo& src); 298 safe_VkEventCreateInfo(); 299 ~safe_VkEventCreateInfo(); 300 void initialize(const VkEventCreateInfo* in_struct); 301 void initialize(const safe_VkEventCreateInfo* src); ptrsafe_VkEventCreateInfo302 VkEventCreateInfo *ptr() { return reinterpret_cast<VkEventCreateInfo *>(this); } ptrsafe_VkEventCreateInfo303 VkEventCreateInfo const *ptr() const { return reinterpret_cast<VkEventCreateInfo const *>(this); } 304 }; 305 306 struct safe_VkQueryPoolCreateInfo { 307 VkStructureType sType; 308 const void* pNext; 309 VkQueryPoolCreateFlags flags; 310 VkQueryType queryType; 311 uint32_t queryCount; 312 VkQueryPipelineStatisticFlags pipelineStatistics; 313 safe_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo* in_struct); 314 safe_VkQueryPoolCreateInfo(const safe_VkQueryPoolCreateInfo& src); 315 safe_VkQueryPoolCreateInfo& operator=(const safe_VkQueryPoolCreateInfo& src); 316 safe_VkQueryPoolCreateInfo(); 317 ~safe_VkQueryPoolCreateInfo(); 318 void initialize(const VkQueryPoolCreateInfo* in_struct); 319 void initialize(const safe_VkQueryPoolCreateInfo* src); ptrsafe_VkQueryPoolCreateInfo320 VkQueryPoolCreateInfo *ptr() { return reinterpret_cast<VkQueryPoolCreateInfo *>(this); } ptrsafe_VkQueryPoolCreateInfo321 VkQueryPoolCreateInfo const *ptr() const { return reinterpret_cast<VkQueryPoolCreateInfo const *>(this); } 322 }; 323 324 struct safe_VkBufferCreateInfo { 325 VkStructureType sType; 326 const void* pNext; 327 VkBufferCreateFlags flags; 328 VkDeviceSize size; 329 VkBufferUsageFlags usage; 330 VkSharingMode sharingMode; 331 uint32_t queueFamilyIndexCount; 332 const uint32_t* pQueueFamilyIndices; 333 safe_VkBufferCreateInfo(const VkBufferCreateInfo* in_struct); 334 safe_VkBufferCreateInfo(const safe_VkBufferCreateInfo& src); 335 safe_VkBufferCreateInfo& operator=(const safe_VkBufferCreateInfo& src); 336 safe_VkBufferCreateInfo(); 337 ~safe_VkBufferCreateInfo(); 338 void initialize(const VkBufferCreateInfo* in_struct); 339 void initialize(const safe_VkBufferCreateInfo* src); ptrsafe_VkBufferCreateInfo340 VkBufferCreateInfo *ptr() { return reinterpret_cast<VkBufferCreateInfo *>(this); } ptrsafe_VkBufferCreateInfo341 VkBufferCreateInfo const *ptr() const { return reinterpret_cast<VkBufferCreateInfo const *>(this); } 342 }; 343 344 struct safe_VkBufferViewCreateInfo { 345 VkStructureType sType; 346 const void* pNext; 347 VkBufferViewCreateFlags flags; 348 VkBuffer buffer; 349 VkFormat format; 350 VkDeviceSize offset; 351 VkDeviceSize range; 352 safe_VkBufferViewCreateInfo(const VkBufferViewCreateInfo* in_struct); 353 safe_VkBufferViewCreateInfo(const safe_VkBufferViewCreateInfo& src); 354 safe_VkBufferViewCreateInfo& operator=(const safe_VkBufferViewCreateInfo& src); 355 safe_VkBufferViewCreateInfo(); 356 ~safe_VkBufferViewCreateInfo(); 357 void initialize(const VkBufferViewCreateInfo* in_struct); 358 void initialize(const safe_VkBufferViewCreateInfo* src); ptrsafe_VkBufferViewCreateInfo359 VkBufferViewCreateInfo *ptr() { return reinterpret_cast<VkBufferViewCreateInfo *>(this); } ptrsafe_VkBufferViewCreateInfo360 VkBufferViewCreateInfo const *ptr() const { return reinterpret_cast<VkBufferViewCreateInfo const *>(this); } 361 }; 362 363 struct safe_VkImageCreateInfo { 364 VkStructureType sType; 365 const void* pNext; 366 VkImageCreateFlags flags; 367 VkImageType imageType; 368 VkFormat format; 369 VkExtent3D extent; 370 uint32_t mipLevels; 371 uint32_t arrayLayers; 372 VkSampleCountFlagBits samples; 373 VkImageTiling tiling; 374 VkImageUsageFlags usage; 375 VkSharingMode sharingMode; 376 uint32_t queueFamilyIndexCount; 377 const uint32_t* pQueueFamilyIndices; 378 VkImageLayout initialLayout; 379 safe_VkImageCreateInfo(const VkImageCreateInfo* in_struct); 380 safe_VkImageCreateInfo(const safe_VkImageCreateInfo& src); 381 safe_VkImageCreateInfo& operator=(const safe_VkImageCreateInfo& src); 382 safe_VkImageCreateInfo(); 383 ~safe_VkImageCreateInfo(); 384 void initialize(const VkImageCreateInfo* in_struct); 385 void initialize(const safe_VkImageCreateInfo* src); ptrsafe_VkImageCreateInfo386 VkImageCreateInfo *ptr() { return reinterpret_cast<VkImageCreateInfo *>(this); } ptrsafe_VkImageCreateInfo387 VkImageCreateInfo const *ptr() const { return reinterpret_cast<VkImageCreateInfo const *>(this); } 388 }; 389 390 struct safe_VkImageViewCreateInfo { 391 VkStructureType sType; 392 const void* pNext; 393 VkImageViewCreateFlags flags; 394 VkImage image; 395 VkImageViewType viewType; 396 VkFormat format; 397 VkComponentMapping components; 398 VkImageSubresourceRange subresourceRange; 399 safe_VkImageViewCreateInfo(const VkImageViewCreateInfo* in_struct); 400 safe_VkImageViewCreateInfo(const safe_VkImageViewCreateInfo& src); 401 safe_VkImageViewCreateInfo& operator=(const safe_VkImageViewCreateInfo& src); 402 safe_VkImageViewCreateInfo(); 403 ~safe_VkImageViewCreateInfo(); 404 void initialize(const VkImageViewCreateInfo* in_struct); 405 void initialize(const safe_VkImageViewCreateInfo* src); ptrsafe_VkImageViewCreateInfo406 VkImageViewCreateInfo *ptr() { return reinterpret_cast<VkImageViewCreateInfo *>(this); } ptrsafe_VkImageViewCreateInfo407 VkImageViewCreateInfo const *ptr() const { return reinterpret_cast<VkImageViewCreateInfo const *>(this); } 408 }; 409 410 struct safe_VkShaderModuleCreateInfo { 411 VkStructureType sType; 412 const void* pNext; 413 VkShaderModuleCreateFlags flags; 414 size_t codeSize; 415 const uint32_t* pCode; 416 safe_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo* in_struct); 417 safe_VkShaderModuleCreateInfo(const safe_VkShaderModuleCreateInfo& src); 418 safe_VkShaderModuleCreateInfo& operator=(const safe_VkShaderModuleCreateInfo& src); 419 safe_VkShaderModuleCreateInfo(); 420 ~safe_VkShaderModuleCreateInfo(); 421 void initialize(const VkShaderModuleCreateInfo* in_struct); 422 void initialize(const safe_VkShaderModuleCreateInfo* src); ptrsafe_VkShaderModuleCreateInfo423 VkShaderModuleCreateInfo *ptr() { return reinterpret_cast<VkShaderModuleCreateInfo *>(this); } ptrsafe_VkShaderModuleCreateInfo424 VkShaderModuleCreateInfo const *ptr() const { return reinterpret_cast<VkShaderModuleCreateInfo const *>(this); } 425 }; 426 427 struct safe_VkPipelineCacheCreateInfo { 428 VkStructureType sType; 429 const void* pNext; 430 VkPipelineCacheCreateFlags flags; 431 size_t initialDataSize; 432 const void* pInitialData; 433 safe_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo* in_struct); 434 safe_VkPipelineCacheCreateInfo(const safe_VkPipelineCacheCreateInfo& src); 435 safe_VkPipelineCacheCreateInfo& operator=(const safe_VkPipelineCacheCreateInfo& src); 436 safe_VkPipelineCacheCreateInfo(); 437 ~safe_VkPipelineCacheCreateInfo(); 438 void initialize(const VkPipelineCacheCreateInfo* in_struct); 439 void initialize(const safe_VkPipelineCacheCreateInfo* src); ptrsafe_VkPipelineCacheCreateInfo440 VkPipelineCacheCreateInfo *ptr() { return reinterpret_cast<VkPipelineCacheCreateInfo *>(this); } ptrsafe_VkPipelineCacheCreateInfo441 VkPipelineCacheCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineCacheCreateInfo const *>(this); } 442 }; 443 444 struct safe_VkSpecializationInfo { 445 uint32_t mapEntryCount; 446 const VkSpecializationMapEntry* pMapEntries; 447 size_t dataSize; 448 const void* pData; 449 safe_VkSpecializationInfo(const VkSpecializationInfo* in_struct); 450 safe_VkSpecializationInfo(const safe_VkSpecializationInfo& src); 451 safe_VkSpecializationInfo& operator=(const safe_VkSpecializationInfo& src); 452 safe_VkSpecializationInfo(); 453 ~safe_VkSpecializationInfo(); 454 void initialize(const VkSpecializationInfo* in_struct); 455 void initialize(const safe_VkSpecializationInfo* src); ptrsafe_VkSpecializationInfo456 VkSpecializationInfo *ptr() { return reinterpret_cast<VkSpecializationInfo *>(this); } ptrsafe_VkSpecializationInfo457 VkSpecializationInfo const *ptr() const { return reinterpret_cast<VkSpecializationInfo const *>(this); } 458 }; 459 460 struct safe_VkPipelineShaderStageCreateInfo { 461 VkStructureType sType; 462 const void* pNext; 463 VkPipelineShaderStageCreateFlags flags; 464 VkShaderStageFlagBits stage; 465 VkShaderModule module; 466 const char* pName; 467 safe_VkSpecializationInfo* pSpecializationInfo; 468 safe_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo* in_struct); 469 safe_VkPipelineShaderStageCreateInfo(const safe_VkPipelineShaderStageCreateInfo& src); 470 safe_VkPipelineShaderStageCreateInfo& operator=(const safe_VkPipelineShaderStageCreateInfo& src); 471 safe_VkPipelineShaderStageCreateInfo(); 472 ~safe_VkPipelineShaderStageCreateInfo(); 473 void initialize(const VkPipelineShaderStageCreateInfo* in_struct); 474 void initialize(const safe_VkPipelineShaderStageCreateInfo* src); ptrsafe_VkPipelineShaderStageCreateInfo475 VkPipelineShaderStageCreateInfo *ptr() { return reinterpret_cast<VkPipelineShaderStageCreateInfo *>(this); } ptrsafe_VkPipelineShaderStageCreateInfo476 VkPipelineShaderStageCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineShaderStageCreateInfo const *>(this); } 477 }; 478 479 struct safe_VkPipelineVertexInputStateCreateInfo { 480 VkStructureType sType; 481 const void* pNext; 482 VkPipelineVertexInputStateCreateFlags flags; 483 uint32_t vertexBindingDescriptionCount; 484 const VkVertexInputBindingDescription* pVertexBindingDescriptions; 485 uint32_t vertexAttributeDescriptionCount; 486 const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; 487 safe_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo* in_struct); 488 safe_VkPipelineVertexInputStateCreateInfo(const safe_VkPipelineVertexInputStateCreateInfo& src); 489 safe_VkPipelineVertexInputStateCreateInfo& operator=(const safe_VkPipelineVertexInputStateCreateInfo& src); 490 safe_VkPipelineVertexInputStateCreateInfo(); 491 ~safe_VkPipelineVertexInputStateCreateInfo(); 492 void initialize(const VkPipelineVertexInputStateCreateInfo* in_struct); 493 void initialize(const safe_VkPipelineVertexInputStateCreateInfo* src); ptrsafe_VkPipelineVertexInputStateCreateInfo494 VkPipelineVertexInputStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineVertexInputStateCreateInfo *>(this); } ptrsafe_VkPipelineVertexInputStateCreateInfo495 VkPipelineVertexInputStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineVertexInputStateCreateInfo const *>(this); } 496 }; 497 498 struct safe_VkPipelineInputAssemblyStateCreateInfo { 499 VkStructureType sType; 500 const void* pNext; 501 VkPipelineInputAssemblyStateCreateFlags flags; 502 VkPrimitiveTopology topology; 503 VkBool32 primitiveRestartEnable; 504 safe_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo* in_struct); 505 safe_VkPipelineInputAssemblyStateCreateInfo(const safe_VkPipelineInputAssemblyStateCreateInfo& src); 506 safe_VkPipelineInputAssemblyStateCreateInfo& operator=(const safe_VkPipelineInputAssemblyStateCreateInfo& src); 507 safe_VkPipelineInputAssemblyStateCreateInfo(); 508 ~safe_VkPipelineInputAssemblyStateCreateInfo(); 509 void initialize(const VkPipelineInputAssemblyStateCreateInfo* in_struct); 510 void initialize(const safe_VkPipelineInputAssemblyStateCreateInfo* src); ptrsafe_VkPipelineInputAssemblyStateCreateInfo511 VkPipelineInputAssemblyStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo *>(this); } ptrsafe_VkPipelineInputAssemblyStateCreateInfo512 VkPipelineInputAssemblyStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo const *>(this); } 513 }; 514 515 struct safe_VkPipelineTessellationStateCreateInfo { 516 VkStructureType sType; 517 const void* pNext; 518 VkPipelineTessellationStateCreateFlags flags; 519 uint32_t patchControlPoints; 520 safe_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo* in_struct); 521 safe_VkPipelineTessellationStateCreateInfo(const safe_VkPipelineTessellationStateCreateInfo& src); 522 safe_VkPipelineTessellationStateCreateInfo& operator=(const safe_VkPipelineTessellationStateCreateInfo& src); 523 safe_VkPipelineTessellationStateCreateInfo(); 524 ~safe_VkPipelineTessellationStateCreateInfo(); 525 void initialize(const VkPipelineTessellationStateCreateInfo* in_struct); 526 void initialize(const safe_VkPipelineTessellationStateCreateInfo* src); ptrsafe_VkPipelineTessellationStateCreateInfo527 VkPipelineTessellationStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineTessellationStateCreateInfo *>(this); } ptrsafe_VkPipelineTessellationStateCreateInfo528 VkPipelineTessellationStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineTessellationStateCreateInfo const *>(this); } 529 }; 530 531 struct safe_VkPipelineViewportStateCreateInfo { 532 VkStructureType sType; 533 const void* pNext; 534 VkPipelineViewportStateCreateFlags flags; 535 uint32_t viewportCount; 536 const VkViewport* pViewports; 537 uint32_t scissorCount; 538 const VkRect2D* pScissors; 539 safe_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports, const bool is_dynamic_scissors); 540 safe_VkPipelineViewportStateCreateInfo(const safe_VkPipelineViewportStateCreateInfo& src); 541 safe_VkPipelineViewportStateCreateInfo& operator=(const safe_VkPipelineViewportStateCreateInfo& src); 542 safe_VkPipelineViewportStateCreateInfo(); 543 ~safe_VkPipelineViewportStateCreateInfo(); 544 void initialize(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports, const bool is_dynamic_scissors); 545 void initialize(const safe_VkPipelineViewportStateCreateInfo* src); ptrsafe_VkPipelineViewportStateCreateInfo546 VkPipelineViewportStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineViewportStateCreateInfo *>(this); } ptrsafe_VkPipelineViewportStateCreateInfo547 VkPipelineViewportStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineViewportStateCreateInfo const *>(this); } 548 }; 549 550 struct safe_VkPipelineRasterizationStateCreateInfo { 551 VkStructureType sType; 552 const void* pNext; 553 VkPipelineRasterizationStateCreateFlags flags; 554 VkBool32 depthClampEnable; 555 VkBool32 rasterizerDiscardEnable; 556 VkPolygonMode polygonMode; 557 VkCullModeFlags cullMode; 558 VkFrontFace frontFace; 559 VkBool32 depthBiasEnable; 560 float depthBiasConstantFactor; 561 float depthBiasClamp; 562 float depthBiasSlopeFactor; 563 float lineWidth; 564 safe_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo* in_struct); 565 safe_VkPipelineRasterizationStateCreateInfo(const safe_VkPipelineRasterizationStateCreateInfo& src); 566 safe_VkPipelineRasterizationStateCreateInfo& operator=(const safe_VkPipelineRasterizationStateCreateInfo& src); 567 safe_VkPipelineRasterizationStateCreateInfo(); 568 ~safe_VkPipelineRasterizationStateCreateInfo(); 569 void initialize(const VkPipelineRasterizationStateCreateInfo* in_struct); 570 void initialize(const safe_VkPipelineRasterizationStateCreateInfo* src); ptrsafe_VkPipelineRasterizationStateCreateInfo571 VkPipelineRasterizationStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineRasterizationStateCreateInfo *>(this); } ptrsafe_VkPipelineRasterizationStateCreateInfo572 VkPipelineRasterizationStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineRasterizationStateCreateInfo const *>(this); } 573 }; 574 575 struct safe_VkPipelineMultisampleStateCreateInfo { 576 VkStructureType sType; 577 const void* pNext; 578 VkPipelineMultisampleStateCreateFlags flags; 579 VkSampleCountFlagBits rasterizationSamples; 580 VkBool32 sampleShadingEnable; 581 float minSampleShading; 582 const VkSampleMask* pSampleMask; 583 VkBool32 alphaToCoverageEnable; 584 VkBool32 alphaToOneEnable; 585 safe_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo* in_struct); 586 safe_VkPipelineMultisampleStateCreateInfo(const safe_VkPipelineMultisampleStateCreateInfo& src); 587 safe_VkPipelineMultisampleStateCreateInfo& operator=(const safe_VkPipelineMultisampleStateCreateInfo& src); 588 safe_VkPipelineMultisampleStateCreateInfo(); 589 ~safe_VkPipelineMultisampleStateCreateInfo(); 590 void initialize(const VkPipelineMultisampleStateCreateInfo* in_struct); 591 void initialize(const safe_VkPipelineMultisampleStateCreateInfo* src); ptrsafe_VkPipelineMultisampleStateCreateInfo592 VkPipelineMultisampleStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineMultisampleStateCreateInfo *>(this); } ptrsafe_VkPipelineMultisampleStateCreateInfo593 VkPipelineMultisampleStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineMultisampleStateCreateInfo const *>(this); } 594 }; 595 596 struct safe_VkPipelineDepthStencilStateCreateInfo { 597 VkStructureType sType; 598 const void* pNext; 599 VkPipelineDepthStencilStateCreateFlags flags; 600 VkBool32 depthTestEnable; 601 VkBool32 depthWriteEnable; 602 VkCompareOp depthCompareOp; 603 VkBool32 depthBoundsTestEnable; 604 VkBool32 stencilTestEnable; 605 VkStencilOpState front; 606 VkStencilOpState back; 607 float minDepthBounds; 608 float maxDepthBounds; 609 safe_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo* in_struct); 610 safe_VkPipelineDepthStencilStateCreateInfo(const safe_VkPipelineDepthStencilStateCreateInfo& src); 611 safe_VkPipelineDepthStencilStateCreateInfo& operator=(const safe_VkPipelineDepthStencilStateCreateInfo& src); 612 safe_VkPipelineDepthStencilStateCreateInfo(); 613 ~safe_VkPipelineDepthStencilStateCreateInfo(); 614 void initialize(const VkPipelineDepthStencilStateCreateInfo* in_struct); 615 void initialize(const safe_VkPipelineDepthStencilStateCreateInfo* src); ptrsafe_VkPipelineDepthStencilStateCreateInfo616 VkPipelineDepthStencilStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo *>(this); } ptrsafe_VkPipelineDepthStencilStateCreateInfo617 VkPipelineDepthStencilStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo const *>(this); } 618 }; 619 620 struct safe_VkPipelineColorBlendStateCreateInfo { 621 VkStructureType sType; 622 const void* pNext; 623 VkPipelineColorBlendStateCreateFlags flags; 624 VkBool32 logicOpEnable; 625 VkLogicOp logicOp; 626 uint32_t attachmentCount; 627 const VkPipelineColorBlendAttachmentState* pAttachments; 628 float blendConstants[4]; 629 safe_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo* in_struct); 630 safe_VkPipelineColorBlendStateCreateInfo(const safe_VkPipelineColorBlendStateCreateInfo& src); 631 safe_VkPipelineColorBlendStateCreateInfo& operator=(const safe_VkPipelineColorBlendStateCreateInfo& src); 632 safe_VkPipelineColorBlendStateCreateInfo(); 633 ~safe_VkPipelineColorBlendStateCreateInfo(); 634 void initialize(const VkPipelineColorBlendStateCreateInfo* in_struct); 635 void initialize(const safe_VkPipelineColorBlendStateCreateInfo* src); ptrsafe_VkPipelineColorBlendStateCreateInfo636 VkPipelineColorBlendStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineColorBlendStateCreateInfo *>(this); } ptrsafe_VkPipelineColorBlendStateCreateInfo637 VkPipelineColorBlendStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineColorBlendStateCreateInfo const *>(this); } 638 }; 639 640 struct safe_VkPipelineDynamicStateCreateInfo { 641 VkStructureType sType; 642 const void* pNext; 643 VkPipelineDynamicStateCreateFlags flags; 644 uint32_t dynamicStateCount; 645 const VkDynamicState* pDynamicStates; 646 safe_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* in_struct); 647 safe_VkPipelineDynamicStateCreateInfo(const safe_VkPipelineDynamicStateCreateInfo& src); 648 safe_VkPipelineDynamicStateCreateInfo& operator=(const safe_VkPipelineDynamicStateCreateInfo& src); 649 safe_VkPipelineDynamicStateCreateInfo(); 650 ~safe_VkPipelineDynamicStateCreateInfo(); 651 void initialize(const VkPipelineDynamicStateCreateInfo* in_struct); 652 void initialize(const safe_VkPipelineDynamicStateCreateInfo* src); ptrsafe_VkPipelineDynamicStateCreateInfo653 VkPipelineDynamicStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineDynamicStateCreateInfo *>(this); } ptrsafe_VkPipelineDynamicStateCreateInfo654 VkPipelineDynamicStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineDynamicStateCreateInfo const *>(this); } 655 }; 656 657 struct safe_VkGraphicsPipelineCreateInfo { 658 VkStructureType sType; 659 const void* pNext; 660 VkPipelineCreateFlags flags; 661 uint32_t stageCount; 662 safe_VkPipelineShaderStageCreateInfo* pStages; 663 safe_VkPipelineVertexInputStateCreateInfo* pVertexInputState; 664 safe_VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; 665 safe_VkPipelineTessellationStateCreateInfo* pTessellationState; 666 safe_VkPipelineViewportStateCreateInfo* pViewportState; 667 safe_VkPipelineRasterizationStateCreateInfo* pRasterizationState; 668 safe_VkPipelineMultisampleStateCreateInfo* pMultisampleState; 669 safe_VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; 670 safe_VkPipelineColorBlendStateCreateInfo* pColorBlendState; 671 safe_VkPipelineDynamicStateCreateInfo* pDynamicState; 672 VkPipelineLayout layout; 673 VkRenderPass renderPass; 674 uint32_t subpass; 675 VkPipeline basePipelineHandle; 676 int32_t basePipelineIndex; 677 safe_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment, const bool uses_depthstencil_attachment); 678 safe_VkGraphicsPipelineCreateInfo(const safe_VkGraphicsPipelineCreateInfo& src); 679 safe_VkGraphicsPipelineCreateInfo& operator=(const safe_VkGraphicsPipelineCreateInfo& src); 680 safe_VkGraphicsPipelineCreateInfo(); 681 ~safe_VkGraphicsPipelineCreateInfo(); 682 void initialize(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment, const bool uses_depthstencil_attachment); 683 void initialize(const safe_VkGraphicsPipelineCreateInfo* src); ptrsafe_VkGraphicsPipelineCreateInfo684 VkGraphicsPipelineCreateInfo *ptr() { return reinterpret_cast<VkGraphicsPipelineCreateInfo *>(this); } ptrsafe_VkGraphicsPipelineCreateInfo685 VkGraphicsPipelineCreateInfo const *ptr() const { return reinterpret_cast<VkGraphicsPipelineCreateInfo const *>(this); } 686 }; 687 688 struct safe_VkComputePipelineCreateInfo { 689 VkStructureType sType; 690 const void* pNext; 691 VkPipelineCreateFlags flags; 692 safe_VkPipelineShaderStageCreateInfo stage; 693 VkPipelineLayout layout; 694 VkPipeline basePipelineHandle; 695 int32_t basePipelineIndex; 696 safe_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo* in_struct); 697 safe_VkComputePipelineCreateInfo(const safe_VkComputePipelineCreateInfo& src); 698 safe_VkComputePipelineCreateInfo& operator=(const safe_VkComputePipelineCreateInfo& src); 699 safe_VkComputePipelineCreateInfo(); 700 ~safe_VkComputePipelineCreateInfo(); 701 void initialize(const VkComputePipelineCreateInfo* in_struct); 702 void initialize(const safe_VkComputePipelineCreateInfo* src); ptrsafe_VkComputePipelineCreateInfo703 VkComputePipelineCreateInfo *ptr() { return reinterpret_cast<VkComputePipelineCreateInfo *>(this); } ptrsafe_VkComputePipelineCreateInfo704 VkComputePipelineCreateInfo const *ptr() const { return reinterpret_cast<VkComputePipelineCreateInfo const *>(this); } 705 }; 706 707 struct safe_VkPipelineLayoutCreateInfo { 708 VkStructureType sType; 709 const void* pNext; 710 VkPipelineLayoutCreateFlags flags; 711 uint32_t setLayoutCount; 712 VkDescriptorSetLayout* pSetLayouts; 713 uint32_t pushConstantRangeCount; 714 const VkPushConstantRange* pPushConstantRanges; 715 safe_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo* in_struct); 716 safe_VkPipelineLayoutCreateInfo(const safe_VkPipelineLayoutCreateInfo& src); 717 safe_VkPipelineLayoutCreateInfo& operator=(const safe_VkPipelineLayoutCreateInfo& src); 718 safe_VkPipelineLayoutCreateInfo(); 719 ~safe_VkPipelineLayoutCreateInfo(); 720 void initialize(const VkPipelineLayoutCreateInfo* in_struct); 721 void initialize(const safe_VkPipelineLayoutCreateInfo* src); ptrsafe_VkPipelineLayoutCreateInfo722 VkPipelineLayoutCreateInfo *ptr() { return reinterpret_cast<VkPipelineLayoutCreateInfo *>(this); } ptrsafe_VkPipelineLayoutCreateInfo723 VkPipelineLayoutCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineLayoutCreateInfo const *>(this); } 724 }; 725 726 struct safe_VkSamplerCreateInfo { 727 VkStructureType sType; 728 const void* pNext; 729 VkSamplerCreateFlags flags; 730 VkFilter magFilter; 731 VkFilter minFilter; 732 VkSamplerMipmapMode mipmapMode; 733 VkSamplerAddressMode addressModeU; 734 VkSamplerAddressMode addressModeV; 735 VkSamplerAddressMode addressModeW; 736 float mipLodBias; 737 VkBool32 anisotropyEnable; 738 float maxAnisotropy; 739 VkBool32 compareEnable; 740 VkCompareOp compareOp; 741 float minLod; 742 float maxLod; 743 VkBorderColor borderColor; 744 VkBool32 unnormalizedCoordinates; 745 safe_VkSamplerCreateInfo(const VkSamplerCreateInfo* in_struct); 746 safe_VkSamplerCreateInfo(const safe_VkSamplerCreateInfo& src); 747 safe_VkSamplerCreateInfo& operator=(const safe_VkSamplerCreateInfo& src); 748 safe_VkSamplerCreateInfo(); 749 ~safe_VkSamplerCreateInfo(); 750 void initialize(const VkSamplerCreateInfo* in_struct); 751 void initialize(const safe_VkSamplerCreateInfo* src); ptrsafe_VkSamplerCreateInfo752 VkSamplerCreateInfo *ptr() { return reinterpret_cast<VkSamplerCreateInfo *>(this); } ptrsafe_VkSamplerCreateInfo753 VkSamplerCreateInfo const *ptr() const { return reinterpret_cast<VkSamplerCreateInfo const *>(this); } 754 }; 755 756 struct safe_VkDescriptorSetLayoutBinding { 757 uint32_t binding; 758 VkDescriptorType descriptorType; 759 uint32_t descriptorCount; 760 VkShaderStageFlags stageFlags; 761 VkSampler* pImmutableSamplers; 762 safe_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding* in_struct); 763 safe_VkDescriptorSetLayoutBinding(const safe_VkDescriptorSetLayoutBinding& src); 764 safe_VkDescriptorSetLayoutBinding& operator=(const safe_VkDescriptorSetLayoutBinding& src); 765 safe_VkDescriptorSetLayoutBinding(); 766 ~safe_VkDescriptorSetLayoutBinding(); 767 void initialize(const VkDescriptorSetLayoutBinding* in_struct); 768 void initialize(const safe_VkDescriptorSetLayoutBinding* src); ptrsafe_VkDescriptorSetLayoutBinding769 VkDescriptorSetLayoutBinding *ptr() { return reinterpret_cast<VkDescriptorSetLayoutBinding *>(this); } ptrsafe_VkDescriptorSetLayoutBinding770 VkDescriptorSetLayoutBinding const *ptr() const { return reinterpret_cast<VkDescriptorSetLayoutBinding const *>(this); } 771 }; 772 773 struct safe_VkDescriptorSetLayoutCreateInfo { 774 VkStructureType sType; 775 const void* pNext; 776 VkDescriptorSetLayoutCreateFlags flags; 777 uint32_t bindingCount; 778 safe_VkDescriptorSetLayoutBinding* pBindings; 779 safe_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo* in_struct); 780 safe_VkDescriptorSetLayoutCreateInfo(const safe_VkDescriptorSetLayoutCreateInfo& src); 781 safe_VkDescriptorSetLayoutCreateInfo& operator=(const safe_VkDescriptorSetLayoutCreateInfo& src); 782 safe_VkDescriptorSetLayoutCreateInfo(); 783 ~safe_VkDescriptorSetLayoutCreateInfo(); 784 void initialize(const VkDescriptorSetLayoutCreateInfo* in_struct); 785 void initialize(const safe_VkDescriptorSetLayoutCreateInfo* src); ptrsafe_VkDescriptorSetLayoutCreateInfo786 VkDescriptorSetLayoutCreateInfo *ptr() { return reinterpret_cast<VkDescriptorSetLayoutCreateInfo *>(this); } ptrsafe_VkDescriptorSetLayoutCreateInfo787 VkDescriptorSetLayoutCreateInfo const *ptr() const { return reinterpret_cast<VkDescriptorSetLayoutCreateInfo const *>(this); } 788 }; 789 790 struct safe_VkDescriptorPoolCreateInfo { 791 VkStructureType sType; 792 const void* pNext; 793 VkDescriptorPoolCreateFlags flags; 794 uint32_t maxSets; 795 uint32_t poolSizeCount; 796 const VkDescriptorPoolSize* pPoolSizes; 797 safe_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo* in_struct); 798 safe_VkDescriptorPoolCreateInfo(const safe_VkDescriptorPoolCreateInfo& src); 799 safe_VkDescriptorPoolCreateInfo& operator=(const safe_VkDescriptorPoolCreateInfo& src); 800 safe_VkDescriptorPoolCreateInfo(); 801 ~safe_VkDescriptorPoolCreateInfo(); 802 void initialize(const VkDescriptorPoolCreateInfo* in_struct); 803 void initialize(const safe_VkDescriptorPoolCreateInfo* src); ptrsafe_VkDescriptorPoolCreateInfo804 VkDescriptorPoolCreateInfo *ptr() { return reinterpret_cast<VkDescriptorPoolCreateInfo *>(this); } ptrsafe_VkDescriptorPoolCreateInfo805 VkDescriptorPoolCreateInfo const *ptr() const { return reinterpret_cast<VkDescriptorPoolCreateInfo const *>(this); } 806 }; 807 808 struct safe_VkDescriptorSetAllocateInfo { 809 VkStructureType sType; 810 const void* pNext; 811 VkDescriptorPool descriptorPool; 812 uint32_t descriptorSetCount; 813 VkDescriptorSetLayout* pSetLayouts; 814 safe_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo* in_struct); 815 safe_VkDescriptorSetAllocateInfo(const safe_VkDescriptorSetAllocateInfo& src); 816 safe_VkDescriptorSetAllocateInfo& operator=(const safe_VkDescriptorSetAllocateInfo& src); 817 safe_VkDescriptorSetAllocateInfo(); 818 ~safe_VkDescriptorSetAllocateInfo(); 819 void initialize(const VkDescriptorSetAllocateInfo* in_struct); 820 void initialize(const safe_VkDescriptorSetAllocateInfo* src); ptrsafe_VkDescriptorSetAllocateInfo821 VkDescriptorSetAllocateInfo *ptr() { return reinterpret_cast<VkDescriptorSetAllocateInfo *>(this); } ptrsafe_VkDescriptorSetAllocateInfo822 VkDescriptorSetAllocateInfo const *ptr() const { return reinterpret_cast<VkDescriptorSetAllocateInfo const *>(this); } 823 }; 824 825 struct safe_VkWriteDescriptorSet { 826 VkStructureType sType; 827 const void* pNext; 828 VkDescriptorSet dstSet; 829 uint32_t dstBinding; 830 uint32_t dstArrayElement; 831 uint32_t descriptorCount; 832 VkDescriptorType descriptorType; 833 VkDescriptorImageInfo* pImageInfo; 834 VkDescriptorBufferInfo* pBufferInfo; 835 VkBufferView* pTexelBufferView; 836 safe_VkWriteDescriptorSet(const VkWriteDescriptorSet* in_struct); 837 safe_VkWriteDescriptorSet(const safe_VkWriteDescriptorSet& src); 838 safe_VkWriteDescriptorSet& operator=(const safe_VkWriteDescriptorSet& src); 839 safe_VkWriteDescriptorSet(); 840 ~safe_VkWriteDescriptorSet(); 841 void initialize(const VkWriteDescriptorSet* in_struct); 842 void initialize(const safe_VkWriteDescriptorSet* src); ptrsafe_VkWriteDescriptorSet843 VkWriteDescriptorSet *ptr() { return reinterpret_cast<VkWriteDescriptorSet *>(this); } ptrsafe_VkWriteDescriptorSet844 VkWriteDescriptorSet const *ptr() const { return reinterpret_cast<VkWriteDescriptorSet const *>(this); } 845 }; 846 847 struct safe_VkCopyDescriptorSet { 848 VkStructureType sType; 849 const void* pNext; 850 VkDescriptorSet srcSet; 851 uint32_t srcBinding; 852 uint32_t srcArrayElement; 853 VkDescriptorSet dstSet; 854 uint32_t dstBinding; 855 uint32_t dstArrayElement; 856 uint32_t descriptorCount; 857 safe_VkCopyDescriptorSet(const VkCopyDescriptorSet* in_struct); 858 safe_VkCopyDescriptorSet(const safe_VkCopyDescriptorSet& src); 859 safe_VkCopyDescriptorSet& operator=(const safe_VkCopyDescriptorSet& src); 860 safe_VkCopyDescriptorSet(); 861 ~safe_VkCopyDescriptorSet(); 862 void initialize(const VkCopyDescriptorSet* in_struct); 863 void initialize(const safe_VkCopyDescriptorSet* src); ptrsafe_VkCopyDescriptorSet864 VkCopyDescriptorSet *ptr() { return reinterpret_cast<VkCopyDescriptorSet *>(this); } ptrsafe_VkCopyDescriptorSet865 VkCopyDescriptorSet const *ptr() const { return reinterpret_cast<VkCopyDescriptorSet const *>(this); } 866 }; 867 868 struct safe_VkFramebufferCreateInfo { 869 VkStructureType sType; 870 const void* pNext; 871 VkFramebufferCreateFlags flags; 872 VkRenderPass renderPass; 873 uint32_t attachmentCount; 874 VkImageView* pAttachments; 875 uint32_t width; 876 uint32_t height; 877 uint32_t layers; 878 safe_VkFramebufferCreateInfo(const VkFramebufferCreateInfo* in_struct); 879 safe_VkFramebufferCreateInfo(const safe_VkFramebufferCreateInfo& src); 880 safe_VkFramebufferCreateInfo& operator=(const safe_VkFramebufferCreateInfo& src); 881 safe_VkFramebufferCreateInfo(); 882 ~safe_VkFramebufferCreateInfo(); 883 void initialize(const VkFramebufferCreateInfo* in_struct); 884 void initialize(const safe_VkFramebufferCreateInfo* src); ptrsafe_VkFramebufferCreateInfo885 VkFramebufferCreateInfo *ptr() { return reinterpret_cast<VkFramebufferCreateInfo *>(this); } ptrsafe_VkFramebufferCreateInfo886 VkFramebufferCreateInfo const *ptr() const { return reinterpret_cast<VkFramebufferCreateInfo const *>(this); } 887 }; 888 889 struct safe_VkSubpassDescription { 890 VkSubpassDescriptionFlags flags; 891 VkPipelineBindPoint pipelineBindPoint; 892 uint32_t inputAttachmentCount; 893 const VkAttachmentReference* pInputAttachments; 894 uint32_t colorAttachmentCount; 895 const VkAttachmentReference* pColorAttachments; 896 const VkAttachmentReference* pResolveAttachments; 897 const VkAttachmentReference* pDepthStencilAttachment; 898 uint32_t preserveAttachmentCount; 899 const uint32_t* pPreserveAttachments; 900 safe_VkSubpassDescription(const VkSubpassDescription* in_struct); 901 safe_VkSubpassDescription(const safe_VkSubpassDescription& src); 902 safe_VkSubpassDescription& operator=(const safe_VkSubpassDescription& src); 903 safe_VkSubpassDescription(); 904 ~safe_VkSubpassDescription(); 905 void initialize(const VkSubpassDescription* in_struct); 906 void initialize(const safe_VkSubpassDescription* src); ptrsafe_VkSubpassDescription907 VkSubpassDescription *ptr() { return reinterpret_cast<VkSubpassDescription *>(this); } ptrsafe_VkSubpassDescription908 VkSubpassDescription const *ptr() const { return reinterpret_cast<VkSubpassDescription const *>(this); } 909 }; 910 911 struct safe_VkRenderPassCreateInfo { 912 VkStructureType sType; 913 const void* pNext; 914 VkRenderPassCreateFlags flags; 915 uint32_t attachmentCount; 916 const VkAttachmentDescription* pAttachments; 917 uint32_t subpassCount; 918 safe_VkSubpassDescription* pSubpasses; 919 uint32_t dependencyCount; 920 const VkSubpassDependency* pDependencies; 921 safe_VkRenderPassCreateInfo(const VkRenderPassCreateInfo* in_struct); 922 safe_VkRenderPassCreateInfo(const safe_VkRenderPassCreateInfo& src); 923 safe_VkRenderPassCreateInfo& operator=(const safe_VkRenderPassCreateInfo& src); 924 safe_VkRenderPassCreateInfo(); 925 ~safe_VkRenderPassCreateInfo(); 926 void initialize(const VkRenderPassCreateInfo* in_struct); 927 void initialize(const safe_VkRenderPassCreateInfo* src); ptrsafe_VkRenderPassCreateInfo928 VkRenderPassCreateInfo *ptr() { return reinterpret_cast<VkRenderPassCreateInfo *>(this); } ptrsafe_VkRenderPassCreateInfo929 VkRenderPassCreateInfo const *ptr() const { return reinterpret_cast<VkRenderPassCreateInfo const *>(this); } 930 }; 931 932 struct safe_VkCommandPoolCreateInfo { 933 VkStructureType sType; 934 const void* pNext; 935 VkCommandPoolCreateFlags flags; 936 uint32_t queueFamilyIndex; 937 safe_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo* in_struct); 938 safe_VkCommandPoolCreateInfo(const safe_VkCommandPoolCreateInfo& src); 939 safe_VkCommandPoolCreateInfo& operator=(const safe_VkCommandPoolCreateInfo& src); 940 safe_VkCommandPoolCreateInfo(); 941 ~safe_VkCommandPoolCreateInfo(); 942 void initialize(const VkCommandPoolCreateInfo* in_struct); 943 void initialize(const safe_VkCommandPoolCreateInfo* src); ptrsafe_VkCommandPoolCreateInfo944 VkCommandPoolCreateInfo *ptr() { return reinterpret_cast<VkCommandPoolCreateInfo *>(this); } ptrsafe_VkCommandPoolCreateInfo945 VkCommandPoolCreateInfo const *ptr() const { return reinterpret_cast<VkCommandPoolCreateInfo const *>(this); } 946 }; 947 948 struct safe_VkCommandBufferAllocateInfo { 949 VkStructureType sType; 950 const void* pNext; 951 VkCommandPool commandPool; 952 VkCommandBufferLevel level; 953 uint32_t commandBufferCount; 954 safe_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo* in_struct); 955 safe_VkCommandBufferAllocateInfo(const safe_VkCommandBufferAllocateInfo& src); 956 safe_VkCommandBufferAllocateInfo& operator=(const safe_VkCommandBufferAllocateInfo& src); 957 safe_VkCommandBufferAllocateInfo(); 958 ~safe_VkCommandBufferAllocateInfo(); 959 void initialize(const VkCommandBufferAllocateInfo* in_struct); 960 void initialize(const safe_VkCommandBufferAllocateInfo* src); ptrsafe_VkCommandBufferAllocateInfo961 VkCommandBufferAllocateInfo *ptr() { return reinterpret_cast<VkCommandBufferAllocateInfo *>(this); } ptrsafe_VkCommandBufferAllocateInfo962 VkCommandBufferAllocateInfo const *ptr() const { return reinterpret_cast<VkCommandBufferAllocateInfo const *>(this); } 963 }; 964 965 struct safe_VkCommandBufferInheritanceInfo { 966 VkStructureType sType; 967 const void* pNext; 968 VkRenderPass renderPass; 969 uint32_t subpass; 970 VkFramebuffer framebuffer; 971 VkBool32 occlusionQueryEnable; 972 VkQueryControlFlags queryFlags; 973 VkQueryPipelineStatisticFlags pipelineStatistics; 974 safe_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo* in_struct); 975 safe_VkCommandBufferInheritanceInfo(const safe_VkCommandBufferInheritanceInfo& src); 976 safe_VkCommandBufferInheritanceInfo& operator=(const safe_VkCommandBufferInheritanceInfo& src); 977 safe_VkCommandBufferInheritanceInfo(); 978 ~safe_VkCommandBufferInheritanceInfo(); 979 void initialize(const VkCommandBufferInheritanceInfo* in_struct); 980 void initialize(const safe_VkCommandBufferInheritanceInfo* src); ptrsafe_VkCommandBufferInheritanceInfo981 VkCommandBufferInheritanceInfo *ptr() { return reinterpret_cast<VkCommandBufferInheritanceInfo *>(this); } ptrsafe_VkCommandBufferInheritanceInfo982 VkCommandBufferInheritanceInfo const *ptr() const { return reinterpret_cast<VkCommandBufferInheritanceInfo const *>(this); } 983 }; 984 985 struct safe_VkCommandBufferBeginInfo { 986 VkStructureType sType; 987 const void* pNext; 988 VkCommandBufferUsageFlags flags; 989 safe_VkCommandBufferInheritanceInfo* pInheritanceInfo; 990 safe_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo* in_struct); 991 safe_VkCommandBufferBeginInfo(const safe_VkCommandBufferBeginInfo& src); 992 safe_VkCommandBufferBeginInfo& operator=(const safe_VkCommandBufferBeginInfo& src); 993 safe_VkCommandBufferBeginInfo(); 994 ~safe_VkCommandBufferBeginInfo(); 995 void initialize(const VkCommandBufferBeginInfo* in_struct); 996 void initialize(const safe_VkCommandBufferBeginInfo* src); ptrsafe_VkCommandBufferBeginInfo997 VkCommandBufferBeginInfo *ptr() { return reinterpret_cast<VkCommandBufferBeginInfo *>(this); } ptrsafe_VkCommandBufferBeginInfo998 VkCommandBufferBeginInfo const *ptr() const { return reinterpret_cast<VkCommandBufferBeginInfo const *>(this); } 999 }; 1000 1001 struct safe_VkMemoryBarrier { 1002 VkStructureType sType; 1003 const void* pNext; 1004 VkAccessFlags srcAccessMask; 1005 VkAccessFlags dstAccessMask; 1006 safe_VkMemoryBarrier(const VkMemoryBarrier* in_struct); 1007 safe_VkMemoryBarrier(const safe_VkMemoryBarrier& src); 1008 safe_VkMemoryBarrier& operator=(const safe_VkMemoryBarrier& src); 1009 safe_VkMemoryBarrier(); 1010 ~safe_VkMemoryBarrier(); 1011 void initialize(const VkMemoryBarrier* in_struct); 1012 void initialize(const safe_VkMemoryBarrier* src); ptrsafe_VkMemoryBarrier1013 VkMemoryBarrier *ptr() { return reinterpret_cast<VkMemoryBarrier *>(this); } ptrsafe_VkMemoryBarrier1014 VkMemoryBarrier const *ptr() const { return reinterpret_cast<VkMemoryBarrier const *>(this); } 1015 }; 1016 1017 struct safe_VkBufferMemoryBarrier { 1018 VkStructureType sType; 1019 const void* pNext; 1020 VkAccessFlags srcAccessMask; 1021 VkAccessFlags dstAccessMask; 1022 uint32_t srcQueueFamilyIndex; 1023 uint32_t dstQueueFamilyIndex; 1024 VkBuffer buffer; 1025 VkDeviceSize offset; 1026 VkDeviceSize size; 1027 safe_VkBufferMemoryBarrier(const VkBufferMemoryBarrier* in_struct); 1028 safe_VkBufferMemoryBarrier(const safe_VkBufferMemoryBarrier& src); 1029 safe_VkBufferMemoryBarrier& operator=(const safe_VkBufferMemoryBarrier& src); 1030 safe_VkBufferMemoryBarrier(); 1031 ~safe_VkBufferMemoryBarrier(); 1032 void initialize(const VkBufferMemoryBarrier* in_struct); 1033 void initialize(const safe_VkBufferMemoryBarrier* src); ptrsafe_VkBufferMemoryBarrier1034 VkBufferMemoryBarrier *ptr() { return reinterpret_cast<VkBufferMemoryBarrier *>(this); } ptrsafe_VkBufferMemoryBarrier1035 VkBufferMemoryBarrier const *ptr() const { return reinterpret_cast<VkBufferMemoryBarrier const *>(this); } 1036 }; 1037 1038 struct safe_VkImageMemoryBarrier { 1039 VkStructureType sType; 1040 const void* pNext; 1041 VkAccessFlags srcAccessMask; 1042 VkAccessFlags dstAccessMask; 1043 VkImageLayout oldLayout; 1044 VkImageLayout newLayout; 1045 uint32_t srcQueueFamilyIndex; 1046 uint32_t dstQueueFamilyIndex; 1047 VkImage image; 1048 VkImageSubresourceRange subresourceRange; 1049 safe_VkImageMemoryBarrier(const VkImageMemoryBarrier* in_struct); 1050 safe_VkImageMemoryBarrier(const safe_VkImageMemoryBarrier& src); 1051 safe_VkImageMemoryBarrier& operator=(const safe_VkImageMemoryBarrier& src); 1052 safe_VkImageMemoryBarrier(); 1053 ~safe_VkImageMemoryBarrier(); 1054 void initialize(const VkImageMemoryBarrier* in_struct); 1055 void initialize(const safe_VkImageMemoryBarrier* src); ptrsafe_VkImageMemoryBarrier1056 VkImageMemoryBarrier *ptr() { return reinterpret_cast<VkImageMemoryBarrier *>(this); } ptrsafe_VkImageMemoryBarrier1057 VkImageMemoryBarrier const *ptr() const { return reinterpret_cast<VkImageMemoryBarrier const *>(this); } 1058 }; 1059 1060 struct safe_VkRenderPassBeginInfo { 1061 VkStructureType sType; 1062 const void* pNext; 1063 VkRenderPass renderPass; 1064 VkFramebuffer framebuffer; 1065 VkRect2D renderArea; 1066 uint32_t clearValueCount; 1067 const VkClearValue* pClearValues; 1068 safe_VkRenderPassBeginInfo(const VkRenderPassBeginInfo* in_struct); 1069 safe_VkRenderPassBeginInfo(const safe_VkRenderPassBeginInfo& src); 1070 safe_VkRenderPassBeginInfo& operator=(const safe_VkRenderPassBeginInfo& src); 1071 safe_VkRenderPassBeginInfo(); 1072 ~safe_VkRenderPassBeginInfo(); 1073 void initialize(const VkRenderPassBeginInfo* in_struct); 1074 void initialize(const safe_VkRenderPassBeginInfo* src); ptrsafe_VkRenderPassBeginInfo1075 VkRenderPassBeginInfo *ptr() { return reinterpret_cast<VkRenderPassBeginInfo *>(this); } ptrsafe_VkRenderPassBeginInfo1076 VkRenderPassBeginInfo const *ptr() const { return reinterpret_cast<VkRenderPassBeginInfo const *>(this); } 1077 }; 1078 1079 struct safe_VkPhysicalDeviceSubgroupProperties { 1080 VkStructureType sType; 1081 void* pNext; 1082 uint32_t subgroupSize; 1083 VkShaderStageFlags supportedStages; 1084 VkSubgroupFeatureFlags supportedOperations; 1085 VkBool32 quadOperationsInAllStages; 1086 safe_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties* in_struct); 1087 safe_VkPhysicalDeviceSubgroupProperties(const safe_VkPhysicalDeviceSubgroupProperties& src); 1088 safe_VkPhysicalDeviceSubgroupProperties& operator=(const safe_VkPhysicalDeviceSubgroupProperties& src); 1089 safe_VkPhysicalDeviceSubgroupProperties(); 1090 ~safe_VkPhysicalDeviceSubgroupProperties(); 1091 void initialize(const VkPhysicalDeviceSubgroupProperties* in_struct); 1092 void initialize(const safe_VkPhysicalDeviceSubgroupProperties* src); ptrsafe_VkPhysicalDeviceSubgroupProperties1093 VkPhysicalDeviceSubgroupProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceSubgroupProperties *>(this); } ptrsafe_VkPhysicalDeviceSubgroupProperties1094 VkPhysicalDeviceSubgroupProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSubgroupProperties const *>(this); } 1095 }; 1096 1097 struct safe_VkBindBufferMemoryInfo { 1098 VkStructureType sType; 1099 const void* pNext; 1100 VkBuffer buffer; 1101 VkDeviceMemory memory; 1102 VkDeviceSize memoryOffset; 1103 safe_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo* in_struct); 1104 safe_VkBindBufferMemoryInfo(const safe_VkBindBufferMemoryInfo& src); 1105 safe_VkBindBufferMemoryInfo& operator=(const safe_VkBindBufferMemoryInfo& src); 1106 safe_VkBindBufferMemoryInfo(); 1107 ~safe_VkBindBufferMemoryInfo(); 1108 void initialize(const VkBindBufferMemoryInfo* in_struct); 1109 void initialize(const safe_VkBindBufferMemoryInfo* src); ptrsafe_VkBindBufferMemoryInfo1110 VkBindBufferMemoryInfo *ptr() { return reinterpret_cast<VkBindBufferMemoryInfo *>(this); } ptrsafe_VkBindBufferMemoryInfo1111 VkBindBufferMemoryInfo const *ptr() const { return reinterpret_cast<VkBindBufferMemoryInfo const *>(this); } 1112 }; 1113 1114 struct safe_VkBindImageMemoryInfo { 1115 VkStructureType sType; 1116 const void* pNext; 1117 VkImage image; 1118 VkDeviceMemory memory; 1119 VkDeviceSize memoryOffset; 1120 safe_VkBindImageMemoryInfo(const VkBindImageMemoryInfo* in_struct); 1121 safe_VkBindImageMemoryInfo(const safe_VkBindImageMemoryInfo& src); 1122 safe_VkBindImageMemoryInfo& operator=(const safe_VkBindImageMemoryInfo& src); 1123 safe_VkBindImageMemoryInfo(); 1124 ~safe_VkBindImageMemoryInfo(); 1125 void initialize(const VkBindImageMemoryInfo* in_struct); 1126 void initialize(const safe_VkBindImageMemoryInfo* src); ptrsafe_VkBindImageMemoryInfo1127 VkBindImageMemoryInfo *ptr() { return reinterpret_cast<VkBindImageMemoryInfo *>(this); } ptrsafe_VkBindImageMemoryInfo1128 VkBindImageMemoryInfo const *ptr() const { return reinterpret_cast<VkBindImageMemoryInfo const *>(this); } 1129 }; 1130 1131 struct safe_VkPhysicalDevice16BitStorageFeatures { 1132 VkStructureType sType; 1133 void* pNext; 1134 VkBool32 storageBuffer16BitAccess; 1135 VkBool32 uniformAndStorageBuffer16BitAccess; 1136 VkBool32 storagePushConstant16; 1137 VkBool32 storageInputOutput16; 1138 safe_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures* in_struct); 1139 safe_VkPhysicalDevice16BitStorageFeatures(const safe_VkPhysicalDevice16BitStorageFeatures& src); 1140 safe_VkPhysicalDevice16BitStorageFeatures& operator=(const safe_VkPhysicalDevice16BitStorageFeatures& src); 1141 safe_VkPhysicalDevice16BitStorageFeatures(); 1142 ~safe_VkPhysicalDevice16BitStorageFeatures(); 1143 void initialize(const VkPhysicalDevice16BitStorageFeatures* in_struct); 1144 void initialize(const safe_VkPhysicalDevice16BitStorageFeatures* src); ptrsafe_VkPhysicalDevice16BitStorageFeatures1145 VkPhysicalDevice16BitStorageFeatures *ptr() { return reinterpret_cast<VkPhysicalDevice16BitStorageFeatures *>(this); } ptrsafe_VkPhysicalDevice16BitStorageFeatures1146 VkPhysicalDevice16BitStorageFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDevice16BitStorageFeatures const *>(this); } 1147 }; 1148 1149 struct safe_VkMemoryDedicatedRequirements { 1150 VkStructureType sType; 1151 void* pNext; 1152 VkBool32 prefersDedicatedAllocation; 1153 VkBool32 requiresDedicatedAllocation; 1154 safe_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements* in_struct); 1155 safe_VkMemoryDedicatedRequirements(const safe_VkMemoryDedicatedRequirements& src); 1156 safe_VkMemoryDedicatedRequirements& operator=(const safe_VkMemoryDedicatedRequirements& src); 1157 safe_VkMemoryDedicatedRequirements(); 1158 ~safe_VkMemoryDedicatedRequirements(); 1159 void initialize(const VkMemoryDedicatedRequirements* in_struct); 1160 void initialize(const safe_VkMemoryDedicatedRequirements* src); ptrsafe_VkMemoryDedicatedRequirements1161 VkMemoryDedicatedRequirements *ptr() { return reinterpret_cast<VkMemoryDedicatedRequirements *>(this); } ptrsafe_VkMemoryDedicatedRequirements1162 VkMemoryDedicatedRequirements const *ptr() const { return reinterpret_cast<VkMemoryDedicatedRequirements const *>(this); } 1163 }; 1164 1165 struct safe_VkMemoryDedicatedAllocateInfo { 1166 VkStructureType sType; 1167 const void* pNext; 1168 VkImage image; 1169 VkBuffer buffer; 1170 safe_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo* in_struct); 1171 safe_VkMemoryDedicatedAllocateInfo(const safe_VkMemoryDedicatedAllocateInfo& src); 1172 safe_VkMemoryDedicatedAllocateInfo& operator=(const safe_VkMemoryDedicatedAllocateInfo& src); 1173 safe_VkMemoryDedicatedAllocateInfo(); 1174 ~safe_VkMemoryDedicatedAllocateInfo(); 1175 void initialize(const VkMemoryDedicatedAllocateInfo* in_struct); 1176 void initialize(const safe_VkMemoryDedicatedAllocateInfo* src); ptrsafe_VkMemoryDedicatedAllocateInfo1177 VkMemoryDedicatedAllocateInfo *ptr() { return reinterpret_cast<VkMemoryDedicatedAllocateInfo *>(this); } ptrsafe_VkMemoryDedicatedAllocateInfo1178 VkMemoryDedicatedAllocateInfo const *ptr() const { return reinterpret_cast<VkMemoryDedicatedAllocateInfo const *>(this); } 1179 }; 1180 1181 struct safe_VkMemoryAllocateFlagsInfo { 1182 VkStructureType sType; 1183 const void* pNext; 1184 VkMemoryAllocateFlags flags; 1185 uint32_t deviceMask; 1186 safe_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo* in_struct); 1187 safe_VkMemoryAllocateFlagsInfo(const safe_VkMemoryAllocateFlagsInfo& src); 1188 safe_VkMemoryAllocateFlagsInfo& operator=(const safe_VkMemoryAllocateFlagsInfo& src); 1189 safe_VkMemoryAllocateFlagsInfo(); 1190 ~safe_VkMemoryAllocateFlagsInfo(); 1191 void initialize(const VkMemoryAllocateFlagsInfo* in_struct); 1192 void initialize(const safe_VkMemoryAllocateFlagsInfo* src); ptrsafe_VkMemoryAllocateFlagsInfo1193 VkMemoryAllocateFlagsInfo *ptr() { return reinterpret_cast<VkMemoryAllocateFlagsInfo *>(this); } ptrsafe_VkMemoryAllocateFlagsInfo1194 VkMemoryAllocateFlagsInfo const *ptr() const { return reinterpret_cast<VkMemoryAllocateFlagsInfo const *>(this); } 1195 }; 1196 1197 struct safe_VkDeviceGroupRenderPassBeginInfo { 1198 VkStructureType sType; 1199 const void* pNext; 1200 uint32_t deviceMask; 1201 uint32_t deviceRenderAreaCount; 1202 const VkRect2D* pDeviceRenderAreas; 1203 safe_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo* in_struct); 1204 safe_VkDeviceGroupRenderPassBeginInfo(const safe_VkDeviceGroupRenderPassBeginInfo& src); 1205 safe_VkDeviceGroupRenderPassBeginInfo& operator=(const safe_VkDeviceGroupRenderPassBeginInfo& src); 1206 safe_VkDeviceGroupRenderPassBeginInfo(); 1207 ~safe_VkDeviceGroupRenderPassBeginInfo(); 1208 void initialize(const VkDeviceGroupRenderPassBeginInfo* in_struct); 1209 void initialize(const safe_VkDeviceGroupRenderPassBeginInfo* src); ptrsafe_VkDeviceGroupRenderPassBeginInfo1210 VkDeviceGroupRenderPassBeginInfo *ptr() { return reinterpret_cast<VkDeviceGroupRenderPassBeginInfo *>(this); } ptrsafe_VkDeviceGroupRenderPassBeginInfo1211 VkDeviceGroupRenderPassBeginInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupRenderPassBeginInfo const *>(this); } 1212 }; 1213 1214 struct safe_VkDeviceGroupCommandBufferBeginInfo { 1215 VkStructureType sType; 1216 const void* pNext; 1217 uint32_t deviceMask; 1218 safe_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo* in_struct); 1219 safe_VkDeviceGroupCommandBufferBeginInfo(const safe_VkDeviceGroupCommandBufferBeginInfo& src); 1220 safe_VkDeviceGroupCommandBufferBeginInfo& operator=(const safe_VkDeviceGroupCommandBufferBeginInfo& src); 1221 safe_VkDeviceGroupCommandBufferBeginInfo(); 1222 ~safe_VkDeviceGroupCommandBufferBeginInfo(); 1223 void initialize(const VkDeviceGroupCommandBufferBeginInfo* in_struct); 1224 void initialize(const safe_VkDeviceGroupCommandBufferBeginInfo* src); ptrsafe_VkDeviceGroupCommandBufferBeginInfo1225 VkDeviceGroupCommandBufferBeginInfo *ptr() { return reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo *>(this); } ptrsafe_VkDeviceGroupCommandBufferBeginInfo1226 VkDeviceGroupCommandBufferBeginInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo const *>(this); } 1227 }; 1228 1229 struct safe_VkDeviceGroupSubmitInfo { 1230 VkStructureType sType; 1231 const void* pNext; 1232 uint32_t waitSemaphoreCount; 1233 const uint32_t* pWaitSemaphoreDeviceIndices; 1234 uint32_t commandBufferCount; 1235 const uint32_t* pCommandBufferDeviceMasks; 1236 uint32_t signalSemaphoreCount; 1237 const uint32_t* pSignalSemaphoreDeviceIndices; 1238 safe_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo* in_struct); 1239 safe_VkDeviceGroupSubmitInfo(const safe_VkDeviceGroupSubmitInfo& src); 1240 safe_VkDeviceGroupSubmitInfo& operator=(const safe_VkDeviceGroupSubmitInfo& src); 1241 safe_VkDeviceGroupSubmitInfo(); 1242 ~safe_VkDeviceGroupSubmitInfo(); 1243 void initialize(const VkDeviceGroupSubmitInfo* in_struct); 1244 void initialize(const safe_VkDeviceGroupSubmitInfo* src); ptrsafe_VkDeviceGroupSubmitInfo1245 VkDeviceGroupSubmitInfo *ptr() { return reinterpret_cast<VkDeviceGroupSubmitInfo *>(this); } ptrsafe_VkDeviceGroupSubmitInfo1246 VkDeviceGroupSubmitInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupSubmitInfo const *>(this); } 1247 }; 1248 1249 struct safe_VkDeviceGroupBindSparseInfo { 1250 VkStructureType sType; 1251 const void* pNext; 1252 uint32_t resourceDeviceIndex; 1253 uint32_t memoryDeviceIndex; 1254 safe_VkDeviceGroupBindSparseInfo(const VkDeviceGroupBindSparseInfo* in_struct); 1255 safe_VkDeviceGroupBindSparseInfo(const safe_VkDeviceGroupBindSparseInfo& src); 1256 safe_VkDeviceGroupBindSparseInfo& operator=(const safe_VkDeviceGroupBindSparseInfo& src); 1257 safe_VkDeviceGroupBindSparseInfo(); 1258 ~safe_VkDeviceGroupBindSparseInfo(); 1259 void initialize(const VkDeviceGroupBindSparseInfo* in_struct); 1260 void initialize(const safe_VkDeviceGroupBindSparseInfo* src); ptrsafe_VkDeviceGroupBindSparseInfo1261 VkDeviceGroupBindSparseInfo *ptr() { return reinterpret_cast<VkDeviceGroupBindSparseInfo *>(this); } ptrsafe_VkDeviceGroupBindSparseInfo1262 VkDeviceGroupBindSparseInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupBindSparseInfo const *>(this); } 1263 }; 1264 1265 struct safe_VkBindBufferMemoryDeviceGroupInfo { 1266 VkStructureType sType; 1267 const void* pNext; 1268 uint32_t deviceIndexCount; 1269 const uint32_t* pDeviceIndices; 1270 safe_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo* in_struct); 1271 safe_VkBindBufferMemoryDeviceGroupInfo(const safe_VkBindBufferMemoryDeviceGroupInfo& src); 1272 safe_VkBindBufferMemoryDeviceGroupInfo& operator=(const safe_VkBindBufferMemoryDeviceGroupInfo& src); 1273 safe_VkBindBufferMemoryDeviceGroupInfo(); 1274 ~safe_VkBindBufferMemoryDeviceGroupInfo(); 1275 void initialize(const VkBindBufferMemoryDeviceGroupInfo* in_struct); 1276 void initialize(const safe_VkBindBufferMemoryDeviceGroupInfo* src); ptrsafe_VkBindBufferMemoryDeviceGroupInfo1277 VkBindBufferMemoryDeviceGroupInfo *ptr() { return reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo *>(this); } ptrsafe_VkBindBufferMemoryDeviceGroupInfo1278 VkBindBufferMemoryDeviceGroupInfo const *ptr() const { return reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo const *>(this); } 1279 }; 1280 1281 struct safe_VkBindImageMemoryDeviceGroupInfo { 1282 VkStructureType sType; 1283 const void* pNext; 1284 uint32_t deviceIndexCount; 1285 const uint32_t* pDeviceIndices; 1286 uint32_t splitInstanceBindRegionCount; 1287 const VkRect2D* pSplitInstanceBindRegions; 1288 safe_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo* in_struct); 1289 safe_VkBindImageMemoryDeviceGroupInfo(const safe_VkBindImageMemoryDeviceGroupInfo& src); 1290 safe_VkBindImageMemoryDeviceGroupInfo& operator=(const safe_VkBindImageMemoryDeviceGroupInfo& src); 1291 safe_VkBindImageMemoryDeviceGroupInfo(); 1292 ~safe_VkBindImageMemoryDeviceGroupInfo(); 1293 void initialize(const VkBindImageMemoryDeviceGroupInfo* in_struct); 1294 void initialize(const safe_VkBindImageMemoryDeviceGroupInfo* src); ptrsafe_VkBindImageMemoryDeviceGroupInfo1295 VkBindImageMemoryDeviceGroupInfo *ptr() { return reinterpret_cast<VkBindImageMemoryDeviceGroupInfo *>(this); } ptrsafe_VkBindImageMemoryDeviceGroupInfo1296 VkBindImageMemoryDeviceGroupInfo const *ptr() const { return reinterpret_cast<VkBindImageMemoryDeviceGroupInfo const *>(this); } 1297 }; 1298 1299 struct safe_VkPhysicalDeviceGroupProperties { 1300 VkStructureType sType; 1301 void* pNext; 1302 uint32_t physicalDeviceCount; 1303 VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; 1304 VkBool32 subsetAllocation; 1305 safe_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties* in_struct); 1306 safe_VkPhysicalDeviceGroupProperties(const safe_VkPhysicalDeviceGroupProperties& src); 1307 safe_VkPhysicalDeviceGroupProperties& operator=(const safe_VkPhysicalDeviceGroupProperties& src); 1308 safe_VkPhysicalDeviceGroupProperties(); 1309 ~safe_VkPhysicalDeviceGroupProperties(); 1310 void initialize(const VkPhysicalDeviceGroupProperties* in_struct); 1311 void initialize(const safe_VkPhysicalDeviceGroupProperties* src); ptrsafe_VkPhysicalDeviceGroupProperties1312 VkPhysicalDeviceGroupProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceGroupProperties *>(this); } ptrsafe_VkPhysicalDeviceGroupProperties1313 VkPhysicalDeviceGroupProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceGroupProperties const *>(this); } 1314 }; 1315 1316 struct safe_VkDeviceGroupDeviceCreateInfo { 1317 VkStructureType sType; 1318 const void* pNext; 1319 uint32_t physicalDeviceCount; 1320 VkPhysicalDevice* pPhysicalDevices; 1321 safe_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo* in_struct); 1322 safe_VkDeviceGroupDeviceCreateInfo(const safe_VkDeviceGroupDeviceCreateInfo& src); 1323 safe_VkDeviceGroupDeviceCreateInfo& operator=(const safe_VkDeviceGroupDeviceCreateInfo& src); 1324 safe_VkDeviceGroupDeviceCreateInfo(); 1325 ~safe_VkDeviceGroupDeviceCreateInfo(); 1326 void initialize(const VkDeviceGroupDeviceCreateInfo* in_struct); 1327 void initialize(const safe_VkDeviceGroupDeviceCreateInfo* src); ptrsafe_VkDeviceGroupDeviceCreateInfo1328 VkDeviceGroupDeviceCreateInfo *ptr() { return reinterpret_cast<VkDeviceGroupDeviceCreateInfo *>(this); } ptrsafe_VkDeviceGroupDeviceCreateInfo1329 VkDeviceGroupDeviceCreateInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupDeviceCreateInfo const *>(this); } 1330 }; 1331 1332 struct safe_VkBufferMemoryRequirementsInfo2 { 1333 VkStructureType sType; 1334 const void* pNext; 1335 VkBuffer buffer; 1336 safe_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2* in_struct); 1337 safe_VkBufferMemoryRequirementsInfo2(const safe_VkBufferMemoryRequirementsInfo2& src); 1338 safe_VkBufferMemoryRequirementsInfo2& operator=(const safe_VkBufferMemoryRequirementsInfo2& src); 1339 safe_VkBufferMemoryRequirementsInfo2(); 1340 ~safe_VkBufferMemoryRequirementsInfo2(); 1341 void initialize(const VkBufferMemoryRequirementsInfo2* in_struct); 1342 void initialize(const safe_VkBufferMemoryRequirementsInfo2* src); ptrsafe_VkBufferMemoryRequirementsInfo21343 VkBufferMemoryRequirementsInfo2 *ptr() { return reinterpret_cast<VkBufferMemoryRequirementsInfo2 *>(this); } ptrsafe_VkBufferMemoryRequirementsInfo21344 VkBufferMemoryRequirementsInfo2 const *ptr() const { return reinterpret_cast<VkBufferMemoryRequirementsInfo2 const *>(this); } 1345 }; 1346 1347 struct safe_VkImageMemoryRequirementsInfo2 { 1348 VkStructureType sType; 1349 const void* pNext; 1350 VkImage image; 1351 safe_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2* in_struct); 1352 safe_VkImageMemoryRequirementsInfo2(const safe_VkImageMemoryRequirementsInfo2& src); 1353 safe_VkImageMemoryRequirementsInfo2& operator=(const safe_VkImageMemoryRequirementsInfo2& src); 1354 safe_VkImageMemoryRequirementsInfo2(); 1355 ~safe_VkImageMemoryRequirementsInfo2(); 1356 void initialize(const VkImageMemoryRequirementsInfo2* in_struct); 1357 void initialize(const safe_VkImageMemoryRequirementsInfo2* src); ptrsafe_VkImageMemoryRequirementsInfo21358 VkImageMemoryRequirementsInfo2 *ptr() { return reinterpret_cast<VkImageMemoryRequirementsInfo2 *>(this); } ptrsafe_VkImageMemoryRequirementsInfo21359 VkImageMemoryRequirementsInfo2 const *ptr() const { return reinterpret_cast<VkImageMemoryRequirementsInfo2 const *>(this); } 1360 }; 1361 1362 struct safe_VkImageSparseMemoryRequirementsInfo2 { 1363 VkStructureType sType; 1364 const void* pNext; 1365 VkImage image; 1366 safe_VkImageSparseMemoryRequirementsInfo2(const VkImageSparseMemoryRequirementsInfo2* in_struct); 1367 safe_VkImageSparseMemoryRequirementsInfo2(const safe_VkImageSparseMemoryRequirementsInfo2& src); 1368 safe_VkImageSparseMemoryRequirementsInfo2& operator=(const safe_VkImageSparseMemoryRequirementsInfo2& src); 1369 safe_VkImageSparseMemoryRequirementsInfo2(); 1370 ~safe_VkImageSparseMemoryRequirementsInfo2(); 1371 void initialize(const VkImageSparseMemoryRequirementsInfo2* in_struct); 1372 void initialize(const safe_VkImageSparseMemoryRequirementsInfo2* src); ptrsafe_VkImageSparseMemoryRequirementsInfo21373 VkImageSparseMemoryRequirementsInfo2 *ptr() { return reinterpret_cast<VkImageSparseMemoryRequirementsInfo2 *>(this); } ptrsafe_VkImageSparseMemoryRequirementsInfo21374 VkImageSparseMemoryRequirementsInfo2 const *ptr() const { return reinterpret_cast<VkImageSparseMemoryRequirementsInfo2 const *>(this); } 1375 }; 1376 1377 struct safe_VkMemoryRequirements2 { 1378 VkStructureType sType; 1379 void* pNext; 1380 VkMemoryRequirements memoryRequirements; 1381 safe_VkMemoryRequirements2(const VkMemoryRequirements2* in_struct); 1382 safe_VkMemoryRequirements2(const safe_VkMemoryRequirements2& src); 1383 safe_VkMemoryRequirements2& operator=(const safe_VkMemoryRequirements2& src); 1384 safe_VkMemoryRequirements2(); 1385 ~safe_VkMemoryRequirements2(); 1386 void initialize(const VkMemoryRequirements2* in_struct); 1387 void initialize(const safe_VkMemoryRequirements2* src); ptrsafe_VkMemoryRequirements21388 VkMemoryRequirements2 *ptr() { return reinterpret_cast<VkMemoryRequirements2 *>(this); } ptrsafe_VkMemoryRequirements21389 VkMemoryRequirements2 const *ptr() const { return reinterpret_cast<VkMemoryRequirements2 const *>(this); } 1390 }; 1391 1392 struct safe_VkSparseImageMemoryRequirements2 { 1393 VkStructureType sType; 1394 void* pNext; 1395 VkSparseImageMemoryRequirements memoryRequirements; 1396 safe_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2* in_struct); 1397 safe_VkSparseImageMemoryRequirements2(const safe_VkSparseImageMemoryRequirements2& src); 1398 safe_VkSparseImageMemoryRequirements2& operator=(const safe_VkSparseImageMemoryRequirements2& src); 1399 safe_VkSparseImageMemoryRequirements2(); 1400 ~safe_VkSparseImageMemoryRequirements2(); 1401 void initialize(const VkSparseImageMemoryRequirements2* in_struct); 1402 void initialize(const safe_VkSparseImageMemoryRequirements2* src); ptrsafe_VkSparseImageMemoryRequirements21403 VkSparseImageMemoryRequirements2 *ptr() { return reinterpret_cast<VkSparseImageMemoryRequirements2 *>(this); } ptrsafe_VkSparseImageMemoryRequirements21404 VkSparseImageMemoryRequirements2 const *ptr() const { return reinterpret_cast<VkSparseImageMemoryRequirements2 const *>(this); } 1405 }; 1406 1407 struct safe_VkPhysicalDeviceFeatures2 { 1408 VkStructureType sType; 1409 void* pNext; 1410 VkPhysicalDeviceFeatures features; 1411 safe_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2* in_struct); 1412 safe_VkPhysicalDeviceFeatures2(const safe_VkPhysicalDeviceFeatures2& src); 1413 safe_VkPhysicalDeviceFeatures2& operator=(const safe_VkPhysicalDeviceFeatures2& src); 1414 safe_VkPhysicalDeviceFeatures2(); 1415 ~safe_VkPhysicalDeviceFeatures2(); 1416 void initialize(const VkPhysicalDeviceFeatures2* in_struct); 1417 void initialize(const safe_VkPhysicalDeviceFeatures2* src); ptrsafe_VkPhysicalDeviceFeatures21418 VkPhysicalDeviceFeatures2 *ptr() { return reinterpret_cast<VkPhysicalDeviceFeatures2 *>(this); } ptrsafe_VkPhysicalDeviceFeatures21419 VkPhysicalDeviceFeatures2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFeatures2 const *>(this); } 1420 }; 1421 1422 struct safe_VkPhysicalDeviceProperties2 { 1423 VkStructureType sType; 1424 void* pNext; 1425 VkPhysicalDeviceProperties properties; 1426 safe_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2* in_struct); 1427 safe_VkPhysicalDeviceProperties2(const safe_VkPhysicalDeviceProperties2& src); 1428 safe_VkPhysicalDeviceProperties2& operator=(const safe_VkPhysicalDeviceProperties2& src); 1429 safe_VkPhysicalDeviceProperties2(); 1430 ~safe_VkPhysicalDeviceProperties2(); 1431 void initialize(const VkPhysicalDeviceProperties2* in_struct); 1432 void initialize(const safe_VkPhysicalDeviceProperties2* src); ptrsafe_VkPhysicalDeviceProperties21433 VkPhysicalDeviceProperties2 *ptr() { return reinterpret_cast<VkPhysicalDeviceProperties2 *>(this); } ptrsafe_VkPhysicalDeviceProperties21434 VkPhysicalDeviceProperties2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceProperties2 const *>(this); } 1435 }; 1436 1437 struct safe_VkFormatProperties2 { 1438 VkStructureType sType; 1439 void* pNext; 1440 VkFormatProperties formatProperties; 1441 safe_VkFormatProperties2(const VkFormatProperties2* in_struct); 1442 safe_VkFormatProperties2(const safe_VkFormatProperties2& src); 1443 safe_VkFormatProperties2& operator=(const safe_VkFormatProperties2& src); 1444 safe_VkFormatProperties2(); 1445 ~safe_VkFormatProperties2(); 1446 void initialize(const VkFormatProperties2* in_struct); 1447 void initialize(const safe_VkFormatProperties2* src); ptrsafe_VkFormatProperties21448 VkFormatProperties2 *ptr() { return reinterpret_cast<VkFormatProperties2 *>(this); } ptrsafe_VkFormatProperties21449 VkFormatProperties2 const *ptr() const { return reinterpret_cast<VkFormatProperties2 const *>(this); } 1450 }; 1451 1452 struct safe_VkImageFormatProperties2 { 1453 VkStructureType sType; 1454 void* pNext; 1455 VkImageFormatProperties imageFormatProperties; 1456 safe_VkImageFormatProperties2(const VkImageFormatProperties2* in_struct); 1457 safe_VkImageFormatProperties2(const safe_VkImageFormatProperties2& src); 1458 safe_VkImageFormatProperties2& operator=(const safe_VkImageFormatProperties2& src); 1459 safe_VkImageFormatProperties2(); 1460 ~safe_VkImageFormatProperties2(); 1461 void initialize(const VkImageFormatProperties2* in_struct); 1462 void initialize(const safe_VkImageFormatProperties2* src); ptrsafe_VkImageFormatProperties21463 VkImageFormatProperties2 *ptr() { return reinterpret_cast<VkImageFormatProperties2 *>(this); } ptrsafe_VkImageFormatProperties21464 VkImageFormatProperties2 const *ptr() const { return reinterpret_cast<VkImageFormatProperties2 const *>(this); } 1465 }; 1466 1467 struct safe_VkPhysicalDeviceImageFormatInfo2 { 1468 VkStructureType sType; 1469 const void* pNext; 1470 VkFormat format; 1471 VkImageType type; 1472 VkImageTiling tiling; 1473 VkImageUsageFlags usage; 1474 VkImageCreateFlags flags; 1475 safe_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2* in_struct); 1476 safe_VkPhysicalDeviceImageFormatInfo2(const safe_VkPhysicalDeviceImageFormatInfo2& src); 1477 safe_VkPhysicalDeviceImageFormatInfo2& operator=(const safe_VkPhysicalDeviceImageFormatInfo2& src); 1478 safe_VkPhysicalDeviceImageFormatInfo2(); 1479 ~safe_VkPhysicalDeviceImageFormatInfo2(); 1480 void initialize(const VkPhysicalDeviceImageFormatInfo2* in_struct); 1481 void initialize(const safe_VkPhysicalDeviceImageFormatInfo2* src); ptrsafe_VkPhysicalDeviceImageFormatInfo21482 VkPhysicalDeviceImageFormatInfo2 *ptr() { return reinterpret_cast<VkPhysicalDeviceImageFormatInfo2 *>(this); } ptrsafe_VkPhysicalDeviceImageFormatInfo21483 VkPhysicalDeviceImageFormatInfo2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceImageFormatInfo2 const *>(this); } 1484 }; 1485 1486 struct safe_VkQueueFamilyProperties2 { 1487 VkStructureType sType; 1488 void* pNext; 1489 VkQueueFamilyProperties queueFamilyProperties; 1490 safe_VkQueueFamilyProperties2(const VkQueueFamilyProperties2* in_struct); 1491 safe_VkQueueFamilyProperties2(const safe_VkQueueFamilyProperties2& src); 1492 safe_VkQueueFamilyProperties2& operator=(const safe_VkQueueFamilyProperties2& src); 1493 safe_VkQueueFamilyProperties2(); 1494 ~safe_VkQueueFamilyProperties2(); 1495 void initialize(const VkQueueFamilyProperties2* in_struct); 1496 void initialize(const safe_VkQueueFamilyProperties2* src); ptrsafe_VkQueueFamilyProperties21497 VkQueueFamilyProperties2 *ptr() { return reinterpret_cast<VkQueueFamilyProperties2 *>(this); } ptrsafe_VkQueueFamilyProperties21498 VkQueueFamilyProperties2 const *ptr() const { return reinterpret_cast<VkQueueFamilyProperties2 const *>(this); } 1499 }; 1500 1501 struct safe_VkPhysicalDeviceMemoryProperties2 { 1502 VkStructureType sType; 1503 void* pNext; 1504 VkPhysicalDeviceMemoryProperties memoryProperties; 1505 safe_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2* in_struct); 1506 safe_VkPhysicalDeviceMemoryProperties2(const safe_VkPhysicalDeviceMemoryProperties2& src); 1507 safe_VkPhysicalDeviceMemoryProperties2& operator=(const safe_VkPhysicalDeviceMemoryProperties2& src); 1508 safe_VkPhysicalDeviceMemoryProperties2(); 1509 ~safe_VkPhysicalDeviceMemoryProperties2(); 1510 void initialize(const VkPhysicalDeviceMemoryProperties2* in_struct); 1511 void initialize(const safe_VkPhysicalDeviceMemoryProperties2* src); ptrsafe_VkPhysicalDeviceMemoryProperties21512 VkPhysicalDeviceMemoryProperties2 *ptr() { return reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>(this); } ptrsafe_VkPhysicalDeviceMemoryProperties21513 VkPhysicalDeviceMemoryProperties2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMemoryProperties2 const *>(this); } 1514 }; 1515 1516 struct safe_VkSparseImageFormatProperties2 { 1517 VkStructureType sType; 1518 void* pNext; 1519 VkSparseImageFormatProperties properties; 1520 safe_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2* in_struct); 1521 safe_VkSparseImageFormatProperties2(const safe_VkSparseImageFormatProperties2& src); 1522 safe_VkSparseImageFormatProperties2& operator=(const safe_VkSparseImageFormatProperties2& src); 1523 safe_VkSparseImageFormatProperties2(); 1524 ~safe_VkSparseImageFormatProperties2(); 1525 void initialize(const VkSparseImageFormatProperties2* in_struct); 1526 void initialize(const safe_VkSparseImageFormatProperties2* src); ptrsafe_VkSparseImageFormatProperties21527 VkSparseImageFormatProperties2 *ptr() { return reinterpret_cast<VkSparseImageFormatProperties2 *>(this); } ptrsafe_VkSparseImageFormatProperties21528 VkSparseImageFormatProperties2 const *ptr() const { return reinterpret_cast<VkSparseImageFormatProperties2 const *>(this); } 1529 }; 1530 1531 struct safe_VkPhysicalDeviceSparseImageFormatInfo2 { 1532 VkStructureType sType; 1533 const void* pNext; 1534 VkFormat format; 1535 VkImageType type; 1536 VkSampleCountFlagBits samples; 1537 VkImageUsageFlags usage; 1538 VkImageTiling tiling; 1539 safe_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct); 1540 safe_VkPhysicalDeviceSparseImageFormatInfo2(const safe_VkPhysicalDeviceSparseImageFormatInfo2& src); 1541 safe_VkPhysicalDeviceSparseImageFormatInfo2& operator=(const safe_VkPhysicalDeviceSparseImageFormatInfo2& src); 1542 safe_VkPhysicalDeviceSparseImageFormatInfo2(); 1543 ~safe_VkPhysicalDeviceSparseImageFormatInfo2(); 1544 void initialize(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct); 1545 void initialize(const safe_VkPhysicalDeviceSparseImageFormatInfo2* src); ptrsafe_VkPhysicalDeviceSparseImageFormatInfo21546 VkPhysicalDeviceSparseImageFormatInfo2 *ptr() { return reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2 *>(this); } ptrsafe_VkPhysicalDeviceSparseImageFormatInfo21547 VkPhysicalDeviceSparseImageFormatInfo2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2 const *>(this); } 1548 }; 1549 1550 struct safe_VkPhysicalDevicePointClippingProperties { 1551 VkStructureType sType; 1552 void* pNext; 1553 VkPointClippingBehavior pointClippingBehavior; 1554 safe_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties* in_struct); 1555 safe_VkPhysicalDevicePointClippingProperties(const safe_VkPhysicalDevicePointClippingProperties& src); 1556 safe_VkPhysicalDevicePointClippingProperties& operator=(const safe_VkPhysicalDevicePointClippingProperties& src); 1557 safe_VkPhysicalDevicePointClippingProperties(); 1558 ~safe_VkPhysicalDevicePointClippingProperties(); 1559 void initialize(const VkPhysicalDevicePointClippingProperties* in_struct); 1560 void initialize(const safe_VkPhysicalDevicePointClippingProperties* src); ptrsafe_VkPhysicalDevicePointClippingProperties1561 VkPhysicalDevicePointClippingProperties *ptr() { return reinterpret_cast<VkPhysicalDevicePointClippingProperties *>(this); } ptrsafe_VkPhysicalDevicePointClippingProperties1562 VkPhysicalDevicePointClippingProperties const *ptr() const { return reinterpret_cast<VkPhysicalDevicePointClippingProperties const *>(this); } 1563 }; 1564 1565 struct safe_VkRenderPassInputAttachmentAspectCreateInfo { 1566 VkStructureType sType; 1567 const void* pNext; 1568 uint32_t aspectReferenceCount; 1569 const VkInputAttachmentAspectReference* pAspectReferences; 1570 safe_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct); 1571 safe_VkRenderPassInputAttachmentAspectCreateInfo(const safe_VkRenderPassInputAttachmentAspectCreateInfo& src); 1572 safe_VkRenderPassInputAttachmentAspectCreateInfo& operator=(const safe_VkRenderPassInputAttachmentAspectCreateInfo& src); 1573 safe_VkRenderPassInputAttachmentAspectCreateInfo(); 1574 ~safe_VkRenderPassInputAttachmentAspectCreateInfo(); 1575 void initialize(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct); 1576 void initialize(const safe_VkRenderPassInputAttachmentAspectCreateInfo* src); ptrsafe_VkRenderPassInputAttachmentAspectCreateInfo1577 VkRenderPassInputAttachmentAspectCreateInfo *ptr() { return reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo *>(this); } ptrsafe_VkRenderPassInputAttachmentAspectCreateInfo1578 VkRenderPassInputAttachmentAspectCreateInfo const *ptr() const { return reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo const *>(this); } 1579 }; 1580 1581 struct safe_VkImageViewUsageCreateInfo { 1582 VkStructureType sType; 1583 const void* pNext; 1584 VkImageUsageFlags usage; 1585 safe_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo* in_struct); 1586 safe_VkImageViewUsageCreateInfo(const safe_VkImageViewUsageCreateInfo& src); 1587 safe_VkImageViewUsageCreateInfo& operator=(const safe_VkImageViewUsageCreateInfo& src); 1588 safe_VkImageViewUsageCreateInfo(); 1589 ~safe_VkImageViewUsageCreateInfo(); 1590 void initialize(const VkImageViewUsageCreateInfo* in_struct); 1591 void initialize(const safe_VkImageViewUsageCreateInfo* src); ptrsafe_VkImageViewUsageCreateInfo1592 VkImageViewUsageCreateInfo *ptr() { return reinterpret_cast<VkImageViewUsageCreateInfo *>(this); } ptrsafe_VkImageViewUsageCreateInfo1593 VkImageViewUsageCreateInfo const *ptr() const { return reinterpret_cast<VkImageViewUsageCreateInfo const *>(this); } 1594 }; 1595 1596 struct safe_VkPipelineTessellationDomainOriginStateCreateInfo { 1597 VkStructureType sType; 1598 const void* pNext; 1599 VkTessellationDomainOrigin domainOrigin; 1600 safe_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct); 1601 safe_VkPipelineTessellationDomainOriginStateCreateInfo(const safe_VkPipelineTessellationDomainOriginStateCreateInfo& src); 1602 safe_VkPipelineTessellationDomainOriginStateCreateInfo& operator=(const safe_VkPipelineTessellationDomainOriginStateCreateInfo& src); 1603 safe_VkPipelineTessellationDomainOriginStateCreateInfo(); 1604 ~safe_VkPipelineTessellationDomainOriginStateCreateInfo(); 1605 void initialize(const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct); 1606 void initialize(const safe_VkPipelineTessellationDomainOriginStateCreateInfo* src); ptrsafe_VkPipelineTessellationDomainOriginStateCreateInfo1607 VkPipelineTessellationDomainOriginStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo *>(this); } ptrsafe_VkPipelineTessellationDomainOriginStateCreateInfo1608 VkPipelineTessellationDomainOriginStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo const *>(this); } 1609 }; 1610 1611 struct safe_VkRenderPassMultiviewCreateInfo { 1612 VkStructureType sType; 1613 const void* pNext; 1614 uint32_t subpassCount; 1615 const uint32_t* pViewMasks; 1616 uint32_t dependencyCount; 1617 const int32_t* pViewOffsets; 1618 uint32_t correlationMaskCount; 1619 const uint32_t* pCorrelationMasks; 1620 safe_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo* in_struct); 1621 safe_VkRenderPassMultiviewCreateInfo(const safe_VkRenderPassMultiviewCreateInfo& src); 1622 safe_VkRenderPassMultiviewCreateInfo& operator=(const safe_VkRenderPassMultiviewCreateInfo& src); 1623 safe_VkRenderPassMultiviewCreateInfo(); 1624 ~safe_VkRenderPassMultiviewCreateInfo(); 1625 void initialize(const VkRenderPassMultiviewCreateInfo* in_struct); 1626 void initialize(const safe_VkRenderPassMultiviewCreateInfo* src); ptrsafe_VkRenderPassMultiviewCreateInfo1627 VkRenderPassMultiviewCreateInfo *ptr() { return reinterpret_cast<VkRenderPassMultiviewCreateInfo *>(this); } ptrsafe_VkRenderPassMultiviewCreateInfo1628 VkRenderPassMultiviewCreateInfo const *ptr() const { return reinterpret_cast<VkRenderPassMultiviewCreateInfo const *>(this); } 1629 }; 1630 1631 struct safe_VkPhysicalDeviceMultiviewFeatures { 1632 VkStructureType sType; 1633 void* pNext; 1634 VkBool32 multiview; 1635 VkBool32 multiviewGeometryShader; 1636 VkBool32 multiviewTessellationShader; 1637 safe_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures* in_struct); 1638 safe_VkPhysicalDeviceMultiviewFeatures(const safe_VkPhysicalDeviceMultiviewFeatures& src); 1639 safe_VkPhysicalDeviceMultiviewFeatures& operator=(const safe_VkPhysicalDeviceMultiviewFeatures& src); 1640 safe_VkPhysicalDeviceMultiviewFeatures(); 1641 ~safe_VkPhysicalDeviceMultiviewFeatures(); 1642 void initialize(const VkPhysicalDeviceMultiviewFeatures* in_struct); 1643 void initialize(const safe_VkPhysicalDeviceMultiviewFeatures* src); ptrsafe_VkPhysicalDeviceMultiviewFeatures1644 VkPhysicalDeviceMultiviewFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceMultiviewFeatures *>(this); } ptrsafe_VkPhysicalDeviceMultiviewFeatures1645 VkPhysicalDeviceMultiviewFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMultiviewFeatures const *>(this); } 1646 }; 1647 1648 struct safe_VkPhysicalDeviceMultiviewProperties { 1649 VkStructureType sType; 1650 void* pNext; 1651 uint32_t maxMultiviewViewCount; 1652 uint32_t maxMultiviewInstanceIndex; 1653 safe_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties* in_struct); 1654 safe_VkPhysicalDeviceMultiviewProperties(const safe_VkPhysicalDeviceMultiviewProperties& src); 1655 safe_VkPhysicalDeviceMultiviewProperties& operator=(const safe_VkPhysicalDeviceMultiviewProperties& src); 1656 safe_VkPhysicalDeviceMultiviewProperties(); 1657 ~safe_VkPhysicalDeviceMultiviewProperties(); 1658 void initialize(const VkPhysicalDeviceMultiviewProperties* in_struct); 1659 void initialize(const safe_VkPhysicalDeviceMultiviewProperties* src); ptrsafe_VkPhysicalDeviceMultiviewProperties1660 VkPhysicalDeviceMultiviewProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceMultiviewProperties *>(this); } ptrsafe_VkPhysicalDeviceMultiviewProperties1661 VkPhysicalDeviceMultiviewProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMultiviewProperties const *>(this); } 1662 }; 1663 1664 struct safe_VkPhysicalDeviceVariablePointersFeatures { 1665 VkStructureType sType; 1666 void* pNext; 1667 VkBool32 variablePointersStorageBuffer; 1668 VkBool32 variablePointers; 1669 safe_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures* in_struct); 1670 safe_VkPhysicalDeviceVariablePointersFeatures(const safe_VkPhysicalDeviceVariablePointersFeatures& src); 1671 safe_VkPhysicalDeviceVariablePointersFeatures& operator=(const safe_VkPhysicalDeviceVariablePointersFeatures& src); 1672 safe_VkPhysicalDeviceVariablePointersFeatures(); 1673 ~safe_VkPhysicalDeviceVariablePointersFeatures(); 1674 void initialize(const VkPhysicalDeviceVariablePointersFeatures* in_struct); 1675 void initialize(const safe_VkPhysicalDeviceVariablePointersFeatures* src); ptrsafe_VkPhysicalDeviceVariablePointersFeatures1676 VkPhysicalDeviceVariablePointersFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures *>(this); } ptrsafe_VkPhysicalDeviceVariablePointersFeatures1677 VkPhysicalDeviceVariablePointersFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures const *>(this); } 1678 }; 1679 1680 struct safe_VkPhysicalDeviceProtectedMemoryFeatures { 1681 VkStructureType sType; 1682 void* pNext; 1683 VkBool32 protectedMemory; 1684 safe_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct); 1685 safe_VkPhysicalDeviceProtectedMemoryFeatures(const safe_VkPhysicalDeviceProtectedMemoryFeatures& src); 1686 safe_VkPhysicalDeviceProtectedMemoryFeatures& operator=(const safe_VkPhysicalDeviceProtectedMemoryFeatures& src); 1687 safe_VkPhysicalDeviceProtectedMemoryFeatures(); 1688 ~safe_VkPhysicalDeviceProtectedMemoryFeatures(); 1689 void initialize(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct); 1690 void initialize(const safe_VkPhysicalDeviceProtectedMemoryFeatures* src); ptrsafe_VkPhysicalDeviceProtectedMemoryFeatures1691 VkPhysicalDeviceProtectedMemoryFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures *>(this); } ptrsafe_VkPhysicalDeviceProtectedMemoryFeatures1692 VkPhysicalDeviceProtectedMemoryFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures const *>(this); } 1693 }; 1694 1695 struct safe_VkPhysicalDeviceProtectedMemoryProperties { 1696 VkStructureType sType; 1697 void* pNext; 1698 VkBool32 protectedNoFault; 1699 safe_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties* in_struct); 1700 safe_VkPhysicalDeviceProtectedMemoryProperties(const safe_VkPhysicalDeviceProtectedMemoryProperties& src); 1701 safe_VkPhysicalDeviceProtectedMemoryProperties& operator=(const safe_VkPhysicalDeviceProtectedMemoryProperties& src); 1702 safe_VkPhysicalDeviceProtectedMemoryProperties(); 1703 ~safe_VkPhysicalDeviceProtectedMemoryProperties(); 1704 void initialize(const VkPhysicalDeviceProtectedMemoryProperties* in_struct); 1705 void initialize(const safe_VkPhysicalDeviceProtectedMemoryProperties* src); ptrsafe_VkPhysicalDeviceProtectedMemoryProperties1706 VkPhysicalDeviceProtectedMemoryProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties *>(this); } ptrsafe_VkPhysicalDeviceProtectedMemoryProperties1707 VkPhysicalDeviceProtectedMemoryProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties const *>(this); } 1708 }; 1709 1710 struct safe_VkDeviceQueueInfo2 { 1711 VkStructureType sType; 1712 const void* pNext; 1713 VkDeviceQueueCreateFlags flags; 1714 uint32_t queueFamilyIndex; 1715 uint32_t queueIndex; 1716 safe_VkDeviceQueueInfo2(const VkDeviceQueueInfo2* in_struct); 1717 safe_VkDeviceQueueInfo2(const safe_VkDeviceQueueInfo2& src); 1718 safe_VkDeviceQueueInfo2& operator=(const safe_VkDeviceQueueInfo2& src); 1719 safe_VkDeviceQueueInfo2(); 1720 ~safe_VkDeviceQueueInfo2(); 1721 void initialize(const VkDeviceQueueInfo2* in_struct); 1722 void initialize(const safe_VkDeviceQueueInfo2* src); ptrsafe_VkDeviceQueueInfo21723 VkDeviceQueueInfo2 *ptr() { return reinterpret_cast<VkDeviceQueueInfo2 *>(this); } ptrsafe_VkDeviceQueueInfo21724 VkDeviceQueueInfo2 const *ptr() const { return reinterpret_cast<VkDeviceQueueInfo2 const *>(this); } 1725 }; 1726 1727 struct safe_VkProtectedSubmitInfo { 1728 VkStructureType sType; 1729 const void* pNext; 1730 VkBool32 protectedSubmit; 1731 safe_VkProtectedSubmitInfo(const VkProtectedSubmitInfo* in_struct); 1732 safe_VkProtectedSubmitInfo(const safe_VkProtectedSubmitInfo& src); 1733 safe_VkProtectedSubmitInfo& operator=(const safe_VkProtectedSubmitInfo& src); 1734 safe_VkProtectedSubmitInfo(); 1735 ~safe_VkProtectedSubmitInfo(); 1736 void initialize(const VkProtectedSubmitInfo* in_struct); 1737 void initialize(const safe_VkProtectedSubmitInfo* src); ptrsafe_VkProtectedSubmitInfo1738 VkProtectedSubmitInfo *ptr() { return reinterpret_cast<VkProtectedSubmitInfo *>(this); } ptrsafe_VkProtectedSubmitInfo1739 VkProtectedSubmitInfo const *ptr() const { return reinterpret_cast<VkProtectedSubmitInfo const *>(this); } 1740 }; 1741 1742 struct safe_VkSamplerYcbcrConversionCreateInfo { 1743 VkStructureType sType; 1744 const void* pNext; 1745 VkFormat format; 1746 VkSamplerYcbcrModelConversion ycbcrModel; 1747 VkSamplerYcbcrRange ycbcrRange; 1748 VkComponentMapping components; 1749 VkChromaLocation xChromaOffset; 1750 VkChromaLocation yChromaOffset; 1751 VkFilter chromaFilter; 1752 VkBool32 forceExplicitReconstruction; 1753 safe_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo* in_struct); 1754 safe_VkSamplerYcbcrConversionCreateInfo(const safe_VkSamplerYcbcrConversionCreateInfo& src); 1755 safe_VkSamplerYcbcrConversionCreateInfo& operator=(const safe_VkSamplerYcbcrConversionCreateInfo& src); 1756 safe_VkSamplerYcbcrConversionCreateInfo(); 1757 ~safe_VkSamplerYcbcrConversionCreateInfo(); 1758 void initialize(const VkSamplerYcbcrConversionCreateInfo* in_struct); 1759 void initialize(const safe_VkSamplerYcbcrConversionCreateInfo* src); ptrsafe_VkSamplerYcbcrConversionCreateInfo1760 VkSamplerYcbcrConversionCreateInfo *ptr() { return reinterpret_cast<VkSamplerYcbcrConversionCreateInfo *>(this); } ptrsafe_VkSamplerYcbcrConversionCreateInfo1761 VkSamplerYcbcrConversionCreateInfo const *ptr() const { return reinterpret_cast<VkSamplerYcbcrConversionCreateInfo const *>(this); } 1762 }; 1763 1764 struct safe_VkSamplerYcbcrConversionInfo { 1765 VkStructureType sType; 1766 const void* pNext; 1767 VkSamplerYcbcrConversion conversion; 1768 safe_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo* in_struct); 1769 safe_VkSamplerYcbcrConversionInfo(const safe_VkSamplerYcbcrConversionInfo& src); 1770 safe_VkSamplerYcbcrConversionInfo& operator=(const safe_VkSamplerYcbcrConversionInfo& src); 1771 safe_VkSamplerYcbcrConversionInfo(); 1772 ~safe_VkSamplerYcbcrConversionInfo(); 1773 void initialize(const VkSamplerYcbcrConversionInfo* in_struct); 1774 void initialize(const safe_VkSamplerYcbcrConversionInfo* src); ptrsafe_VkSamplerYcbcrConversionInfo1775 VkSamplerYcbcrConversionInfo *ptr() { return reinterpret_cast<VkSamplerYcbcrConversionInfo *>(this); } ptrsafe_VkSamplerYcbcrConversionInfo1776 VkSamplerYcbcrConversionInfo const *ptr() const { return reinterpret_cast<VkSamplerYcbcrConversionInfo const *>(this); } 1777 }; 1778 1779 struct safe_VkBindImagePlaneMemoryInfo { 1780 VkStructureType sType; 1781 const void* pNext; 1782 VkImageAspectFlagBits planeAspect; 1783 safe_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo* in_struct); 1784 safe_VkBindImagePlaneMemoryInfo(const safe_VkBindImagePlaneMemoryInfo& src); 1785 safe_VkBindImagePlaneMemoryInfo& operator=(const safe_VkBindImagePlaneMemoryInfo& src); 1786 safe_VkBindImagePlaneMemoryInfo(); 1787 ~safe_VkBindImagePlaneMemoryInfo(); 1788 void initialize(const VkBindImagePlaneMemoryInfo* in_struct); 1789 void initialize(const safe_VkBindImagePlaneMemoryInfo* src); ptrsafe_VkBindImagePlaneMemoryInfo1790 VkBindImagePlaneMemoryInfo *ptr() { return reinterpret_cast<VkBindImagePlaneMemoryInfo *>(this); } ptrsafe_VkBindImagePlaneMemoryInfo1791 VkBindImagePlaneMemoryInfo const *ptr() const { return reinterpret_cast<VkBindImagePlaneMemoryInfo const *>(this); } 1792 }; 1793 1794 struct safe_VkImagePlaneMemoryRequirementsInfo { 1795 VkStructureType sType; 1796 const void* pNext; 1797 VkImageAspectFlagBits planeAspect; 1798 safe_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo* in_struct); 1799 safe_VkImagePlaneMemoryRequirementsInfo(const safe_VkImagePlaneMemoryRequirementsInfo& src); 1800 safe_VkImagePlaneMemoryRequirementsInfo& operator=(const safe_VkImagePlaneMemoryRequirementsInfo& src); 1801 safe_VkImagePlaneMemoryRequirementsInfo(); 1802 ~safe_VkImagePlaneMemoryRequirementsInfo(); 1803 void initialize(const VkImagePlaneMemoryRequirementsInfo* in_struct); 1804 void initialize(const safe_VkImagePlaneMemoryRequirementsInfo* src); ptrsafe_VkImagePlaneMemoryRequirementsInfo1805 VkImagePlaneMemoryRequirementsInfo *ptr() { return reinterpret_cast<VkImagePlaneMemoryRequirementsInfo *>(this); } ptrsafe_VkImagePlaneMemoryRequirementsInfo1806 VkImagePlaneMemoryRequirementsInfo const *ptr() const { return reinterpret_cast<VkImagePlaneMemoryRequirementsInfo const *>(this); } 1807 }; 1808 1809 struct safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures { 1810 VkStructureType sType; 1811 void* pNext; 1812 VkBool32 samplerYcbcrConversion; 1813 safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct); 1814 safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& src); 1815 safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& operator=(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& src); 1816 safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(); 1817 ~safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(); 1818 void initialize(const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct); 1819 void initialize(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures* src); ptrsafe_VkPhysicalDeviceSamplerYcbcrConversionFeatures1820 VkPhysicalDeviceSamplerYcbcrConversionFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(this); } ptrsafe_VkPhysicalDeviceSamplerYcbcrConversionFeatures1821 VkPhysicalDeviceSamplerYcbcrConversionFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures const *>(this); } 1822 }; 1823 1824 struct safe_VkSamplerYcbcrConversionImageFormatProperties { 1825 VkStructureType sType; 1826 void* pNext; 1827 uint32_t combinedImageSamplerDescriptorCount; 1828 safe_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties* in_struct); 1829 safe_VkSamplerYcbcrConversionImageFormatProperties(const safe_VkSamplerYcbcrConversionImageFormatProperties& src); 1830 safe_VkSamplerYcbcrConversionImageFormatProperties& operator=(const safe_VkSamplerYcbcrConversionImageFormatProperties& src); 1831 safe_VkSamplerYcbcrConversionImageFormatProperties(); 1832 ~safe_VkSamplerYcbcrConversionImageFormatProperties(); 1833 void initialize(const VkSamplerYcbcrConversionImageFormatProperties* in_struct); 1834 void initialize(const safe_VkSamplerYcbcrConversionImageFormatProperties* src); ptrsafe_VkSamplerYcbcrConversionImageFormatProperties1835 VkSamplerYcbcrConversionImageFormatProperties *ptr() { return reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties *>(this); } ptrsafe_VkSamplerYcbcrConversionImageFormatProperties1836 VkSamplerYcbcrConversionImageFormatProperties const *ptr() const { return reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties const *>(this); } 1837 }; 1838 1839 struct safe_VkDescriptorUpdateTemplateCreateInfo { 1840 VkStructureType sType; 1841 const void* pNext; 1842 VkDescriptorUpdateTemplateCreateFlags flags; 1843 uint32_t descriptorUpdateEntryCount; 1844 const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; 1845 VkDescriptorUpdateTemplateType templateType; 1846 VkDescriptorSetLayout descriptorSetLayout; 1847 VkPipelineBindPoint pipelineBindPoint; 1848 VkPipelineLayout pipelineLayout; 1849 uint32_t set; 1850 safe_VkDescriptorUpdateTemplateCreateInfo(const VkDescriptorUpdateTemplateCreateInfo* in_struct); 1851 safe_VkDescriptorUpdateTemplateCreateInfo(const safe_VkDescriptorUpdateTemplateCreateInfo& src); 1852 safe_VkDescriptorUpdateTemplateCreateInfo& operator=(const safe_VkDescriptorUpdateTemplateCreateInfo& src); 1853 safe_VkDescriptorUpdateTemplateCreateInfo(); 1854 ~safe_VkDescriptorUpdateTemplateCreateInfo(); 1855 void initialize(const VkDescriptorUpdateTemplateCreateInfo* in_struct); 1856 void initialize(const safe_VkDescriptorUpdateTemplateCreateInfo* src); ptrsafe_VkDescriptorUpdateTemplateCreateInfo1857 VkDescriptorUpdateTemplateCreateInfo *ptr() { return reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo *>(this); } ptrsafe_VkDescriptorUpdateTemplateCreateInfo1858 VkDescriptorUpdateTemplateCreateInfo const *ptr() const { return reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo const *>(this); } 1859 }; 1860 1861 struct safe_VkPhysicalDeviceExternalImageFormatInfo { 1862 VkStructureType sType; 1863 const void* pNext; 1864 VkExternalMemoryHandleTypeFlagBits handleType; 1865 safe_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo* in_struct); 1866 safe_VkPhysicalDeviceExternalImageFormatInfo(const safe_VkPhysicalDeviceExternalImageFormatInfo& src); 1867 safe_VkPhysicalDeviceExternalImageFormatInfo& operator=(const safe_VkPhysicalDeviceExternalImageFormatInfo& src); 1868 safe_VkPhysicalDeviceExternalImageFormatInfo(); 1869 ~safe_VkPhysicalDeviceExternalImageFormatInfo(); 1870 void initialize(const VkPhysicalDeviceExternalImageFormatInfo* in_struct); 1871 void initialize(const safe_VkPhysicalDeviceExternalImageFormatInfo* src); ptrsafe_VkPhysicalDeviceExternalImageFormatInfo1872 VkPhysicalDeviceExternalImageFormatInfo *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo *>(this); } ptrsafe_VkPhysicalDeviceExternalImageFormatInfo1873 VkPhysicalDeviceExternalImageFormatInfo const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo const *>(this); } 1874 }; 1875 1876 struct safe_VkExternalImageFormatProperties { 1877 VkStructureType sType; 1878 void* pNext; 1879 VkExternalMemoryProperties externalMemoryProperties; 1880 safe_VkExternalImageFormatProperties(const VkExternalImageFormatProperties* in_struct); 1881 safe_VkExternalImageFormatProperties(const safe_VkExternalImageFormatProperties& src); 1882 safe_VkExternalImageFormatProperties& operator=(const safe_VkExternalImageFormatProperties& src); 1883 safe_VkExternalImageFormatProperties(); 1884 ~safe_VkExternalImageFormatProperties(); 1885 void initialize(const VkExternalImageFormatProperties* in_struct); 1886 void initialize(const safe_VkExternalImageFormatProperties* src); ptrsafe_VkExternalImageFormatProperties1887 VkExternalImageFormatProperties *ptr() { return reinterpret_cast<VkExternalImageFormatProperties *>(this); } ptrsafe_VkExternalImageFormatProperties1888 VkExternalImageFormatProperties const *ptr() const { return reinterpret_cast<VkExternalImageFormatProperties const *>(this); } 1889 }; 1890 1891 struct safe_VkPhysicalDeviceExternalBufferInfo { 1892 VkStructureType sType; 1893 const void* pNext; 1894 VkBufferCreateFlags flags; 1895 VkBufferUsageFlags usage; 1896 VkExternalMemoryHandleTypeFlagBits handleType; 1897 safe_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo* in_struct); 1898 safe_VkPhysicalDeviceExternalBufferInfo(const safe_VkPhysicalDeviceExternalBufferInfo& src); 1899 safe_VkPhysicalDeviceExternalBufferInfo& operator=(const safe_VkPhysicalDeviceExternalBufferInfo& src); 1900 safe_VkPhysicalDeviceExternalBufferInfo(); 1901 ~safe_VkPhysicalDeviceExternalBufferInfo(); 1902 void initialize(const VkPhysicalDeviceExternalBufferInfo* in_struct); 1903 void initialize(const safe_VkPhysicalDeviceExternalBufferInfo* src); ptrsafe_VkPhysicalDeviceExternalBufferInfo1904 VkPhysicalDeviceExternalBufferInfo *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalBufferInfo *>(this); } ptrsafe_VkPhysicalDeviceExternalBufferInfo1905 VkPhysicalDeviceExternalBufferInfo const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalBufferInfo const *>(this); } 1906 }; 1907 1908 struct safe_VkExternalBufferProperties { 1909 VkStructureType sType; 1910 void* pNext; 1911 VkExternalMemoryProperties externalMemoryProperties; 1912 safe_VkExternalBufferProperties(const VkExternalBufferProperties* in_struct); 1913 safe_VkExternalBufferProperties(const safe_VkExternalBufferProperties& src); 1914 safe_VkExternalBufferProperties& operator=(const safe_VkExternalBufferProperties& src); 1915 safe_VkExternalBufferProperties(); 1916 ~safe_VkExternalBufferProperties(); 1917 void initialize(const VkExternalBufferProperties* in_struct); 1918 void initialize(const safe_VkExternalBufferProperties* src); ptrsafe_VkExternalBufferProperties1919 VkExternalBufferProperties *ptr() { return reinterpret_cast<VkExternalBufferProperties *>(this); } ptrsafe_VkExternalBufferProperties1920 VkExternalBufferProperties const *ptr() const { return reinterpret_cast<VkExternalBufferProperties const *>(this); } 1921 }; 1922 1923 struct safe_VkPhysicalDeviceIDProperties { 1924 VkStructureType sType; 1925 void* pNext; 1926 uint8_t deviceUUID[VK_UUID_SIZE]; 1927 uint8_t driverUUID[VK_UUID_SIZE]; 1928 uint8_t deviceLUID[VK_LUID_SIZE]; 1929 uint32_t deviceNodeMask; 1930 VkBool32 deviceLUIDValid; 1931 safe_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties* in_struct); 1932 safe_VkPhysicalDeviceIDProperties(const safe_VkPhysicalDeviceIDProperties& src); 1933 safe_VkPhysicalDeviceIDProperties& operator=(const safe_VkPhysicalDeviceIDProperties& src); 1934 safe_VkPhysicalDeviceIDProperties(); 1935 ~safe_VkPhysicalDeviceIDProperties(); 1936 void initialize(const VkPhysicalDeviceIDProperties* in_struct); 1937 void initialize(const safe_VkPhysicalDeviceIDProperties* src); ptrsafe_VkPhysicalDeviceIDProperties1938 VkPhysicalDeviceIDProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceIDProperties *>(this); } ptrsafe_VkPhysicalDeviceIDProperties1939 VkPhysicalDeviceIDProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceIDProperties const *>(this); } 1940 }; 1941 1942 struct safe_VkExternalMemoryImageCreateInfo { 1943 VkStructureType sType; 1944 const void* pNext; 1945 VkExternalMemoryHandleTypeFlags handleTypes; 1946 safe_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo* in_struct); 1947 safe_VkExternalMemoryImageCreateInfo(const safe_VkExternalMemoryImageCreateInfo& src); 1948 safe_VkExternalMemoryImageCreateInfo& operator=(const safe_VkExternalMemoryImageCreateInfo& src); 1949 safe_VkExternalMemoryImageCreateInfo(); 1950 ~safe_VkExternalMemoryImageCreateInfo(); 1951 void initialize(const VkExternalMemoryImageCreateInfo* in_struct); 1952 void initialize(const safe_VkExternalMemoryImageCreateInfo* src); ptrsafe_VkExternalMemoryImageCreateInfo1953 VkExternalMemoryImageCreateInfo *ptr() { return reinterpret_cast<VkExternalMemoryImageCreateInfo *>(this); } ptrsafe_VkExternalMemoryImageCreateInfo1954 VkExternalMemoryImageCreateInfo const *ptr() const { return reinterpret_cast<VkExternalMemoryImageCreateInfo const *>(this); } 1955 }; 1956 1957 struct safe_VkExternalMemoryBufferCreateInfo { 1958 VkStructureType sType; 1959 const void* pNext; 1960 VkExternalMemoryHandleTypeFlags handleTypes; 1961 safe_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo* in_struct); 1962 safe_VkExternalMemoryBufferCreateInfo(const safe_VkExternalMemoryBufferCreateInfo& src); 1963 safe_VkExternalMemoryBufferCreateInfo& operator=(const safe_VkExternalMemoryBufferCreateInfo& src); 1964 safe_VkExternalMemoryBufferCreateInfo(); 1965 ~safe_VkExternalMemoryBufferCreateInfo(); 1966 void initialize(const VkExternalMemoryBufferCreateInfo* in_struct); 1967 void initialize(const safe_VkExternalMemoryBufferCreateInfo* src); ptrsafe_VkExternalMemoryBufferCreateInfo1968 VkExternalMemoryBufferCreateInfo *ptr() { return reinterpret_cast<VkExternalMemoryBufferCreateInfo *>(this); } ptrsafe_VkExternalMemoryBufferCreateInfo1969 VkExternalMemoryBufferCreateInfo const *ptr() const { return reinterpret_cast<VkExternalMemoryBufferCreateInfo const *>(this); } 1970 }; 1971 1972 struct safe_VkExportMemoryAllocateInfo { 1973 VkStructureType sType; 1974 const void* pNext; 1975 VkExternalMemoryHandleTypeFlags handleTypes; 1976 safe_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo* in_struct); 1977 safe_VkExportMemoryAllocateInfo(const safe_VkExportMemoryAllocateInfo& src); 1978 safe_VkExportMemoryAllocateInfo& operator=(const safe_VkExportMemoryAllocateInfo& src); 1979 safe_VkExportMemoryAllocateInfo(); 1980 ~safe_VkExportMemoryAllocateInfo(); 1981 void initialize(const VkExportMemoryAllocateInfo* in_struct); 1982 void initialize(const safe_VkExportMemoryAllocateInfo* src); ptrsafe_VkExportMemoryAllocateInfo1983 VkExportMemoryAllocateInfo *ptr() { return reinterpret_cast<VkExportMemoryAllocateInfo *>(this); } ptrsafe_VkExportMemoryAllocateInfo1984 VkExportMemoryAllocateInfo const *ptr() const { return reinterpret_cast<VkExportMemoryAllocateInfo const *>(this); } 1985 }; 1986 1987 struct safe_VkPhysicalDeviceExternalFenceInfo { 1988 VkStructureType sType; 1989 const void* pNext; 1990 VkExternalFenceHandleTypeFlagBits handleType; 1991 safe_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo* in_struct); 1992 safe_VkPhysicalDeviceExternalFenceInfo(const safe_VkPhysicalDeviceExternalFenceInfo& src); 1993 safe_VkPhysicalDeviceExternalFenceInfo& operator=(const safe_VkPhysicalDeviceExternalFenceInfo& src); 1994 safe_VkPhysicalDeviceExternalFenceInfo(); 1995 ~safe_VkPhysicalDeviceExternalFenceInfo(); 1996 void initialize(const VkPhysicalDeviceExternalFenceInfo* in_struct); 1997 void initialize(const safe_VkPhysicalDeviceExternalFenceInfo* src); ptrsafe_VkPhysicalDeviceExternalFenceInfo1998 VkPhysicalDeviceExternalFenceInfo *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalFenceInfo *>(this); } ptrsafe_VkPhysicalDeviceExternalFenceInfo1999 VkPhysicalDeviceExternalFenceInfo const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalFenceInfo const *>(this); } 2000 }; 2001 2002 struct safe_VkExternalFenceProperties { 2003 VkStructureType sType; 2004 void* pNext; 2005 VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; 2006 VkExternalFenceHandleTypeFlags compatibleHandleTypes; 2007 VkExternalFenceFeatureFlags externalFenceFeatures; 2008 safe_VkExternalFenceProperties(const VkExternalFenceProperties* in_struct); 2009 safe_VkExternalFenceProperties(const safe_VkExternalFenceProperties& src); 2010 safe_VkExternalFenceProperties& operator=(const safe_VkExternalFenceProperties& src); 2011 safe_VkExternalFenceProperties(); 2012 ~safe_VkExternalFenceProperties(); 2013 void initialize(const VkExternalFenceProperties* in_struct); 2014 void initialize(const safe_VkExternalFenceProperties* src); ptrsafe_VkExternalFenceProperties2015 VkExternalFenceProperties *ptr() { return reinterpret_cast<VkExternalFenceProperties *>(this); } ptrsafe_VkExternalFenceProperties2016 VkExternalFenceProperties const *ptr() const { return reinterpret_cast<VkExternalFenceProperties const *>(this); } 2017 }; 2018 2019 struct safe_VkExportFenceCreateInfo { 2020 VkStructureType sType; 2021 const void* pNext; 2022 VkExternalFenceHandleTypeFlags handleTypes; 2023 safe_VkExportFenceCreateInfo(const VkExportFenceCreateInfo* in_struct); 2024 safe_VkExportFenceCreateInfo(const safe_VkExportFenceCreateInfo& src); 2025 safe_VkExportFenceCreateInfo& operator=(const safe_VkExportFenceCreateInfo& src); 2026 safe_VkExportFenceCreateInfo(); 2027 ~safe_VkExportFenceCreateInfo(); 2028 void initialize(const VkExportFenceCreateInfo* in_struct); 2029 void initialize(const safe_VkExportFenceCreateInfo* src); ptrsafe_VkExportFenceCreateInfo2030 VkExportFenceCreateInfo *ptr() { return reinterpret_cast<VkExportFenceCreateInfo *>(this); } ptrsafe_VkExportFenceCreateInfo2031 VkExportFenceCreateInfo const *ptr() const { return reinterpret_cast<VkExportFenceCreateInfo const *>(this); } 2032 }; 2033 2034 struct safe_VkExportSemaphoreCreateInfo { 2035 VkStructureType sType; 2036 const void* pNext; 2037 VkExternalSemaphoreHandleTypeFlags handleTypes; 2038 safe_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo* in_struct); 2039 safe_VkExportSemaphoreCreateInfo(const safe_VkExportSemaphoreCreateInfo& src); 2040 safe_VkExportSemaphoreCreateInfo& operator=(const safe_VkExportSemaphoreCreateInfo& src); 2041 safe_VkExportSemaphoreCreateInfo(); 2042 ~safe_VkExportSemaphoreCreateInfo(); 2043 void initialize(const VkExportSemaphoreCreateInfo* in_struct); 2044 void initialize(const safe_VkExportSemaphoreCreateInfo* src); ptrsafe_VkExportSemaphoreCreateInfo2045 VkExportSemaphoreCreateInfo *ptr() { return reinterpret_cast<VkExportSemaphoreCreateInfo *>(this); } ptrsafe_VkExportSemaphoreCreateInfo2046 VkExportSemaphoreCreateInfo const *ptr() const { return reinterpret_cast<VkExportSemaphoreCreateInfo const *>(this); } 2047 }; 2048 2049 struct safe_VkPhysicalDeviceExternalSemaphoreInfo { 2050 VkStructureType sType; 2051 const void* pNext; 2052 VkExternalSemaphoreHandleTypeFlagBits handleType; 2053 safe_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct); 2054 safe_VkPhysicalDeviceExternalSemaphoreInfo(const safe_VkPhysicalDeviceExternalSemaphoreInfo& src); 2055 safe_VkPhysicalDeviceExternalSemaphoreInfo& operator=(const safe_VkPhysicalDeviceExternalSemaphoreInfo& src); 2056 safe_VkPhysicalDeviceExternalSemaphoreInfo(); 2057 ~safe_VkPhysicalDeviceExternalSemaphoreInfo(); 2058 void initialize(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct); 2059 void initialize(const safe_VkPhysicalDeviceExternalSemaphoreInfo* src); ptrsafe_VkPhysicalDeviceExternalSemaphoreInfo2060 VkPhysicalDeviceExternalSemaphoreInfo *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo *>(this); } ptrsafe_VkPhysicalDeviceExternalSemaphoreInfo2061 VkPhysicalDeviceExternalSemaphoreInfo const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo const *>(this); } 2062 }; 2063 2064 struct safe_VkExternalSemaphoreProperties { 2065 VkStructureType sType; 2066 void* pNext; 2067 VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; 2068 VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; 2069 VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; 2070 safe_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties* in_struct); 2071 safe_VkExternalSemaphoreProperties(const safe_VkExternalSemaphoreProperties& src); 2072 safe_VkExternalSemaphoreProperties& operator=(const safe_VkExternalSemaphoreProperties& src); 2073 safe_VkExternalSemaphoreProperties(); 2074 ~safe_VkExternalSemaphoreProperties(); 2075 void initialize(const VkExternalSemaphoreProperties* in_struct); 2076 void initialize(const safe_VkExternalSemaphoreProperties* src); ptrsafe_VkExternalSemaphoreProperties2077 VkExternalSemaphoreProperties *ptr() { return reinterpret_cast<VkExternalSemaphoreProperties *>(this); } ptrsafe_VkExternalSemaphoreProperties2078 VkExternalSemaphoreProperties const *ptr() const { return reinterpret_cast<VkExternalSemaphoreProperties const *>(this); } 2079 }; 2080 2081 struct safe_VkPhysicalDeviceMaintenance3Properties { 2082 VkStructureType sType; 2083 void* pNext; 2084 uint32_t maxPerSetDescriptors; 2085 VkDeviceSize maxMemoryAllocationSize; 2086 safe_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties* in_struct); 2087 safe_VkPhysicalDeviceMaintenance3Properties(const safe_VkPhysicalDeviceMaintenance3Properties& src); 2088 safe_VkPhysicalDeviceMaintenance3Properties& operator=(const safe_VkPhysicalDeviceMaintenance3Properties& src); 2089 safe_VkPhysicalDeviceMaintenance3Properties(); 2090 ~safe_VkPhysicalDeviceMaintenance3Properties(); 2091 void initialize(const VkPhysicalDeviceMaintenance3Properties* in_struct); 2092 void initialize(const safe_VkPhysicalDeviceMaintenance3Properties* src); ptrsafe_VkPhysicalDeviceMaintenance3Properties2093 VkPhysicalDeviceMaintenance3Properties *ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance3Properties *>(this); } ptrsafe_VkPhysicalDeviceMaintenance3Properties2094 VkPhysicalDeviceMaintenance3Properties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMaintenance3Properties const *>(this); } 2095 }; 2096 2097 struct safe_VkDescriptorSetLayoutSupport { 2098 VkStructureType sType; 2099 void* pNext; 2100 VkBool32 supported; 2101 safe_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport* in_struct); 2102 safe_VkDescriptorSetLayoutSupport(const safe_VkDescriptorSetLayoutSupport& src); 2103 safe_VkDescriptorSetLayoutSupport& operator=(const safe_VkDescriptorSetLayoutSupport& src); 2104 safe_VkDescriptorSetLayoutSupport(); 2105 ~safe_VkDescriptorSetLayoutSupport(); 2106 void initialize(const VkDescriptorSetLayoutSupport* in_struct); 2107 void initialize(const safe_VkDescriptorSetLayoutSupport* src); ptrsafe_VkDescriptorSetLayoutSupport2108 VkDescriptorSetLayoutSupport *ptr() { return reinterpret_cast<VkDescriptorSetLayoutSupport *>(this); } ptrsafe_VkDescriptorSetLayoutSupport2109 VkDescriptorSetLayoutSupport const *ptr() const { return reinterpret_cast<VkDescriptorSetLayoutSupport const *>(this); } 2110 }; 2111 2112 struct safe_VkPhysicalDeviceShaderDrawParametersFeatures { 2113 VkStructureType sType; 2114 void* pNext; 2115 VkBool32 shaderDrawParameters; 2116 safe_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct); 2117 safe_VkPhysicalDeviceShaderDrawParametersFeatures(const safe_VkPhysicalDeviceShaderDrawParametersFeatures& src); 2118 safe_VkPhysicalDeviceShaderDrawParametersFeatures& operator=(const safe_VkPhysicalDeviceShaderDrawParametersFeatures& src); 2119 safe_VkPhysicalDeviceShaderDrawParametersFeatures(); 2120 ~safe_VkPhysicalDeviceShaderDrawParametersFeatures(); 2121 void initialize(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct); 2122 void initialize(const safe_VkPhysicalDeviceShaderDrawParametersFeatures* src); ptrsafe_VkPhysicalDeviceShaderDrawParametersFeatures2123 VkPhysicalDeviceShaderDrawParametersFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures *>(this); } ptrsafe_VkPhysicalDeviceShaderDrawParametersFeatures2124 VkPhysicalDeviceShaderDrawParametersFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures const *>(this); } 2125 }; 2126 2127 struct safe_VkSwapchainCreateInfoKHR { 2128 VkStructureType sType; 2129 const void* pNext; 2130 VkSwapchainCreateFlagsKHR flags; 2131 VkSurfaceKHR surface; 2132 uint32_t minImageCount; 2133 VkFormat imageFormat; 2134 VkColorSpaceKHR imageColorSpace; 2135 VkExtent2D imageExtent; 2136 uint32_t imageArrayLayers; 2137 VkImageUsageFlags imageUsage; 2138 VkSharingMode imageSharingMode; 2139 uint32_t queueFamilyIndexCount; 2140 const uint32_t* pQueueFamilyIndices; 2141 VkSurfaceTransformFlagBitsKHR preTransform; 2142 VkCompositeAlphaFlagBitsKHR compositeAlpha; 2143 VkPresentModeKHR presentMode; 2144 VkBool32 clipped; 2145 VkSwapchainKHR oldSwapchain; 2146 safe_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR* in_struct); 2147 safe_VkSwapchainCreateInfoKHR(const safe_VkSwapchainCreateInfoKHR& src); 2148 safe_VkSwapchainCreateInfoKHR& operator=(const safe_VkSwapchainCreateInfoKHR& src); 2149 safe_VkSwapchainCreateInfoKHR(); 2150 ~safe_VkSwapchainCreateInfoKHR(); 2151 void initialize(const VkSwapchainCreateInfoKHR* in_struct); 2152 void initialize(const safe_VkSwapchainCreateInfoKHR* src); ptrsafe_VkSwapchainCreateInfoKHR2153 VkSwapchainCreateInfoKHR *ptr() { return reinterpret_cast<VkSwapchainCreateInfoKHR *>(this); } ptrsafe_VkSwapchainCreateInfoKHR2154 VkSwapchainCreateInfoKHR const *ptr() const { return reinterpret_cast<VkSwapchainCreateInfoKHR const *>(this); } 2155 }; 2156 2157 struct safe_VkPresentInfoKHR { 2158 VkStructureType sType; 2159 const void* pNext; 2160 uint32_t waitSemaphoreCount; 2161 VkSemaphore* pWaitSemaphores; 2162 uint32_t swapchainCount; 2163 VkSwapchainKHR* pSwapchains; 2164 const uint32_t* pImageIndices; 2165 VkResult* pResults; 2166 safe_VkPresentInfoKHR(const VkPresentInfoKHR* in_struct); 2167 safe_VkPresentInfoKHR(const safe_VkPresentInfoKHR& src); 2168 safe_VkPresentInfoKHR& operator=(const safe_VkPresentInfoKHR& src); 2169 safe_VkPresentInfoKHR(); 2170 ~safe_VkPresentInfoKHR(); 2171 void initialize(const VkPresentInfoKHR* in_struct); 2172 void initialize(const safe_VkPresentInfoKHR* src); ptrsafe_VkPresentInfoKHR2173 VkPresentInfoKHR *ptr() { return reinterpret_cast<VkPresentInfoKHR *>(this); } ptrsafe_VkPresentInfoKHR2174 VkPresentInfoKHR const *ptr() const { return reinterpret_cast<VkPresentInfoKHR const *>(this); } 2175 }; 2176 2177 struct safe_VkImageSwapchainCreateInfoKHR { 2178 VkStructureType sType; 2179 const void* pNext; 2180 VkSwapchainKHR swapchain; 2181 safe_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR* in_struct); 2182 safe_VkImageSwapchainCreateInfoKHR(const safe_VkImageSwapchainCreateInfoKHR& src); 2183 safe_VkImageSwapchainCreateInfoKHR& operator=(const safe_VkImageSwapchainCreateInfoKHR& src); 2184 safe_VkImageSwapchainCreateInfoKHR(); 2185 ~safe_VkImageSwapchainCreateInfoKHR(); 2186 void initialize(const VkImageSwapchainCreateInfoKHR* in_struct); 2187 void initialize(const safe_VkImageSwapchainCreateInfoKHR* src); ptrsafe_VkImageSwapchainCreateInfoKHR2188 VkImageSwapchainCreateInfoKHR *ptr() { return reinterpret_cast<VkImageSwapchainCreateInfoKHR *>(this); } ptrsafe_VkImageSwapchainCreateInfoKHR2189 VkImageSwapchainCreateInfoKHR const *ptr() const { return reinterpret_cast<VkImageSwapchainCreateInfoKHR const *>(this); } 2190 }; 2191 2192 struct safe_VkBindImageMemorySwapchainInfoKHR { 2193 VkStructureType sType; 2194 const void* pNext; 2195 VkSwapchainKHR swapchain; 2196 uint32_t imageIndex; 2197 safe_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR* in_struct); 2198 safe_VkBindImageMemorySwapchainInfoKHR(const safe_VkBindImageMemorySwapchainInfoKHR& src); 2199 safe_VkBindImageMemorySwapchainInfoKHR& operator=(const safe_VkBindImageMemorySwapchainInfoKHR& src); 2200 safe_VkBindImageMemorySwapchainInfoKHR(); 2201 ~safe_VkBindImageMemorySwapchainInfoKHR(); 2202 void initialize(const VkBindImageMemorySwapchainInfoKHR* in_struct); 2203 void initialize(const safe_VkBindImageMemorySwapchainInfoKHR* src); ptrsafe_VkBindImageMemorySwapchainInfoKHR2204 VkBindImageMemorySwapchainInfoKHR *ptr() { return reinterpret_cast<VkBindImageMemorySwapchainInfoKHR *>(this); } ptrsafe_VkBindImageMemorySwapchainInfoKHR2205 VkBindImageMemorySwapchainInfoKHR const *ptr() const { return reinterpret_cast<VkBindImageMemorySwapchainInfoKHR const *>(this); } 2206 }; 2207 2208 struct safe_VkAcquireNextImageInfoKHR { 2209 VkStructureType sType; 2210 const void* pNext; 2211 VkSwapchainKHR swapchain; 2212 uint64_t timeout; 2213 VkSemaphore semaphore; 2214 VkFence fence; 2215 uint32_t deviceMask; 2216 safe_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR* in_struct); 2217 safe_VkAcquireNextImageInfoKHR(const safe_VkAcquireNextImageInfoKHR& src); 2218 safe_VkAcquireNextImageInfoKHR& operator=(const safe_VkAcquireNextImageInfoKHR& src); 2219 safe_VkAcquireNextImageInfoKHR(); 2220 ~safe_VkAcquireNextImageInfoKHR(); 2221 void initialize(const VkAcquireNextImageInfoKHR* in_struct); 2222 void initialize(const safe_VkAcquireNextImageInfoKHR* src); ptrsafe_VkAcquireNextImageInfoKHR2223 VkAcquireNextImageInfoKHR *ptr() { return reinterpret_cast<VkAcquireNextImageInfoKHR *>(this); } ptrsafe_VkAcquireNextImageInfoKHR2224 VkAcquireNextImageInfoKHR const *ptr() const { return reinterpret_cast<VkAcquireNextImageInfoKHR const *>(this); } 2225 }; 2226 2227 struct safe_VkDeviceGroupPresentCapabilitiesKHR { 2228 VkStructureType sType; 2229 const void* pNext; 2230 uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; 2231 VkDeviceGroupPresentModeFlagsKHR modes; 2232 safe_VkDeviceGroupPresentCapabilitiesKHR(const VkDeviceGroupPresentCapabilitiesKHR* in_struct); 2233 safe_VkDeviceGroupPresentCapabilitiesKHR(const safe_VkDeviceGroupPresentCapabilitiesKHR& src); 2234 safe_VkDeviceGroupPresentCapabilitiesKHR& operator=(const safe_VkDeviceGroupPresentCapabilitiesKHR& src); 2235 safe_VkDeviceGroupPresentCapabilitiesKHR(); 2236 ~safe_VkDeviceGroupPresentCapabilitiesKHR(); 2237 void initialize(const VkDeviceGroupPresentCapabilitiesKHR* in_struct); 2238 void initialize(const safe_VkDeviceGroupPresentCapabilitiesKHR* src); ptrsafe_VkDeviceGroupPresentCapabilitiesKHR2239 VkDeviceGroupPresentCapabilitiesKHR *ptr() { return reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>(this); } ptrsafe_VkDeviceGroupPresentCapabilitiesKHR2240 VkDeviceGroupPresentCapabilitiesKHR const *ptr() const { return reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR const *>(this); } 2241 }; 2242 2243 struct safe_VkDeviceGroupPresentInfoKHR { 2244 VkStructureType sType; 2245 const void* pNext; 2246 uint32_t swapchainCount; 2247 const uint32_t* pDeviceMasks; 2248 VkDeviceGroupPresentModeFlagBitsKHR mode; 2249 safe_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR* in_struct); 2250 safe_VkDeviceGroupPresentInfoKHR(const safe_VkDeviceGroupPresentInfoKHR& src); 2251 safe_VkDeviceGroupPresentInfoKHR& operator=(const safe_VkDeviceGroupPresentInfoKHR& src); 2252 safe_VkDeviceGroupPresentInfoKHR(); 2253 ~safe_VkDeviceGroupPresentInfoKHR(); 2254 void initialize(const VkDeviceGroupPresentInfoKHR* in_struct); 2255 void initialize(const safe_VkDeviceGroupPresentInfoKHR* src); ptrsafe_VkDeviceGroupPresentInfoKHR2256 VkDeviceGroupPresentInfoKHR *ptr() { return reinterpret_cast<VkDeviceGroupPresentInfoKHR *>(this); } ptrsafe_VkDeviceGroupPresentInfoKHR2257 VkDeviceGroupPresentInfoKHR const *ptr() const { return reinterpret_cast<VkDeviceGroupPresentInfoKHR const *>(this); } 2258 }; 2259 2260 struct safe_VkDeviceGroupSwapchainCreateInfoKHR { 2261 VkStructureType sType; 2262 const void* pNext; 2263 VkDeviceGroupPresentModeFlagsKHR modes; 2264 safe_VkDeviceGroupSwapchainCreateInfoKHR(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct); 2265 safe_VkDeviceGroupSwapchainCreateInfoKHR(const safe_VkDeviceGroupSwapchainCreateInfoKHR& src); 2266 safe_VkDeviceGroupSwapchainCreateInfoKHR& operator=(const safe_VkDeviceGroupSwapchainCreateInfoKHR& src); 2267 safe_VkDeviceGroupSwapchainCreateInfoKHR(); 2268 ~safe_VkDeviceGroupSwapchainCreateInfoKHR(); 2269 void initialize(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct); 2270 void initialize(const safe_VkDeviceGroupSwapchainCreateInfoKHR* src); ptrsafe_VkDeviceGroupSwapchainCreateInfoKHR2271 VkDeviceGroupSwapchainCreateInfoKHR *ptr() { return reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR *>(this); } ptrsafe_VkDeviceGroupSwapchainCreateInfoKHR2272 VkDeviceGroupSwapchainCreateInfoKHR const *ptr() const { return reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR const *>(this); } 2273 }; 2274 2275 struct safe_VkDisplayPropertiesKHR { 2276 VkDisplayKHR display; 2277 const char* displayName; 2278 VkExtent2D physicalDimensions; 2279 VkExtent2D physicalResolution; 2280 VkSurfaceTransformFlagsKHR supportedTransforms; 2281 VkBool32 planeReorderPossible; 2282 VkBool32 persistentContent; 2283 safe_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR* in_struct); 2284 safe_VkDisplayPropertiesKHR(const safe_VkDisplayPropertiesKHR& src); 2285 safe_VkDisplayPropertiesKHR& operator=(const safe_VkDisplayPropertiesKHR& src); 2286 safe_VkDisplayPropertiesKHR(); 2287 ~safe_VkDisplayPropertiesKHR(); 2288 void initialize(const VkDisplayPropertiesKHR* in_struct); 2289 void initialize(const safe_VkDisplayPropertiesKHR* src); ptrsafe_VkDisplayPropertiesKHR2290 VkDisplayPropertiesKHR *ptr() { return reinterpret_cast<VkDisplayPropertiesKHR *>(this); } ptrsafe_VkDisplayPropertiesKHR2291 VkDisplayPropertiesKHR const *ptr() const { return reinterpret_cast<VkDisplayPropertiesKHR const *>(this); } 2292 }; 2293 2294 struct safe_VkDisplayModeCreateInfoKHR { 2295 VkStructureType sType; 2296 const void* pNext; 2297 VkDisplayModeCreateFlagsKHR flags; 2298 VkDisplayModeParametersKHR parameters; 2299 safe_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR* in_struct); 2300 safe_VkDisplayModeCreateInfoKHR(const safe_VkDisplayModeCreateInfoKHR& src); 2301 safe_VkDisplayModeCreateInfoKHR& operator=(const safe_VkDisplayModeCreateInfoKHR& src); 2302 safe_VkDisplayModeCreateInfoKHR(); 2303 ~safe_VkDisplayModeCreateInfoKHR(); 2304 void initialize(const VkDisplayModeCreateInfoKHR* in_struct); 2305 void initialize(const safe_VkDisplayModeCreateInfoKHR* src); ptrsafe_VkDisplayModeCreateInfoKHR2306 VkDisplayModeCreateInfoKHR *ptr() { return reinterpret_cast<VkDisplayModeCreateInfoKHR *>(this); } ptrsafe_VkDisplayModeCreateInfoKHR2307 VkDisplayModeCreateInfoKHR const *ptr() const { return reinterpret_cast<VkDisplayModeCreateInfoKHR const *>(this); } 2308 }; 2309 2310 struct safe_VkDisplaySurfaceCreateInfoKHR { 2311 VkStructureType sType; 2312 const void* pNext; 2313 VkDisplaySurfaceCreateFlagsKHR flags; 2314 VkDisplayModeKHR displayMode; 2315 uint32_t planeIndex; 2316 uint32_t planeStackIndex; 2317 VkSurfaceTransformFlagBitsKHR transform; 2318 float globalAlpha; 2319 VkDisplayPlaneAlphaFlagBitsKHR alphaMode; 2320 VkExtent2D imageExtent; 2321 safe_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR* in_struct); 2322 safe_VkDisplaySurfaceCreateInfoKHR(const safe_VkDisplaySurfaceCreateInfoKHR& src); 2323 safe_VkDisplaySurfaceCreateInfoKHR& operator=(const safe_VkDisplaySurfaceCreateInfoKHR& src); 2324 safe_VkDisplaySurfaceCreateInfoKHR(); 2325 ~safe_VkDisplaySurfaceCreateInfoKHR(); 2326 void initialize(const VkDisplaySurfaceCreateInfoKHR* in_struct); 2327 void initialize(const safe_VkDisplaySurfaceCreateInfoKHR* src); ptrsafe_VkDisplaySurfaceCreateInfoKHR2328 VkDisplaySurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkDisplaySurfaceCreateInfoKHR *>(this); } ptrsafe_VkDisplaySurfaceCreateInfoKHR2329 VkDisplaySurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkDisplaySurfaceCreateInfoKHR const *>(this); } 2330 }; 2331 2332 struct safe_VkDisplayPresentInfoKHR { 2333 VkStructureType sType; 2334 const void* pNext; 2335 VkRect2D srcRect; 2336 VkRect2D dstRect; 2337 VkBool32 persistent; 2338 safe_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR* in_struct); 2339 safe_VkDisplayPresentInfoKHR(const safe_VkDisplayPresentInfoKHR& src); 2340 safe_VkDisplayPresentInfoKHR& operator=(const safe_VkDisplayPresentInfoKHR& src); 2341 safe_VkDisplayPresentInfoKHR(); 2342 ~safe_VkDisplayPresentInfoKHR(); 2343 void initialize(const VkDisplayPresentInfoKHR* in_struct); 2344 void initialize(const safe_VkDisplayPresentInfoKHR* src); ptrsafe_VkDisplayPresentInfoKHR2345 VkDisplayPresentInfoKHR *ptr() { return reinterpret_cast<VkDisplayPresentInfoKHR *>(this); } ptrsafe_VkDisplayPresentInfoKHR2346 VkDisplayPresentInfoKHR const *ptr() const { return reinterpret_cast<VkDisplayPresentInfoKHR const *>(this); } 2347 }; 2348 2349 #ifdef VK_USE_PLATFORM_XLIB_KHR 2350 struct safe_VkXlibSurfaceCreateInfoKHR { 2351 VkStructureType sType; 2352 const void* pNext; 2353 VkXlibSurfaceCreateFlagsKHR flags; 2354 Display* dpy; 2355 Window window; 2356 safe_VkXlibSurfaceCreateInfoKHR(const VkXlibSurfaceCreateInfoKHR* in_struct); 2357 safe_VkXlibSurfaceCreateInfoKHR(const safe_VkXlibSurfaceCreateInfoKHR& src); 2358 safe_VkXlibSurfaceCreateInfoKHR& operator=(const safe_VkXlibSurfaceCreateInfoKHR& src); 2359 safe_VkXlibSurfaceCreateInfoKHR(); 2360 ~safe_VkXlibSurfaceCreateInfoKHR(); 2361 void initialize(const VkXlibSurfaceCreateInfoKHR* in_struct); 2362 void initialize(const safe_VkXlibSurfaceCreateInfoKHR* src); ptrsafe_VkXlibSurfaceCreateInfoKHR2363 VkXlibSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkXlibSurfaceCreateInfoKHR *>(this); } ptrsafe_VkXlibSurfaceCreateInfoKHR2364 VkXlibSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkXlibSurfaceCreateInfoKHR const *>(this); } 2365 }; 2366 #endif // VK_USE_PLATFORM_XLIB_KHR 2367 2368 #ifdef VK_USE_PLATFORM_XCB_KHR 2369 struct safe_VkXcbSurfaceCreateInfoKHR { 2370 VkStructureType sType; 2371 const void* pNext; 2372 VkXcbSurfaceCreateFlagsKHR flags; 2373 xcb_connection_t* connection; 2374 xcb_window_t window; 2375 safe_VkXcbSurfaceCreateInfoKHR(const VkXcbSurfaceCreateInfoKHR* in_struct); 2376 safe_VkXcbSurfaceCreateInfoKHR(const safe_VkXcbSurfaceCreateInfoKHR& src); 2377 safe_VkXcbSurfaceCreateInfoKHR& operator=(const safe_VkXcbSurfaceCreateInfoKHR& src); 2378 safe_VkXcbSurfaceCreateInfoKHR(); 2379 ~safe_VkXcbSurfaceCreateInfoKHR(); 2380 void initialize(const VkXcbSurfaceCreateInfoKHR* in_struct); 2381 void initialize(const safe_VkXcbSurfaceCreateInfoKHR* src); ptrsafe_VkXcbSurfaceCreateInfoKHR2382 VkXcbSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkXcbSurfaceCreateInfoKHR *>(this); } ptrsafe_VkXcbSurfaceCreateInfoKHR2383 VkXcbSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkXcbSurfaceCreateInfoKHR const *>(this); } 2384 }; 2385 #endif // VK_USE_PLATFORM_XCB_KHR 2386 2387 #ifdef VK_USE_PLATFORM_WAYLAND_KHR 2388 struct safe_VkWaylandSurfaceCreateInfoKHR { 2389 VkStructureType sType; 2390 const void* pNext; 2391 VkWaylandSurfaceCreateFlagsKHR flags; 2392 struct wl_display* display; 2393 struct wl_surface* surface; 2394 safe_VkWaylandSurfaceCreateInfoKHR(const VkWaylandSurfaceCreateInfoKHR* in_struct); 2395 safe_VkWaylandSurfaceCreateInfoKHR(const safe_VkWaylandSurfaceCreateInfoKHR& src); 2396 safe_VkWaylandSurfaceCreateInfoKHR& operator=(const safe_VkWaylandSurfaceCreateInfoKHR& src); 2397 safe_VkWaylandSurfaceCreateInfoKHR(); 2398 ~safe_VkWaylandSurfaceCreateInfoKHR(); 2399 void initialize(const VkWaylandSurfaceCreateInfoKHR* in_struct); 2400 void initialize(const safe_VkWaylandSurfaceCreateInfoKHR* src); ptrsafe_VkWaylandSurfaceCreateInfoKHR2401 VkWaylandSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkWaylandSurfaceCreateInfoKHR *>(this); } ptrsafe_VkWaylandSurfaceCreateInfoKHR2402 VkWaylandSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkWaylandSurfaceCreateInfoKHR const *>(this); } 2403 }; 2404 #endif // VK_USE_PLATFORM_WAYLAND_KHR 2405 2406 #ifdef VK_USE_PLATFORM_ANDROID_KHR 2407 struct safe_VkAndroidSurfaceCreateInfoKHR { 2408 VkStructureType sType; 2409 const void* pNext; 2410 VkAndroidSurfaceCreateFlagsKHR flags; 2411 struct ANativeWindow* window; 2412 safe_VkAndroidSurfaceCreateInfoKHR(const VkAndroidSurfaceCreateInfoKHR* in_struct); 2413 safe_VkAndroidSurfaceCreateInfoKHR(const safe_VkAndroidSurfaceCreateInfoKHR& src); 2414 safe_VkAndroidSurfaceCreateInfoKHR& operator=(const safe_VkAndroidSurfaceCreateInfoKHR& src); 2415 safe_VkAndroidSurfaceCreateInfoKHR(); 2416 ~safe_VkAndroidSurfaceCreateInfoKHR(); 2417 void initialize(const VkAndroidSurfaceCreateInfoKHR* in_struct); 2418 void initialize(const safe_VkAndroidSurfaceCreateInfoKHR* src); ptrsafe_VkAndroidSurfaceCreateInfoKHR2419 VkAndroidSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkAndroidSurfaceCreateInfoKHR *>(this); } ptrsafe_VkAndroidSurfaceCreateInfoKHR2420 VkAndroidSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkAndroidSurfaceCreateInfoKHR const *>(this); } 2421 }; 2422 #endif // VK_USE_PLATFORM_ANDROID_KHR 2423 2424 #ifdef VK_USE_PLATFORM_WIN32_KHR 2425 struct safe_VkWin32SurfaceCreateInfoKHR { 2426 VkStructureType sType; 2427 const void* pNext; 2428 VkWin32SurfaceCreateFlagsKHR flags; 2429 HINSTANCE hinstance; 2430 HWND hwnd; 2431 safe_VkWin32SurfaceCreateInfoKHR(const VkWin32SurfaceCreateInfoKHR* in_struct); 2432 safe_VkWin32SurfaceCreateInfoKHR(const safe_VkWin32SurfaceCreateInfoKHR& src); 2433 safe_VkWin32SurfaceCreateInfoKHR& operator=(const safe_VkWin32SurfaceCreateInfoKHR& src); 2434 safe_VkWin32SurfaceCreateInfoKHR(); 2435 ~safe_VkWin32SurfaceCreateInfoKHR(); 2436 void initialize(const VkWin32SurfaceCreateInfoKHR* in_struct); 2437 void initialize(const safe_VkWin32SurfaceCreateInfoKHR* src); ptrsafe_VkWin32SurfaceCreateInfoKHR2438 VkWin32SurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkWin32SurfaceCreateInfoKHR *>(this); } ptrsafe_VkWin32SurfaceCreateInfoKHR2439 VkWin32SurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkWin32SurfaceCreateInfoKHR const *>(this); } 2440 }; 2441 #endif // VK_USE_PLATFORM_WIN32_KHR 2442 2443 #ifdef VK_USE_PLATFORM_WIN32_KHR 2444 struct safe_VkImportMemoryWin32HandleInfoKHR { 2445 VkStructureType sType; 2446 const void* pNext; 2447 VkExternalMemoryHandleTypeFlagBits handleType; 2448 HANDLE handle; 2449 LPCWSTR name; 2450 safe_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR* in_struct); 2451 safe_VkImportMemoryWin32HandleInfoKHR(const safe_VkImportMemoryWin32HandleInfoKHR& src); 2452 safe_VkImportMemoryWin32HandleInfoKHR& operator=(const safe_VkImportMemoryWin32HandleInfoKHR& src); 2453 safe_VkImportMemoryWin32HandleInfoKHR(); 2454 ~safe_VkImportMemoryWin32HandleInfoKHR(); 2455 void initialize(const VkImportMemoryWin32HandleInfoKHR* in_struct); 2456 void initialize(const safe_VkImportMemoryWin32HandleInfoKHR* src); ptrsafe_VkImportMemoryWin32HandleInfoKHR2457 VkImportMemoryWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkImportMemoryWin32HandleInfoKHR *>(this); } ptrsafe_VkImportMemoryWin32HandleInfoKHR2458 VkImportMemoryWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkImportMemoryWin32HandleInfoKHR const *>(this); } 2459 }; 2460 #endif // VK_USE_PLATFORM_WIN32_KHR 2461 2462 #ifdef VK_USE_PLATFORM_WIN32_KHR 2463 struct safe_VkExportMemoryWin32HandleInfoKHR { 2464 VkStructureType sType; 2465 const void* pNext; 2466 const SECURITY_ATTRIBUTES* pAttributes; 2467 DWORD dwAccess; 2468 LPCWSTR name; 2469 safe_VkExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR* in_struct); 2470 safe_VkExportMemoryWin32HandleInfoKHR(const safe_VkExportMemoryWin32HandleInfoKHR& src); 2471 safe_VkExportMemoryWin32HandleInfoKHR& operator=(const safe_VkExportMemoryWin32HandleInfoKHR& src); 2472 safe_VkExportMemoryWin32HandleInfoKHR(); 2473 ~safe_VkExportMemoryWin32HandleInfoKHR(); 2474 void initialize(const VkExportMemoryWin32HandleInfoKHR* in_struct); 2475 void initialize(const safe_VkExportMemoryWin32HandleInfoKHR* src); ptrsafe_VkExportMemoryWin32HandleInfoKHR2476 VkExportMemoryWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkExportMemoryWin32HandleInfoKHR *>(this); } ptrsafe_VkExportMemoryWin32HandleInfoKHR2477 VkExportMemoryWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkExportMemoryWin32HandleInfoKHR const *>(this); } 2478 }; 2479 #endif // VK_USE_PLATFORM_WIN32_KHR 2480 2481 #ifdef VK_USE_PLATFORM_WIN32_KHR 2482 struct safe_VkMemoryWin32HandlePropertiesKHR { 2483 VkStructureType sType; 2484 void* pNext; 2485 uint32_t memoryTypeBits; 2486 safe_VkMemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR* in_struct); 2487 safe_VkMemoryWin32HandlePropertiesKHR(const safe_VkMemoryWin32HandlePropertiesKHR& src); 2488 safe_VkMemoryWin32HandlePropertiesKHR& operator=(const safe_VkMemoryWin32HandlePropertiesKHR& src); 2489 safe_VkMemoryWin32HandlePropertiesKHR(); 2490 ~safe_VkMemoryWin32HandlePropertiesKHR(); 2491 void initialize(const VkMemoryWin32HandlePropertiesKHR* in_struct); 2492 void initialize(const safe_VkMemoryWin32HandlePropertiesKHR* src); ptrsafe_VkMemoryWin32HandlePropertiesKHR2493 VkMemoryWin32HandlePropertiesKHR *ptr() { return reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>(this); } ptrsafe_VkMemoryWin32HandlePropertiesKHR2494 VkMemoryWin32HandlePropertiesKHR const *ptr() const { return reinterpret_cast<VkMemoryWin32HandlePropertiesKHR const *>(this); } 2495 }; 2496 #endif // VK_USE_PLATFORM_WIN32_KHR 2497 2498 #ifdef VK_USE_PLATFORM_WIN32_KHR 2499 struct safe_VkMemoryGetWin32HandleInfoKHR { 2500 VkStructureType sType; 2501 const void* pNext; 2502 VkDeviceMemory memory; 2503 VkExternalMemoryHandleTypeFlagBits handleType; 2504 safe_VkMemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR* in_struct); 2505 safe_VkMemoryGetWin32HandleInfoKHR(const safe_VkMemoryGetWin32HandleInfoKHR& src); 2506 safe_VkMemoryGetWin32HandleInfoKHR& operator=(const safe_VkMemoryGetWin32HandleInfoKHR& src); 2507 safe_VkMemoryGetWin32HandleInfoKHR(); 2508 ~safe_VkMemoryGetWin32HandleInfoKHR(); 2509 void initialize(const VkMemoryGetWin32HandleInfoKHR* in_struct); 2510 void initialize(const safe_VkMemoryGetWin32HandleInfoKHR* src); ptrsafe_VkMemoryGetWin32HandleInfoKHR2511 VkMemoryGetWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkMemoryGetWin32HandleInfoKHR *>(this); } ptrsafe_VkMemoryGetWin32HandleInfoKHR2512 VkMemoryGetWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkMemoryGetWin32HandleInfoKHR const *>(this); } 2513 }; 2514 #endif // VK_USE_PLATFORM_WIN32_KHR 2515 2516 struct safe_VkImportMemoryFdInfoKHR { 2517 VkStructureType sType; 2518 const void* pNext; 2519 VkExternalMemoryHandleTypeFlagBits handleType; 2520 int fd; 2521 safe_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR* in_struct); 2522 safe_VkImportMemoryFdInfoKHR(const safe_VkImportMemoryFdInfoKHR& src); 2523 safe_VkImportMemoryFdInfoKHR& operator=(const safe_VkImportMemoryFdInfoKHR& src); 2524 safe_VkImportMemoryFdInfoKHR(); 2525 ~safe_VkImportMemoryFdInfoKHR(); 2526 void initialize(const VkImportMemoryFdInfoKHR* in_struct); 2527 void initialize(const safe_VkImportMemoryFdInfoKHR* src); ptrsafe_VkImportMemoryFdInfoKHR2528 VkImportMemoryFdInfoKHR *ptr() { return reinterpret_cast<VkImportMemoryFdInfoKHR *>(this); } ptrsafe_VkImportMemoryFdInfoKHR2529 VkImportMemoryFdInfoKHR const *ptr() const { return reinterpret_cast<VkImportMemoryFdInfoKHR const *>(this); } 2530 }; 2531 2532 struct safe_VkMemoryFdPropertiesKHR { 2533 VkStructureType sType; 2534 void* pNext; 2535 uint32_t memoryTypeBits; 2536 safe_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR* in_struct); 2537 safe_VkMemoryFdPropertiesKHR(const safe_VkMemoryFdPropertiesKHR& src); 2538 safe_VkMemoryFdPropertiesKHR& operator=(const safe_VkMemoryFdPropertiesKHR& src); 2539 safe_VkMemoryFdPropertiesKHR(); 2540 ~safe_VkMemoryFdPropertiesKHR(); 2541 void initialize(const VkMemoryFdPropertiesKHR* in_struct); 2542 void initialize(const safe_VkMemoryFdPropertiesKHR* src); ptrsafe_VkMemoryFdPropertiesKHR2543 VkMemoryFdPropertiesKHR *ptr() { return reinterpret_cast<VkMemoryFdPropertiesKHR *>(this); } ptrsafe_VkMemoryFdPropertiesKHR2544 VkMemoryFdPropertiesKHR const *ptr() const { return reinterpret_cast<VkMemoryFdPropertiesKHR const *>(this); } 2545 }; 2546 2547 struct safe_VkMemoryGetFdInfoKHR { 2548 VkStructureType sType; 2549 const void* pNext; 2550 VkDeviceMemory memory; 2551 VkExternalMemoryHandleTypeFlagBits handleType; 2552 safe_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR* in_struct); 2553 safe_VkMemoryGetFdInfoKHR(const safe_VkMemoryGetFdInfoKHR& src); 2554 safe_VkMemoryGetFdInfoKHR& operator=(const safe_VkMemoryGetFdInfoKHR& src); 2555 safe_VkMemoryGetFdInfoKHR(); 2556 ~safe_VkMemoryGetFdInfoKHR(); 2557 void initialize(const VkMemoryGetFdInfoKHR* in_struct); 2558 void initialize(const safe_VkMemoryGetFdInfoKHR* src); ptrsafe_VkMemoryGetFdInfoKHR2559 VkMemoryGetFdInfoKHR *ptr() { return reinterpret_cast<VkMemoryGetFdInfoKHR *>(this); } ptrsafe_VkMemoryGetFdInfoKHR2560 VkMemoryGetFdInfoKHR const *ptr() const { return reinterpret_cast<VkMemoryGetFdInfoKHR const *>(this); } 2561 }; 2562 2563 #ifdef VK_USE_PLATFORM_WIN32_KHR 2564 struct safe_VkWin32KeyedMutexAcquireReleaseInfoKHR { 2565 VkStructureType sType; 2566 const void* pNext; 2567 uint32_t acquireCount; 2568 VkDeviceMemory* pAcquireSyncs; 2569 const uint64_t* pAcquireKeys; 2570 const uint32_t* pAcquireTimeouts; 2571 uint32_t releaseCount; 2572 VkDeviceMemory* pReleaseSyncs; 2573 const uint64_t* pReleaseKeys; 2574 safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct); 2575 safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& src); 2576 safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& operator=(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& src); 2577 safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(); 2578 ~safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(); 2579 void initialize(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct); 2580 void initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR* src); ptrsafe_VkWin32KeyedMutexAcquireReleaseInfoKHR2581 VkWin32KeyedMutexAcquireReleaseInfoKHR *ptr() { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR *>(this); } ptrsafe_VkWin32KeyedMutexAcquireReleaseInfoKHR2582 VkWin32KeyedMutexAcquireReleaseInfoKHR const *ptr() const { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR const *>(this); } 2583 }; 2584 #endif // VK_USE_PLATFORM_WIN32_KHR 2585 2586 #ifdef VK_USE_PLATFORM_WIN32_KHR 2587 struct safe_VkImportSemaphoreWin32HandleInfoKHR { 2588 VkStructureType sType; 2589 const void* pNext; 2590 VkSemaphore semaphore; 2591 VkSemaphoreImportFlags flags; 2592 VkExternalSemaphoreHandleTypeFlagBits handleType; 2593 HANDLE handle; 2594 LPCWSTR name; 2595 safe_VkImportSemaphoreWin32HandleInfoKHR(const VkImportSemaphoreWin32HandleInfoKHR* in_struct); 2596 safe_VkImportSemaphoreWin32HandleInfoKHR(const safe_VkImportSemaphoreWin32HandleInfoKHR& src); 2597 safe_VkImportSemaphoreWin32HandleInfoKHR& operator=(const safe_VkImportSemaphoreWin32HandleInfoKHR& src); 2598 safe_VkImportSemaphoreWin32HandleInfoKHR(); 2599 ~safe_VkImportSemaphoreWin32HandleInfoKHR(); 2600 void initialize(const VkImportSemaphoreWin32HandleInfoKHR* in_struct); 2601 void initialize(const safe_VkImportSemaphoreWin32HandleInfoKHR* src); ptrsafe_VkImportSemaphoreWin32HandleInfoKHR2602 VkImportSemaphoreWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR *>(this); } ptrsafe_VkImportSemaphoreWin32HandleInfoKHR2603 VkImportSemaphoreWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR const *>(this); } 2604 }; 2605 #endif // VK_USE_PLATFORM_WIN32_KHR 2606 2607 #ifdef VK_USE_PLATFORM_WIN32_KHR 2608 struct safe_VkExportSemaphoreWin32HandleInfoKHR { 2609 VkStructureType sType; 2610 const void* pNext; 2611 const SECURITY_ATTRIBUTES* pAttributes; 2612 DWORD dwAccess; 2613 LPCWSTR name; 2614 safe_VkExportSemaphoreWin32HandleInfoKHR(const VkExportSemaphoreWin32HandleInfoKHR* in_struct); 2615 safe_VkExportSemaphoreWin32HandleInfoKHR(const safe_VkExportSemaphoreWin32HandleInfoKHR& src); 2616 safe_VkExportSemaphoreWin32HandleInfoKHR& operator=(const safe_VkExportSemaphoreWin32HandleInfoKHR& src); 2617 safe_VkExportSemaphoreWin32HandleInfoKHR(); 2618 ~safe_VkExportSemaphoreWin32HandleInfoKHR(); 2619 void initialize(const VkExportSemaphoreWin32HandleInfoKHR* in_struct); 2620 void initialize(const safe_VkExportSemaphoreWin32HandleInfoKHR* src); ptrsafe_VkExportSemaphoreWin32HandleInfoKHR2621 VkExportSemaphoreWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR *>(this); } ptrsafe_VkExportSemaphoreWin32HandleInfoKHR2622 VkExportSemaphoreWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR const *>(this); } 2623 }; 2624 #endif // VK_USE_PLATFORM_WIN32_KHR 2625 2626 #ifdef VK_USE_PLATFORM_WIN32_KHR 2627 struct safe_VkD3D12FenceSubmitInfoKHR { 2628 VkStructureType sType; 2629 const void* pNext; 2630 uint32_t waitSemaphoreValuesCount; 2631 const uint64_t* pWaitSemaphoreValues; 2632 uint32_t signalSemaphoreValuesCount; 2633 const uint64_t* pSignalSemaphoreValues; 2634 safe_VkD3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR* in_struct); 2635 safe_VkD3D12FenceSubmitInfoKHR(const safe_VkD3D12FenceSubmitInfoKHR& src); 2636 safe_VkD3D12FenceSubmitInfoKHR& operator=(const safe_VkD3D12FenceSubmitInfoKHR& src); 2637 safe_VkD3D12FenceSubmitInfoKHR(); 2638 ~safe_VkD3D12FenceSubmitInfoKHR(); 2639 void initialize(const VkD3D12FenceSubmitInfoKHR* in_struct); 2640 void initialize(const safe_VkD3D12FenceSubmitInfoKHR* src); ptrsafe_VkD3D12FenceSubmitInfoKHR2641 VkD3D12FenceSubmitInfoKHR *ptr() { return reinterpret_cast<VkD3D12FenceSubmitInfoKHR *>(this); } ptrsafe_VkD3D12FenceSubmitInfoKHR2642 VkD3D12FenceSubmitInfoKHR const *ptr() const { return reinterpret_cast<VkD3D12FenceSubmitInfoKHR const *>(this); } 2643 }; 2644 #endif // VK_USE_PLATFORM_WIN32_KHR 2645 2646 #ifdef VK_USE_PLATFORM_WIN32_KHR 2647 struct safe_VkSemaphoreGetWin32HandleInfoKHR { 2648 VkStructureType sType; 2649 const void* pNext; 2650 VkSemaphore semaphore; 2651 VkExternalSemaphoreHandleTypeFlagBits handleType; 2652 safe_VkSemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR* in_struct); 2653 safe_VkSemaphoreGetWin32HandleInfoKHR(const safe_VkSemaphoreGetWin32HandleInfoKHR& src); 2654 safe_VkSemaphoreGetWin32HandleInfoKHR& operator=(const safe_VkSemaphoreGetWin32HandleInfoKHR& src); 2655 safe_VkSemaphoreGetWin32HandleInfoKHR(); 2656 ~safe_VkSemaphoreGetWin32HandleInfoKHR(); 2657 void initialize(const VkSemaphoreGetWin32HandleInfoKHR* in_struct); 2658 void initialize(const safe_VkSemaphoreGetWin32HandleInfoKHR* src); ptrsafe_VkSemaphoreGetWin32HandleInfoKHR2659 VkSemaphoreGetWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR *>(this); } ptrsafe_VkSemaphoreGetWin32HandleInfoKHR2660 VkSemaphoreGetWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR const *>(this); } 2661 }; 2662 #endif // VK_USE_PLATFORM_WIN32_KHR 2663 2664 struct safe_VkImportSemaphoreFdInfoKHR { 2665 VkStructureType sType; 2666 const void* pNext; 2667 VkSemaphore semaphore; 2668 VkSemaphoreImportFlags flags; 2669 VkExternalSemaphoreHandleTypeFlagBits handleType; 2670 int fd; 2671 safe_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR* in_struct); 2672 safe_VkImportSemaphoreFdInfoKHR(const safe_VkImportSemaphoreFdInfoKHR& src); 2673 safe_VkImportSemaphoreFdInfoKHR& operator=(const safe_VkImportSemaphoreFdInfoKHR& src); 2674 safe_VkImportSemaphoreFdInfoKHR(); 2675 ~safe_VkImportSemaphoreFdInfoKHR(); 2676 void initialize(const VkImportSemaphoreFdInfoKHR* in_struct); 2677 void initialize(const safe_VkImportSemaphoreFdInfoKHR* src); ptrsafe_VkImportSemaphoreFdInfoKHR2678 VkImportSemaphoreFdInfoKHR *ptr() { return reinterpret_cast<VkImportSemaphoreFdInfoKHR *>(this); } ptrsafe_VkImportSemaphoreFdInfoKHR2679 VkImportSemaphoreFdInfoKHR const *ptr() const { return reinterpret_cast<VkImportSemaphoreFdInfoKHR const *>(this); } 2680 }; 2681 2682 struct safe_VkSemaphoreGetFdInfoKHR { 2683 VkStructureType sType; 2684 const void* pNext; 2685 VkSemaphore semaphore; 2686 VkExternalSemaphoreHandleTypeFlagBits handleType; 2687 safe_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR* in_struct); 2688 safe_VkSemaphoreGetFdInfoKHR(const safe_VkSemaphoreGetFdInfoKHR& src); 2689 safe_VkSemaphoreGetFdInfoKHR& operator=(const safe_VkSemaphoreGetFdInfoKHR& src); 2690 safe_VkSemaphoreGetFdInfoKHR(); 2691 ~safe_VkSemaphoreGetFdInfoKHR(); 2692 void initialize(const VkSemaphoreGetFdInfoKHR* in_struct); 2693 void initialize(const safe_VkSemaphoreGetFdInfoKHR* src); ptrsafe_VkSemaphoreGetFdInfoKHR2694 VkSemaphoreGetFdInfoKHR *ptr() { return reinterpret_cast<VkSemaphoreGetFdInfoKHR *>(this); } ptrsafe_VkSemaphoreGetFdInfoKHR2695 VkSemaphoreGetFdInfoKHR const *ptr() const { return reinterpret_cast<VkSemaphoreGetFdInfoKHR const *>(this); } 2696 }; 2697 2698 struct safe_VkPhysicalDevicePushDescriptorPropertiesKHR { 2699 VkStructureType sType; 2700 void* pNext; 2701 uint32_t maxPushDescriptors; 2702 safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct); 2703 safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& src); 2704 safe_VkPhysicalDevicePushDescriptorPropertiesKHR& operator=(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& src); 2705 safe_VkPhysicalDevicePushDescriptorPropertiesKHR(); 2706 ~safe_VkPhysicalDevicePushDescriptorPropertiesKHR(); 2707 void initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct); 2708 void initialize(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR* src); ptrsafe_VkPhysicalDevicePushDescriptorPropertiesKHR2709 VkPhysicalDevicePushDescriptorPropertiesKHR *ptr() { return reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR *>(this); } ptrsafe_VkPhysicalDevicePushDescriptorPropertiesKHR2710 VkPhysicalDevicePushDescriptorPropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR const *>(this); } 2711 }; 2712 2713 struct safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR { 2714 VkStructureType sType; 2715 void* pNext; 2716 VkBool32 shaderFloat16; 2717 VkBool32 shaderInt8; 2718 safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR(const VkPhysicalDeviceShaderFloat16Int8FeaturesKHR* in_struct); 2719 safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR(const safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR& src); 2720 safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR& operator=(const safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR& src); 2721 safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR(); 2722 ~safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR(); 2723 void initialize(const VkPhysicalDeviceShaderFloat16Int8FeaturesKHR* in_struct); 2724 void initialize(const safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR* src); ptrsafe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR2725 VkPhysicalDeviceShaderFloat16Int8FeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR *>(this); } ptrsafe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR2726 VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const *>(this); } 2727 }; 2728 2729 struct safe_VkPresentRegionKHR { 2730 uint32_t rectangleCount; 2731 const VkRectLayerKHR* pRectangles; 2732 safe_VkPresentRegionKHR(const VkPresentRegionKHR* in_struct); 2733 safe_VkPresentRegionKHR(const safe_VkPresentRegionKHR& src); 2734 safe_VkPresentRegionKHR& operator=(const safe_VkPresentRegionKHR& src); 2735 safe_VkPresentRegionKHR(); 2736 ~safe_VkPresentRegionKHR(); 2737 void initialize(const VkPresentRegionKHR* in_struct); 2738 void initialize(const safe_VkPresentRegionKHR* src); ptrsafe_VkPresentRegionKHR2739 VkPresentRegionKHR *ptr() { return reinterpret_cast<VkPresentRegionKHR *>(this); } ptrsafe_VkPresentRegionKHR2740 VkPresentRegionKHR const *ptr() const { return reinterpret_cast<VkPresentRegionKHR const *>(this); } 2741 }; 2742 2743 struct safe_VkPresentRegionsKHR { 2744 VkStructureType sType; 2745 const void* pNext; 2746 uint32_t swapchainCount; 2747 safe_VkPresentRegionKHR* pRegions; 2748 safe_VkPresentRegionsKHR(const VkPresentRegionsKHR* in_struct); 2749 safe_VkPresentRegionsKHR(const safe_VkPresentRegionsKHR& src); 2750 safe_VkPresentRegionsKHR& operator=(const safe_VkPresentRegionsKHR& src); 2751 safe_VkPresentRegionsKHR(); 2752 ~safe_VkPresentRegionsKHR(); 2753 void initialize(const VkPresentRegionsKHR* in_struct); 2754 void initialize(const safe_VkPresentRegionsKHR* src); ptrsafe_VkPresentRegionsKHR2755 VkPresentRegionsKHR *ptr() { return reinterpret_cast<VkPresentRegionsKHR *>(this); } ptrsafe_VkPresentRegionsKHR2756 VkPresentRegionsKHR const *ptr() const { return reinterpret_cast<VkPresentRegionsKHR const *>(this); } 2757 }; 2758 2759 struct safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR { 2760 VkStructureType sType; 2761 void* pNext; 2762 VkBool32 imagelessFramebuffer; 2763 safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR(const VkPhysicalDeviceImagelessFramebufferFeaturesKHR* in_struct); 2764 safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR(const safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR& src); 2765 safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR& operator=(const safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR& src); 2766 safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR(); 2767 ~safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR(); 2768 void initialize(const VkPhysicalDeviceImagelessFramebufferFeaturesKHR* in_struct); 2769 void initialize(const safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR* src); ptrsafe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR2770 VkPhysicalDeviceImagelessFramebufferFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeaturesKHR *>(this); } ptrsafe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR2771 VkPhysicalDeviceImagelessFramebufferFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeaturesKHR const *>(this); } 2772 }; 2773 2774 struct safe_VkFramebufferAttachmentImageInfoKHR { 2775 VkStructureType sType; 2776 const void* pNext; 2777 VkImageCreateFlags flags; 2778 VkImageUsageFlags usage; 2779 uint32_t width; 2780 uint32_t height; 2781 uint32_t layerCount; 2782 uint32_t viewFormatCount; 2783 const VkFormat* pViewFormats; 2784 safe_VkFramebufferAttachmentImageInfoKHR(const VkFramebufferAttachmentImageInfoKHR* in_struct); 2785 safe_VkFramebufferAttachmentImageInfoKHR(const safe_VkFramebufferAttachmentImageInfoKHR& src); 2786 safe_VkFramebufferAttachmentImageInfoKHR& operator=(const safe_VkFramebufferAttachmentImageInfoKHR& src); 2787 safe_VkFramebufferAttachmentImageInfoKHR(); 2788 ~safe_VkFramebufferAttachmentImageInfoKHR(); 2789 void initialize(const VkFramebufferAttachmentImageInfoKHR* in_struct); 2790 void initialize(const safe_VkFramebufferAttachmentImageInfoKHR* src); ptrsafe_VkFramebufferAttachmentImageInfoKHR2791 VkFramebufferAttachmentImageInfoKHR *ptr() { return reinterpret_cast<VkFramebufferAttachmentImageInfoKHR *>(this); } ptrsafe_VkFramebufferAttachmentImageInfoKHR2792 VkFramebufferAttachmentImageInfoKHR const *ptr() const { return reinterpret_cast<VkFramebufferAttachmentImageInfoKHR const *>(this); } 2793 }; 2794 2795 struct safe_VkFramebufferAttachmentsCreateInfoKHR { 2796 VkStructureType sType; 2797 const void* pNext; 2798 uint32_t attachmentImageInfoCount; 2799 safe_VkFramebufferAttachmentImageInfoKHR* pAttachmentImageInfos; 2800 safe_VkFramebufferAttachmentsCreateInfoKHR(const VkFramebufferAttachmentsCreateInfoKHR* in_struct); 2801 safe_VkFramebufferAttachmentsCreateInfoKHR(const safe_VkFramebufferAttachmentsCreateInfoKHR& src); 2802 safe_VkFramebufferAttachmentsCreateInfoKHR& operator=(const safe_VkFramebufferAttachmentsCreateInfoKHR& src); 2803 safe_VkFramebufferAttachmentsCreateInfoKHR(); 2804 ~safe_VkFramebufferAttachmentsCreateInfoKHR(); 2805 void initialize(const VkFramebufferAttachmentsCreateInfoKHR* in_struct); 2806 void initialize(const safe_VkFramebufferAttachmentsCreateInfoKHR* src); ptrsafe_VkFramebufferAttachmentsCreateInfoKHR2807 VkFramebufferAttachmentsCreateInfoKHR *ptr() { return reinterpret_cast<VkFramebufferAttachmentsCreateInfoKHR *>(this); } ptrsafe_VkFramebufferAttachmentsCreateInfoKHR2808 VkFramebufferAttachmentsCreateInfoKHR const *ptr() const { return reinterpret_cast<VkFramebufferAttachmentsCreateInfoKHR const *>(this); } 2809 }; 2810 2811 struct safe_VkRenderPassAttachmentBeginInfoKHR { 2812 VkStructureType sType; 2813 const void* pNext; 2814 uint32_t attachmentCount; 2815 VkImageView* pAttachments; 2816 safe_VkRenderPassAttachmentBeginInfoKHR(const VkRenderPassAttachmentBeginInfoKHR* in_struct); 2817 safe_VkRenderPassAttachmentBeginInfoKHR(const safe_VkRenderPassAttachmentBeginInfoKHR& src); 2818 safe_VkRenderPassAttachmentBeginInfoKHR& operator=(const safe_VkRenderPassAttachmentBeginInfoKHR& src); 2819 safe_VkRenderPassAttachmentBeginInfoKHR(); 2820 ~safe_VkRenderPassAttachmentBeginInfoKHR(); 2821 void initialize(const VkRenderPassAttachmentBeginInfoKHR* in_struct); 2822 void initialize(const safe_VkRenderPassAttachmentBeginInfoKHR* src); ptrsafe_VkRenderPassAttachmentBeginInfoKHR2823 VkRenderPassAttachmentBeginInfoKHR *ptr() { return reinterpret_cast<VkRenderPassAttachmentBeginInfoKHR *>(this); } ptrsafe_VkRenderPassAttachmentBeginInfoKHR2824 VkRenderPassAttachmentBeginInfoKHR const *ptr() const { return reinterpret_cast<VkRenderPassAttachmentBeginInfoKHR const *>(this); } 2825 }; 2826 2827 struct safe_VkAttachmentDescription2KHR { 2828 VkStructureType sType; 2829 const void* pNext; 2830 VkAttachmentDescriptionFlags flags; 2831 VkFormat format; 2832 VkSampleCountFlagBits samples; 2833 VkAttachmentLoadOp loadOp; 2834 VkAttachmentStoreOp storeOp; 2835 VkAttachmentLoadOp stencilLoadOp; 2836 VkAttachmentStoreOp stencilStoreOp; 2837 VkImageLayout initialLayout; 2838 VkImageLayout finalLayout; 2839 safe_VkAttachmentDescription2KHR(const VkAttachmentDescription2KHR* in_struct); 2840 safe_VkAttachmentDescription2KHR(const safe_VkAttachmentDescription2KHR& src); 2841 safe_VkAttachmentDescription2KHR& operator=(const safe_VkAttachmentDescription2KHR& src); 2842 safe_VkAttachmentDescription2KHR(); 2843 ~safe_VkAttachmentDescription2KHR(); 2844 void initialize(const VkAttachmentDescription2KHR* in_struct); 2845 void initialize(const safe_VkAttachmentDescription2KHR* src); ptrsafe_VkAttachmentDescription2KHR2846 VkAttachmentDescription2KHR *ptr() { return reinterpret_cast<VkAttachmentDescription2KHR *>(this); } ptrsafe_VkAttachmentDescription2KHR2847 VkAttachmentDescription2KHR const *ptr() const { return reinterpret_cast<VkAttachmentDescription2KHR const *>(this); } 2848 }; 2849 2850 struct safe_VkAttachmentReference2KHR { 2851 VkStructureType sType; 2852 const void* pNext; 2853 uint32_t attachment; 2854 VkImageLayout layout; 2855 VkImageAspectFlags aspectMask; 2856 safe_VkAttachmentReference2KHR(const VkAttachmentReference2KHR* in_struct); 2857 safe_VkAttachmentReference2KHR(const safe_VkAttachmentReference2KHR& src); 2858 safe_VkAttachmentReference2KHR& operator=(const safe_VkAttachmentReference2KHR& src); 2859 safe_VkAttachmentReference2KHR(); 2860 ~safe_VkAttachmentReference2KHR(); 2861 void initialize(const VkAttachmentReference2KHR* in_struct); 2862 void initialize(const safe_VkAttachmentReference2KHR* src); ptrsafe_VkAttachmentReference2KHR2863 VkAttachmentReference2KHR *ptr() { return reinterpret_cast<VkAttachmentReference2KHR *>(this); } ptrsafe_VkAttachmentReference2KHR2864 VkAttachmentReference2KHR const *ptr() const { return reinterpret_cast<VkAttachmentReference2KHR const *>(this); } 2865 }; 2866 2867 struct safe_VkSubpassDescription2KHR { 2868 VkStructureType sType; 2869 const void* pNext; 2870 VkSubpassDescriptionFlags flags; 2871 VkPipelineBindPoint pipelineBindPoint; 2872 uint32_t viewMask; 2873 uint32_t inputAttachmentCount; 2874 safe_VkAttachmentReference2KHR* pInputAttachments; 2875 uint32_t colorAttachmentCount; 2876 safe_VkAttachmentReference2KHR* pColorAttachments; 2877 safe_VkAttachmentReference2KHR* pResolveAttachments; 2878 safe_VkAttachmentReference2KHR* pDepthStencilAttachment; 2879 uint32_t preserveAttachmentCount; 2880 const uint32_t* pPreserveAttachments; 2881 safe_VkSubpassDescription2KHR(const VkSubpassDescription2KHR* in_struct); 2882 safe_VkSubpassDescription2KHR(const safe_VkSubpassDescription2KHR& src); 2883 safe_VkSubpassDescription2KHR& operator=(const safe_VkSubpassDescription2KHR& src); 2884 safe_VkSubpassDescription2KHR(); 2885 ~safe_VkSubpassDescription2KHR(); 2886 void initialize(const VkSubpassDescription2KHR* in_struct); 2887 void initialize(const safe_VkSubpassDescription2KHR* src); ptrsafe_VkSubpassDescription2KHR2888 VkSubpassDescription2KHR *ptr() { return reinterpret_cast<VkSubpassDescription2KHR *>(this); } ptrsafe_VkSubpassDescription2KHR2889 VkSubpassDescription2KHR const *ptr() const { return reinterpret_cast<VkSubpassDescription2KHR const *>(this); } 2890 }; 2891 2892 struct safe_VkSubpassDependency2KHR { 2893 VkStructureType sType; 2894 const void* pNext; 2895 uint32_t srcSubpass; 2896 uint32_t dstSubpass; 2897 VkPipelineStageFlags srcStageMask; 2898 VkPipelineStageFlags dstStageMask; 2899 VkAccessFlags srcAccessMask; 2900 VkAccessFlags dstAccessMask; 2901 VkDependencyFlags dependencyFlags; 2902 int32_t viewOffset; 2903 safe_VkSubpassDependency2KHR(const VkSubpassDependency2KHR* in_struct); 2904 safe_VkSubpassDependency2KHR(const safe_VkSubpassDependency2KHR& src); 2905 safe_VkSubpassDependency2KHR& operator=(const safe_VkSubpassDependency2KHR& src); 2906 safe_VkSubpassDependency2KHR(); 2907 ~safe_VkSubpassDependency2KHR(); 2908 void initialize(const VkSubpassDependency2KHR* in_struct); 2909 void initialize(const safe_VkSubpassDependency2KHR* src); ptrsafe_VkSubpassDependency2KHR2910 VkSubpassDependency2KHR *ptr() { return reinterpret_cast<VkSubpassDependency2KHR *>(this); } ptrsafe_VkSubpassDependency2KHR2911 VkSubpassDependency2KHR const *ptr() const { return reinterpret_cast<VkSubpassDependency2KHR const *>(this); } 2912 }; 2913 2914 struct safe_VkRenderPassCreateInfo2KHR { 2915 VkStructureType sType; 2916 const void* pNext; 2917 VkRenderPassCreateFlags flags; 2918 uint32_t attachmentCount; 2919 safe_VkAttachmentDescription2KHR* pAttachments; 2920 uint32_t subpassCount; 2921 safe_VkSubpassDescription2KHR* pSubpasses; 2922 uint32_t dependencyCount; 2923 safe_VkSubpassDependency2KHR* pDependencies; 2924 uint32_t correlatedViewMaskCount; 2925 const uint32_t* pCorrelatedViewMasks; 2926 safe_VkRenderPassCreateInfo2KHR(const VkRenderPassCreateInfo2KHR* in_struct); 2927 safe_VkRenderPassCreateInfo2KHR(const safe_VkRenderPassCreateInfo2KHR& src); 2928 safe_VkRenderPassCreateInfo2KHR& operator=(const safe_VkRenderPassCreateInfo2KHR& src); 2929 safe_VkRenderPassCreateInfo2KHR(); 2930 ~safe_VkRenderPassCreateInfo2KHR(); 2931 void initialize(const VkRenderPassCreateInfo2KHR* in_struct); 2932 void initialize(const safe_VkRenderPassCreateInfo2KHR* src); ptrsafe_VkRenderPassCreateInfo2KHR2933 VkRenderPassCreateInfo2KHR *ptr() { return reinterpret_cast<VkRenderPassCreateInfo2KHR *>(this); } ptrsafe_VkRenderPassCreateInfo2KHR2934 VkRenderPassCreateInfo2KHR const *ptr() const { return reinterpret_cast<VkRenderPassCreateInfo2KHR const *>(this); } 2935 }; 2936 2937 struct safe_VkSubpassBeginInfoKHR { 2938 VkStructureType sType; 2939 const void* pNext; 2940 VkSubpassContents contents; 2941 safe_VkSubpassBeginInfoKHR(const VkSubpassBeginInfoKHR* in_struct); 2942 safe_VkSubpassBeginInfoKHR(const safe_VkSubpassBeginInfoKHR& src); 2943 safe_VkSubpassBeginInfoKHR& operator=(const safe_VkSubpassBeginInfoKHR& src); 2944 safe_VkSubpassBeginInfoKHR(); 2945 ~safe_VkSubpassBeginInfoKHR(); 2946 void initialize(const VkSubpassBeginInfoKHR* in_struct); 2947 void initialize(const safe_VkSubpassBeginInfoKHR* src); ptrsafe_VkSubpassBeginInfoKHR2948 VkSubpassBeginInfoKHR *ptr() { return reinterpret_cast<VkSubpassBeginInfoKHR *>(this); } ptrsafe_VkSubpassBeginInfoKHR2949 VkSubpassBeginInfoKHR const *ptr() const { return reinterpret_cast<VkSubpassBeginInfoKHR const *>(this); } 2950 }; 2951 2952 struct safe_VkSubpassEndInfoKHR { 2953 VkStructureType sType; 2954 const void* pNext; 2955 safe_VkSubpassEndInfoKHR(const VkSubpassEndInfoKHR* in_struct); 2956 safe_VkSubpassEndInfoKHR(const safe_VkSubpassEndInfoKHR& src); 2957 safe_VkSubpassEndInfoKHR& operator=(const safe_VkSubpassEndInfoKHR& src); 2958 safe_VkSubpassEndInfoKHR(); 2959 ~safe_VkSubpassEndInfoKHR(); 2960 void initialize(const VkSubpassEndInfoKHR* in_struct); 2961 void initialize(const safe_VkSubpassEndInfoKHR* src); ptrsafe_VkSubpassEndInfoKHR2962 VkSubpassEndInfoKHR *ptr() { return reinterpret_cast<VkSubpassEndInfoKHR *>(this); } ptrsafe_VkSubpassEndInfoKHR2963 VkSubpassEndInfoKHR const *ptr() const { return reinterpret_cast<VkSubpassEndInfoKHR const *>(this); } 2964 }; 2965 2966 struct safe_VkSharedPresentSurfaceCapabilitiesKHR { 2967 VkStructureType sType; 2968 void* pNext; 2969 VkImageUsageFlags sharedPresentSupportedUsageFlags; 2970 safe_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct); 2971 safe_VkSharedPresentSurfaceCapabilitiesKHR(const safe_VkSharedPresentSurfaceCapabilitiesKHR& src); 2972 safe_VkSharedPresentSurfaceCapabilitiesKHR& operator=(const safe_VkSharedPresentSurfaceCapabilitiesKHR& src); 2973 safe_VkSharedPresentSurfaceCapabilitiesKHR(); 2974 ~safe_VkSharedPresentSurfaceCapabilitiesKHR(); 2975 void initialize(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct); 2976 void initialize(const safe_VkSharedPresentSurfaceCapabilitiesKHR* src); ptrsafe_VkSharedPresentSurfaceCapabilitiesKHR2977 VkSharedPresentSurfaceCapabilitiesKHR *ptr() { return reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR *>(this); } ptrsafe_VkSharedPresentSurfaceCapabilitiesKHR2978 VkSharedPresentSurfaceCapabilitiesKHR const *ptr() const { return reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR const *>(this); } 2979 }; 2980 2981 #ifdef VK_USE_PLATFORM_WIN32_KHR 2982 struct safe_VkImportFenceWin32HandleInfoKHR { 2983 VkStructureType sType; 2984 const void* pNext; 2985 VkFence fence; 2986 VkFenceImportFlags flags; 2987 VkExternalFenceHandleTypeFlagBits handleType; 2988 HANDLE handle; 2989 LPCWSTR name; 2990 safe_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR* in_struct); 2991 safe_VkImportFenceWin32HandleInfoKHR(const safe_VkImportFenceWin32HandleInfoKHR& src); 2992 safe_VkImportFenceWin32HandleInfoKHR& operator=(const safe_VkImportFenceWin32HandleInfoKHR& src); 2993 safe_VkImportFenceWin32HandleInfoKHR(); 2994 ~safe_VkImportFenceWin32HandleInfoKHR(); 2995 void initialize(const VkImportFenceWin32HandleInfoKHR* in_struct); 2996 void initialize(const safe_VkImportFenceWin32HandleInfoKHR* src); ptrsafe_VkImportFenceWin32HandleInfoKHR2997 VkImportFenceWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkImportFenceWin32HandleInfoKHR *>(this); } ptrsafe_VkImportFenceWin32HandleInfoKHR2998 VkImportFenceWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkImportFenceWin32HandleInfoKHR const *>(this); } 2999 }; 3000 #endif // VK_USE_PLATFORM_WIN32_KHR 3001 3002 #ifdef VK_USE_PLATFORM_WIN32_KHR 3003 struct safe_VkExportFenceWin32HandleInfoKHR { 3004 VkStructureType sType; 3005 const void* pNext; 3006 const SECURITY_ATTRIBUTES* pAttributes; 3007 DWORD dwAccess; 3008 LPCWSTR name; 3009 safe_VkExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR* in_struct); 3010 safe_VkExportFenceWin32HandleInfoKHR(const safe_VkExportFenceWin32HandleInfoKHR& src); 3011 safe_VkExportFenceWin32HandleInfoKHR& operator=(const safe_VkExportFenceWin32HandleInfoKHR& src); 3012 safe_VkExportFenceWin32HandleInfoKHR(); 3013 ~safe_VkExportFenceWin32HandleInfoKHR(); 3014 void initialize(const VkExportFenceWin32HandleInfoKHR* in_struct); 3015 void initialize(const safe_VkExportFenceWin32HandleInfoKHR* src); ptrsafe_VkExportFenceWin32HandleInfoKHR3016 VkExportFenceWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkExportFenceWin32HandleInfoKHR *>(this); } ptrsafe_VkExportFenceWin32HandleInfoKHR3017 VkExportFenceWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkExportFenceWin32HandleInfoKHR const *>(this); } 3018 }; 3019 #endif // VK_USE_PLATFORM_WIN32_KHR 3020 3021 #ifdef VK_USE_PLATFORM_WIN32_KHR 3022 struct safe_VkFenceGetWin32HandleInfoKHR { 3023 VkStructureType sType; 3024 const void* pNext; 3025 VkFence fence; 3026 VkExternalFenceHandleTypeFlagBits handleType; 3027 safe_VkFenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR* in_struct); 3028 safe_VkFenceGetWin32HandleInfoKHR(const safe_VkFenceGetWin32HandleInfoKHR& src); 3029 safe_VkFenceGetWin32HandleInfoKHR& operator=(const safe_VkFenceGetWin32HandleInfoKHR& src); 3030 safe_VkFenceGetWin32HandleInfoKHR(); 3031 ~safe_VkFenceGetWin32HandleInfoKHR(); 3032 void initialize(const VkFenceGetWin32HandleInfoKHR* in_struct); 3033 void initialize(const safe_VkFenceGetWin32HandleInfoKHR* src); ptrsafe_VkFenceGetWin32HandleInfoKHR3034 VkFenceGetWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkFenceGetWin32HandleInfoKHR *>(this); } ptrsafe_VkFenceGetWin32HandleInfoKHR3035 VkFenceGetWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkFenceGetWin32HandleInfoKHR const *>(this); } 3036 }; 3037 #endif // VK_USE_PLATFORM_WIN32_KHR 3038 3039 struct safe_VkImportFenceFdInfoKHR { 3040 VkStructureType sType; 3041 const void* pNext; 3042 VkFence fence; 3043 VkFenceImportFlags flags; 3044 VkExternalFenceHandleTypeFlagBits handleType; 3045 int fd; 3046 safe_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR* in_struct); 3047 safe_VkImportFenceFdInfoKHR(const safe_VkImportFenceFdInfoKHR& src); 3048 safe_VkImportFenceFdInfoKHR& operator=(const safe_VkImportFenceFdInfoKHR& src); 3049 safe_VkImportFenceFdInfoKHR(); 3050 ~safe_VkImportFenceFdInfoKHR(); 3051 void initialize(const VkImportFenceFdInfoKHR* in_struct); 3052 void initialize(const safe_VkImportFenceFdInfoKHR* src); ptrsafe_VkImportFenceFdInfoKHR3053 VkImportFenceFdInfoKHR *ptr() { return reinterpret_cast<VkImportFenceFdInfoKHR *>(this); } ptrsafe_VkImportFenceFdInfoKHR3054 VkImportFenceFdInfoKHR const *ptr() const { return reinterpret_cast<VkImportFenceFdInfoKHR const *>(this); } 3055 }; 3056 3057 struct safe_VkFenceGetFdInfoKHR { 3058 VkStructureType sType; 3059 const void* pNext; 3060 VkFence fence; 3061 VkExternalFenceHandleTypeFlagBits handleType; 3062 safe_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR* in_struct); 3063 safe_VkFenceGetFdInfoKHR(const safe_VkFenceGetFdInfoKHR& src); 3064 safe_VkFenceGetFdInfoKHR& operator=(const safe_VkFenceGetFdInfoKHR& src); 3065 safe_VkFenceGetFdInfoKHR(); 3066 ~safe_VkFenceGetFdInfoKHR(); 3067 void initialize(const VkFenceGetFdInfoKHR* in_struct); 3068 void initialize(const safe_VkFenceGetFdInfoKHR* src); ptrsafe_VkFenceGetFdInfoKHR3069 VkFenceGetFdInfoKHR *ptr() { return reinterpret_cast<VkFenceGetFdInfoKHR *>(this); } ptrsafe_VkFenceGetFdInfoKHR3070 VkFenceGetFdInfoKHR const *ptr() const { return reinterpret_cast<VkFenceGetFdInfoKHR const *>(this); } 3071 }; 3072 3073 struct safe_VkPhysicalDeviceSurfaceInfo2KHR { 3074 VkStructureType sType; 3075 const void* pNext; 3076 VkSurfaceKHR surface; 3077 safe_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct); 3078 safe_VkPhysicalDeviceSurfaceInfo2KHR(const safe_VkPhysicalDeviceSurfaceInfo2KHR& src); 3079 safe_VkPhysicalDeviceSurfaceInfo2KHR& operator=(const safe_VkPhysicalDeviceSurfaceInfo2KHR& src); 3080 safe_VkPhysicalDeviceSurfaceInfo2KHR(); 3081 ~safe_VkPhysicalDeviceSurfaceInfo2KHR(); 3082 void initialize(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct); 3083 void initialize(const safe_VkPhysicalDeviceSurfaceInfo2KHR* src); ptrsafe_VkPhysicalDeviceSurfaceInfo2KHR3084 VkPhysicalDeviceSurfaceInfo2KHR *ptr() { return reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR *>(this); } ptrsafe_VkPhysicalDeviceSurfaceInfo2KHR3085 VkPhysicalDeviceSurfaceInfo2KHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR const *>(this); } 3086 }; 3087 3088 struct safe_VkSurfaceCapabilities2KHR { 3089 VkStructureType sType; 3090 void* pNext; 3091 VkSurfaceCapabilitiesKHR surfaceCapabilities; 3092 safe_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR* in_struct); 3093 safe_VkSurfaceCapabilities2KHR(const safe_VkSurfaceCapabilities2KHR& src); 3094 safe_VkSurfaceCapabilities2KHR& operator=(const safe_VkSurfaceCapabilities2KHR& src); 3095 safe_VkSurfaceCapabilities2KHR(); 3096 ~safe_VkSurfaceCapabilities2KHR(); 3097 void initialize(const VkSurfaceCapabilities2KHR* in_struct); 3098 void initialize(const safe_VkSurfaceCapabilities2KHR* src); ptrsafe_VkSurfaceCapabilities2KHR3099 VkSurfaceCapabilities2KHR *ptr() { return reinterpret_cast<VkSurfaceCapabilities2KHR *>(this); } ptrsafe_VkSurfaceCapabilities2KHR3100 VkSurfaceCapabilities2KHR const *ptr() const { return reinterpret_cast<VkSurfaceCapabilities2KHR const *>(this); } 3101 }; 3102 3103 struct safe_VkSurfaceFormat2KHR { 3104 VkStructureType sType; 3105 void* pNext; 3106 VkSurfaceFormatKHR surfaceFormat; 3107 safe_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR* in_struct); 3108 safe_VkSurfaceFormat2KHR(const safe_VkSurfaceFormat2KHR& src); 3109 safe_VkSurfaceFormat2KHR& operator=(const safe_VkSurfaceFormat2KHR& src); 3110 safe_VkSurfaceFormat2KHR(); 3111 ~safe_VkSurfaceFormat2KHR(); 3112 void initialize(const VkSurfaceFormat2KHR* in_struct); 3113 void initialize(const safe_VkSurfaceFormat2KHR* src); ptrsafe_VkSurfaceFormat2KHR3114 VkSurfaceFormat2KHR *ptr() { return reinterpret_cast<VkSurfaceFormat2KHR *>(this); } ptrsafe_VkSurfaceFormat2KHR3115 VkSurfaceFormat2KHR const *ptr() const { return reinterpret_cast<VkSurfaceFormat2KHR const *>(this); } 3116 }; 3117 3118 struct safe_VkDisplayProperties2KHR { 3119 VkStructureType sType; 3120 void* pNext; 3121 safe_VkDisplayPropertiesKHR displayProperties; 3122 safe_VkDisplayProperties2KHR(const VkDisplayProperties2KHR* in_struct); 3123 safe_VkDisplayProperties2KHR(const safe_VkDisplayProperties2KHR& src); 3124 safe_VkDisplayProperties2KHR& operator=(const safe_VkDisplayProperties2KHR& src); 3125 safe_VkDisplayProperties2KHR(); 3126 ~safe_VkDisplayProperties2KHR(); 3127 void initialize(const VkDisplayProperties2KHR* in_struct); 3128 void initialize(const safe_VkDisplayProperties2KHR* src); ptrsafe_VkDisplayProperties2KHR3129 VkDisplayProperties2KHR *ptr() { return reinterpret_cast<VkDisplayProperties2KHR *>(this); } ptrsafe_VkDisplayProperties2KHR3130 VkDisplayProperties2KHR const *ptr() const { return reinterpret_cast<VkDisplayProperties2KHR const *>(this); } 3131 }; 3132 3133 struct safe_VkDisplayPlaneProperties2KHR { 3134 VkStructureType sType; 3135 void* pNext; 3136 VkDisplayPlanePropertiesKHR displayPlaneProperties; 3137 safe_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR* in_struct); 3138 safe_VkDisplayPlaneProperties2KHR(const safe_VkDisplayPlaneProperties2KHR& src); 3139 safe_VkDisplayPlaneProperties2KHR& operator=(const safe_VkDisplayPlaneProperties2KHR& src); 3140 safe_VkDisplayPlaneProperties2KHR(); 3141 ~safe_VkDisplayPlaneProperties2KHR(); 3142 void initialize(const VkDisplayPlaneProperties2KHR* in_struct); 3143 void initialize(const safe_VkDisplayPlaneProperties2KHR* src); ptrsafe_VkDisplayPlaneProperties2KHR3144 VkDisplayPlaneProperties2KHR *ptr() { return reinterpret_cast<VkDisplayPlaneProperties2KHR *>(this); } ptrsafe_VkDisplayPlaneProperties2KHR3145 VkDisplayPlaneProperties2KHR const *ptr() const { return reinterpret_cast<VkDisplayPlaneProperties2KHR const *>(this); } 3146 }; 3147 3148 struct safe_VkDisplayModeProperties2KHR { 3149 VkStructureType sType; 3150 void* pNext; 3151 VkDisplayModePropertiesKHR displayModeProperties; 3152 safe_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR* in_struct); 3153 safe_VkDisplayModeProperties2KHR(const safe_VkDisplayModeProperties2KHR& src); 3154 safe_VkDisplayModeProperties2KHR& operator=(const safe_VkDisplayModeProperties2KHR& src); 3155 safe_VkDisplayModeProperties2KHR(); 3156 ~safe_VkDisplayModeProperties2KHR(); 3157 void initialize(const VkDisplayModeProperties2KHR* in_struct); 3158 void initialize(const safe_VkDisplayModeProperties2KHR* src); ptrsafe_VkDisplayModeProperties2KHR3159 VkDisplayModeProperties2KHR *ptr() { return reinterpret_cast<VkDisplayModeProperties2KHR *>(this); } ptrsafe_VkDisplayModeProperties2KHR3160 VkDisplayModeProperties2KHR const *ptr() const { return reinterpret_cast<VkDisplayModeProperties2KHR const *>(this); } 3161 }; 3162 3163 struct safe_VkDisplayPlaneInfo2KHR { 3164 VkStructureType sType; 3165 const void* pNext; 3166 VkDisplayModeKHR mode; 3167 uint32_t planeIndex; 3168 safe_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR* in_struct); 3169 safe_VkDisplayPlaneInfo2KHR(const safe_VkDisplayPlaneInfo2KHR& src); 3170 safe_VkDisplayPlaneInfo2KHR& operator=(const safe_VkDisplayPlaneInfo2KHR& src); 3171 safe_VkDisplayPlaneInfo2KHR(); 3172 ~safe_VkDisplayPlaneInfo2KHR(); 3173 void initialize(const VkDisplayPlaneInfo2KHR* in_struct); 3174 void initialize(const safe_VkDisplayPlaneInfo2KHR* src); ptrsafe_VkDisplayPlaneInfo2KHR3175 VkDisplayPlaneInfo2KHR *ptr() { return reinterpret_cast<VkDisplayPlaneInfo2KHR *>(this); } ptrsafe_VkDisplayPlaneInfo2KHR3176 VkDisplayPlaneInfo2KHR const *ptr() const { return reinterpret_cast<VkDisplayPlaneInfo2KHR const *>(this); } 3177 }; 3178 3179 struct safe_VkDisplayPlaneCapabilities2KHR { 3180 VkStructureType sType; 3181 void* pNext; 3182 VkDisplayPlaneCapabilitiesKHR capabilities; 3183 safe_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR* in_struct); 3184 safe_VkDisplayPlaneCapabilities2KHR(const safe_VkDisplayPlaneCapabilities2KHR& src); 3185 safe_VkDisplayPlaneCapabilities2KHR& operator=(const safe_VkDisplayPlaneCapabilities2KHR& src); 3186 safe_VkDisplayPlaneCapabilities2KHR(); 3187 ~safe_VkDisplayPlaneCapabilities2KHR(); 3188 void initialize(const VkDisplayPlaneCapabilities2KHR* in_struct); 3189 void initialize(const safe_VkDisplayPlaneCapabilities2KHR* src); ptrsafe_VkDisplayPlaneCapabilities2KHR3190 VkDisplayPlaneCapabilities2KHR *ptr() { return reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>(this); } ptrsafe_VkDisplayPlaneCapabilities2KHR3191 VkDisplayPlaneCapabilities2KHR const *ptr() const { return reinterpret_cast<VkDisplayPlaneCapabilities2KHR const *>(this); } 3192 }; 3193 3194 struct safe_VkImageFormatListCreateInfoKHR { 3195 VkStructureType sType; 3196 const void* pNext; 3197 uint32_t viewFormatCount; 3198 const VkFormat* pViewFormats; 3199 safe_VkImageFormatListCreateInfoKHR(const VkImageFormatListCreateInfoKHR* in_struct); 3200 safe_VkImageFormatListCreateInfoKHR(const safe_VkImageFormatListCreateInfoKHR& src); 3201 safe_VkImageFormatListCreateInfoKHR& operator=(const safe_VkImageFormatListCreateInfoKHR& src); 3202 safe_VkImageFormatListCreateInfoKHR(); 3203 ~safe_VkImageFormatListCreateInfoKHR(); 3204 void initialize(const VkImageFormatListCreateInfoKHR* in_struct); 3205 void initialize(const safe_VkImageFormatListCreateInfoKHR* src); ptrsafe_VkImageFormatListCreateInfoKHR3206 VkImageFormatListCreateInfoKHR *ptr() { return reinterpret_cast<VkImageFormatListCreateInfoKHR *>(this); } ptrsafe_VkImageFormatListCreateInfoKHR3207 VkImageFormatListCreateInfoKHR const *ptr() const { return reinterpret_cast<VkImageFormatListCreateInfoKHR const *>(this); } 3208 }; 3209 3210 struct safe_VkPhysicalDevice8BitStorageFeaturesKHR { 3211 VkStructureType sType; 3212 void* pNext; 3213 VkBool32 storageBuffer8BitAccess; 3214 VkBool32 uniformAndStorageBuffer8BitAccess; 3215 VkBool32 storagePushConstant8; 3216 safe_VkPhysicalDevice8BitStorageFeaturesKHR(const VkPhysicalDevice8BitStorageFeaturesKHR* in_struct); 3217 safe_VkPhysicalDevice8BitStorageFeaturesKHR(const safe_VkPhysicalDevice8BitStorageFeaturesKHR& src); 3218 safe_VkPhysicalDevice8BitStorageFeaturesKHR& operator=(const safe_VkPhysicalDevice8BitStorageFeaturesKHR& src); 3219 safe_VkPhysicalDevice8BitStorageFeaturesKHR(); 3220 ~safe_VkPhysicalDevice8BitStorageFeaturesKHR(); 3221 void initialize(const VkPhysicalDevice8BitStorageFeaturesKHR* in_struct); 3222 void initialize(const safe_VkPhysicalDevice8BitStorageFeaturesKHR* src); ptrsafe_VkPhysicalDevice8BitStorageFeaturesKHR3223 VkPhysicalDevice8BitStorageFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR *>(this); } ptrsafe_VkPhysicalDevice8BitStorageFeaturesKHR3224 VkPhysicalDevice8BitStorageFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR const *>(this); } 3225 }; 3226 3227 struct safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR { 3228 VkStructureType sType; 3229 void* pNext; 3230 VkBool32 shaderBufferInt64Atomics; 3231 VkBool32 shaderSharedInt64Atomics; 3232 safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR(const VkPhysicalDeviceShaderAtomicInt64FeaturesKHR* in_struct); 3233 safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR(const safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR& src); 3234 safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR& operator=(const safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR& src); 3235 safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR(); 3236 ~safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR(); 3237 void initialize(const VkPhysicalDeviceShaderAtomicInt64FeaturesKHR* in_struct); 3238 void initialize(const safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR* src); ptrsafe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR3239 VkPhysicalDeviceShaderAtomicInt64FeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR *>(this); } ptrsafe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR3240 VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const *>(this); } 3241 }; 3242 3243 struct safe_VkPhysicalDeviceDriverPropertiesKHR { 3244 VkStructureType sType; 3245 void* pNext; 3246 VkDriverIdKHR driverID; 3247 char driverName[VK_MAX_DRIVER_NAME_SIZE_KHR]; 3248 char driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR]; 3249 VkConformanceVersionKHR conformanceVersion; 3250 safe_VkPhysicalDeviceDriverPropertiesKHR(const VkPhysicalDeviceDriverPropertiesKHR* in_struct); 3251 safe_VkPhysicalDeviceDriverPropertiesKHR(const safe_VkPhysicalDeviceDriverPropertiesKHR& src); 3252 safe_VkPhysicalDeviceDriverPropertiesKHR& operator=(const safe_VkPhysicalDeviceDriverPropertiesKHR& src); 3253 safe_VkPhysicalDeviceDriverPropertiesKHR(); 3254 ~safe_VkPhysicalDeviceDriverPropertiesKHR(); 3255 void initialize(const VkPhysicalDeviceDriverPropertiesKHR* in_struct); 3256 void initialize(const safe_VkPhysicalDeviceDriverPropertiesKHR* src); ptrsafe_VkPhysicalDeviceDriverPropertiesKHR3257 VkPhysicalDeviceDriverPropertiesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceDriverPropertiesKHR *>(this); } ptrsafe_VkPhysicalDeviceDriverPropertiesKHR3258 VkPhysicalDeviceDriverPropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDriverPropertiesKHR const *>(this); } 3259 }; 3260 3261 struct safe_VkPhysicalDeviceFloatControlsPropertiesKHR { 3262 VkStructureType sType; 3263 void* pNext; 3264 VkShaderFloatControlsIndependenceKHR denormBehaviorIndependence; 3265 VkShaderFloatControlsIndependenceKHR roundingModeIndependence; 3266 VkBool32 shaderSignedZeroInfNanPreserveFloat16; 3267 VkBool32 shaderSignedZeroInfNanPreserveFloat32; 3268 VkBool32 shaderSignedZeroInfNanPreserveFloat64; 3269 VkBool32 shaderDenormPreserveFloat16; 3270 VkBool32 shaderDenormPreserveFloat32; 3271 VkBool32 shaderDenormPreserveFloat64; 3272 VkBool32 shaderDenormFlushToZeroFloat16; 3273 VkBool32 shaderDenormFlushToZeroFloat32; 3274 VkBool32 shaderDenormFlushToZeroFloat64; 3275 VkBool32 shaderRoundingModeRTEFloat16; 3276 VkBool32 shaderRoundingModeRTEFloat32; 3277 VkBool32 shaderRoundingModeRTEFloat64; 3278 VkBool32 shaderRoundingModeRTZFloat16; 3279 VkBool32 shaderRoundingModeRTZFloat32; 3280 VkBool32 shaderRoundingModeRTZFloat64; 3281 safe_VkPhysicalDeviceFloatControlsPropertiesKHR(const VkPhysicalDeviceFloatControlsPropertiesKHR* in_struct); 3282 safe_VkPhysicalDeviceFloatControlsPropertiesKHR(const safe_VkPhysicalDeviceFloatControlsPropertiesKHR& src); 3283 safe_VkPhysicalDeviceFloatControlsPropertiesKHR& operator=(const safe_VkPhysicalDeviceFloatControlsPropertiesKHR& src); 3284 safe_VkPhysicalDeviceFloatControlsPropertiesKHR(); 3285 ~safe_VkPhysicalDeviceFloatControlsPropertiesKHR(); 3286 void initialize(const VkPhysicalDeviceFloatControlsPropertiesKHR* in_struct); 3287 void initialize(const safe_VkPhysicalDeviceFloatControlsPropertiesKHR* src); ptrsafe_VkPhysicalDeviceFloatControlsPropertiesKHR3288 VkPhysicalDeviceFloatControlsPropertiesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceFloatControlsPropertiesKHR *>(this); } ptrsafe_VkPhysicalDeviceFloatControlsPropertiesKHR3289 VkPhysicalDeviceFloatControlsPropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFloatControlsPropertiesKHR const *>(this); } 3290 }; 3291 3292 struct safe_VkSubpassDescriptionDepthStencilResolveKHR { 3293 VkStructureType sType; 3294 const void* pNext; 3295 VkResolveModeFlagBitsKHR depthResolveMode; 3296 VkResolveModeFlagBitsKHR stencilResolveMode; 3297 safe_VkAttachmentReference2KHR* pDepthStencilResolveAttachment; 3298 safe_VkSubpassDescriptionDepthStencilResolveKHR(const VkSubpassDescriptionDepthStencilResolveKHR* in_struct); 3299 safe_VkSubpassDescriptionDepthStencilResolveKHR(const safe_VkSubpassDescriptionDepthStencilResolveKHR& src); 3300 safe_VkSubpassDescriptionDepthStencilResolveKHR& operator=(const safe_VkSubpassDescriptionDepthStencilResolveKHR& src); 3301 safe_VkSubpassDescriptionDepthStencilResolveKHR(); 3302 ~safe_VkSubpassDescriptionDepthStencilResolveKHR(); 3303 void initialize(const VkSubpassDescriptionDepthStencilResolveKHR* in_struct); 3304 void initialize(const safe_VkSubpassDescriptionDepthStencilResolveKHR* src); ptrsafe_VkSubpassDescriptionDepthStencilResolveKHR3305 VkSubpassDescriptionDepthStencilResolveKHR *ptr() { return reinterpret_cast<VkSubpassDescriptionDepthStencilResolveKHR *>(this); } ptrsafe_VkSubpassDescriptionDepthStencilResolveKHR3306 VkSubpassDescriptionDepthStencilResolveKHR const *ptr() const { return reinterpret_cast<VkSubpassDescriptionDepthStencilResolveKHR const *>(this); } 3307 }; 3308 3309 struct safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR { 3310 VkStructureType sType; 3311 void* pNext; 3312 VkResolveModeFlagsKHR supportedDepthResolveModes; 3313 VkResolveModeFlagsKHR supportedStencilResolveModes; 3314 VkBool32 independentResolveNone; 3315 VkBool32 independentResolve; 3316 safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR(const VkPhysicalDeviceDepthStencilResolvePropertiesKHR* in_struct); 3317 safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR(const safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR& src); 3318 safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR& operator=(const safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR& src); 3319 safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR(); 3320 ~safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR(); 3321 void initialize(const VkPhysicalDeviceDepthStencilResolvePropertiesKHR* in_struct); 3322 void initialize(const safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR* src); ptrsafe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR3323 VkPhysicalDeviceDepthStencilResolvePropertiesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceDepthStencilResolvePropertiesKHR *>(this); } ptrsafe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR3324 VkPhysicalDeviceDepthStencilResolvePropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDepthStencilResolvePropertiesKHR const *>(this); } 3325 }; 3326 3327 struct safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR { 3328 VkStructureType sType; 3329 void* pNext; 3330 VkBool32 vulkanMemoryModel; 3331 VkBool32 vulkanMemoryModelDeviceScope; 3332 VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; 3333 safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR(const VkPhysicalDeviceVulkanMemoryModelFeaturesKHR* in_struct); 3334 safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR(const safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR& src); 3335 safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR& operator=(const safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR& src); 3336 safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR(); 3337 ~safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR(); 3338 void initialize(const VkPhysicalDeviceVulkanMemoryModelFeaturesKHR* in_struct); 3339 void initialize(const safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR* src); ptrsafe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR3340 VkPhysicalDeviceVulkanMemoryModelFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeaturesKHR *>(this); } ptrsafe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR3341 VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const *>(this); } 3342 }; 3343 3344 struct safe_VkSurfaceProtectedCapabilitiesKHR { 3345 VkStructureType sType; 3346 const void* pNext; 3347 VkBool32 supportsProtected; 3348 safe_VkSurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR* in_struct); 3349 safe_VkSurfaceProtectedCapabilitiesKHR(const safe_VkSurfaceProtectedCapabilitiesKHR& src); 3350 safe_VkSurfaceProtectedCapabilitiesKHR& operator=(const safe_VkSurfaceProtectedCapabilitiesKHR& src); 3351 safe_VkSurfaceProtectedCapabilitiesKHR(); 3352 ~safe_VkSurfaceProtectedCapabilitiesKHR(); 3353 void initialize(const VkSurfaceProtectedCapabilitiesKHR* in_struct); 3354 void initialize(const safe_VkSurfaceProtectedCapabilitiesKHR* src); ptrsafe_VkSurfaceProtectedCapabilitiesKHR3355 VkSurfaceProtectedCapabilitiesKHR *ptr() { return reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR *>(this); } ptrsafe_VkSurfaceProtectedCapabilitiesKHR3356 VkSurfaceProtectedCapabilitiesKHR const *ptr() const { return reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR const *>(this); } 3357 }; 3358 3359 struct safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR { 3360 VkStructureType sType; 3361 void* pNext; 3362 VkBool32 uniformBufferStandardLayout; 3363 safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR(const VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR* in_struct); 3364 safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& src); 3365 safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& operator=(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& src); 3366 safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR(); 3367 ~safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR(); 3368 void initialize(const VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR* in_struct); 3369 void initialize(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR* src); ptrsafe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR3370 VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR *>(this); } ptrsafe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR3371 VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const *>(this); } 3372 }; 3373 3374 struct safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR { 3375 VkStructureType sType; 3376 void* pNext; 3377 VkBool32 pipelineExecutableInfo; 3378 safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct); 3379 safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& src); 3380 safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& src); 3381 safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(); 3382 ~safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(); 3383 void initialize(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct); 3384 void initialize(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* src); ptrsafe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR3385 VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>(this); } ptrsafe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR3386 VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const *>(this); } 3387 }; 3388 3389 struct safe_VkPipelineInfoKHR { 3390 VkStructureType sType; 3391 const void* pNext; 3392 VkPipeline pipeline; 3393 safe_VkPipelineInfoKHR(const VkPipelineInfoKHR* in_struct); 3394 safe_VkPipelineInfoKHR(const safe_VkPipelineInfoKHR& src); 3395 safe_VkPipelineInfoKHR& operator=(const safe_VkPipelineInfoKHR& src); 3396 safe_VkPipelineInfoKHR(); 3397 ~safe_VkPipelineInfoKHR(); 3398 void initialize(const VkPipelineInfoKHR* in_struct); 3399 void initialize(const safe_VkPipelineInfoKHR* src); ptrsafe_VkPipelineInfoKHR3400 VkPipelineInfoKHR *ptr() { return reinterpret_cast<VkPipelineInfoKHR *>(this); } ptrsafe_VkPipelineInfoKHR3401 VkPipelineInfoKHR const *ptr() const { return reinterpret_cast<VkPipelineInfoKHR const *>(this); } 3402 }; 3403 3404 struct safe_VkPipelineExecutablePropertiesKHR { 3405 VkStructureType sType; 3406 void* pNext; 3407 VkShaderStageFlags stages; 3408 char name[VK_MAX_DESCRIPTION_SIZE]; 3409 char description[VK_MAX_DESCRIPTION_SIZE]; 3410 uint32_t subgroupSize; 3411 safe_VkPipelineExecutablePropertiesKHR(const VkPipelineExecutablePropertiesKHR* in_struct); 3412 safe_VkPipelineExecutablePropertiesKHR(const safe_VkPipelineExecutablePropertiesKHR& src); 3413 safe_VkPipelineExecutablePropertiesKHR& operator=(const safe_VkPipelineExecutablePropertiesKHR& src); 3414 safe_VkPipelineExecutablePropertiesKHR(); 3415 ~safe_VkPipelineExecutablePropertiesKHR(); 3416 void initialize(const VkPipelineExecutablePropertiesKHR* in_struct); 3417 void initialize(const safe_VkPipelineExecutablePropertiesKHR* src); ptrsafe_VkPipelineExecutablePropertiesKHR3418 VkPipelineExecutablePropertiesKHR *ptr() { return reinterpret_cast<VkPipelineExecutablePropertiesKHR *>(this); } ptrsafe_VkPipelineExecutablePropertiesKHR3419 VkPipelineExecutablePropertiesKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutablePropertiesKHR const *>(this); } 3420 }; 3421 3422 struct safe_VkPipelineExecutableInfoKHR { 3423 VkStructureType sType; 3424 const void* pNext; 3425 VkPipeline pipeline; 3426 uint32_t executableIndex; 3427 safe_VkPipelineExecutableInfoKHR(const VkPipelineExecutableInfoKHR* in_struct); 3428 safe_VkPipelineExecutableInfoKHR(const safe_VkPipelineExecutableInfoKHR& src); 3429 safe_VkPipelineExecutableInfoKHR& operator=(const safe_VkPipelineExecutableInfoKHR& src); 3430 safe_VkPipelineExecutableInfoKHR(); 3431 ~safe_VkPipelineExecutableInfoKHR(); 3432 void initialize(const VkPipelineExecutableInfoKHR* in_struct); 3433 void initialize(const safe_VkPipelineExecutableInfoKHR* src); ptrsafe_VkPipelineExecutableInfoKHR3434 VkPipelineExecutableInfoKHR *ptr() { return reinterpret_cast<VkPipelineExecutableInfoKHR *>(this); } ptrsafe_VkPipelineExecutableInfoKHR3435 VkPipelineExecutableInfoKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutableInfoKHR const *>(this); } 3436 }; 3437 3438 struct safe_VkPipelineExecutableStatisticKHR { 3439 VkStructureType sType; 3440 void* pNext; 3441 char name[VK_MAX_DESCRIPTION_SIZE]; 3442 char description[VK_MAX_DESCRIPTION_SIZE]; 3443 VkPipelineExecutableStatisticFormatKHR format; 3444 VkPipelineExecutableStatisticValueKHR value; 3445 safe_VkPipelineExecutableStatisticKHR(const VkPipelineExecutableStatisticKHR* in_struct); 3446 safe_VkPipelineExecutableStatisticKHR(const safe_VkPipelineExecutableStatisticKHR& src); 3447 safe_VkPipelineExecutableStatisticKHR& operator=(const safe_VkPipelineExecutableStatisticKHR& src); 3448 safe_VkPipelineExecutableStatisticKHR(); 3449 ~safe_VkPipelineExecutableStatisticKHR(); 3450 void initialize(const VkPipelineExecutableStatisticKHR* in_struct); 3451 void initialize(const safe_VkPipelineExecutableStatisticKHR* src); ptrsafe_VkPipelineExecutableStatisticKHR3452 VkPipelineExecutableStatisticKHR *ptr() { return reinterpret_cast<VkPipelineExecutableStatisticKHR *>(this); } ptrsafe_VkPipelineExecutableStatisticKHR3453 VkPipelineExecutableStatisticKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutableStatisticKHR const *>(this); } 3454 }; 3455 3456 struct safe_VkPipelineExecutableInternalRepresentationKHR { 3457 VkStructureType sType; 3458 void* pNext; 3459 char name[VK_MAX_DESCRIPTION_SIZE]; 3460 char description[VK_MAX_DESCRIPTION_SIZE]; 3461 VkBool32 isText; 3462 size_t dataSize; 3463 void* pData; 3464 safe_VkPipelineExecutableInternalRepresentationKHR(const VkPipelineExecutableInternalRepresentationKHR* in_struct); 3465 safe_VkPipelineExecutableInternalRepresentationKHR(const safe_VkPipelineExecutableInternalRepresentationKHR& src); 3466 safe_VkPipelineExecutableInternalRepresentationKHR& operator=(const safe_VkPipelineExecutableInternalRepresentationKHR& src); 3467 safe_VkPipelineExecutableInternalRepresentationKHR(); 3468 ~safe_VkPipelineExecutableInternalRepresentationKHR(); 3469 void initialize(const VkPipelineExecutableInternalRepresentationKHR* in_struct); 3470 void initialize(const safe_VkPipelineExecutableInternalRepresentationKHR* src); ptrsafe_VkPipelineExecutableInternalRepresentationKHR3471 VkPipelineExecutableInternalRepresentationKHR *ptr() { return reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>(this); } ptrsafe_VkPipelineExecutableInternalRepresentationKHR3472 VkPipelineExecutableInternalRepresentationKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR const *>(this); } 3473 }; 3474 3475 struct safe_VkDebugReportCallbackCreateInfoEXT { 3476 VkStructureType sType; 3477 const void* pNext; 3478 VkDebugReportFlagsEXT flags; 3479 PFN_vkDebugReportCallbackEXT pfnCallback; 3480 void* pUserData; 3481 safe_VkDebugReportCallbackCreateInfoEXT(const VkDebugReportCallbackCreateInfoEXT* in_struct); 3482 safe_VkDebugReportCallbackCreateInfoEXT(const safe_VkDebugReportCallbackCreateInfoEXT& src); 3483 safe_VkDebugReportCallbackCreateInfoEXT& operator=(const safe_VkDebugReportCallbackCreateInfoEXT& src); 3484 safe_VkDebugReportCallbackCreateInfoEXT(); 3485 ~safe_VkDebugReportCallbackCreateInfoEXT(); 3486 void initialize(const VkDebugReportCallbackCreateInfoEXT* in_struct); 3487 void initialize(const safe_VkDebugReportCallbackCreateInfoEXT* src); ptrsafe_VkDebugReportCallbackCreateInfoEXT3488 VkDebugReportCallbackCreateInfoEXT *ptr() { return reinterpret_cast<VkDebugReportCallbackCreateInfoEXT *>(this); } ptrsafe_VkDebugReportCallbackCreateInfoEXT3489 VkDebugReportCallbackCreateInfoEXT const *ptr() const { return reinterpret_cast<VkDebugReportCallbackCreateInfoEXT const *>(this); } 3490 }; 3491 3492 struct safe_VkPipelineRasterizationStateRasterizationOrderAMD { 3493 VkStructureType sType; 3494 const void* pNext; 3495 VkRasterizationOrderAMD rasterizationOrder; 3496 safe_VkPipelineRasterizationStateRasterizationOrderAMD(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct); 3497 safe_VkPipelineRasterizationStateRasterizationOrderAMD(const safe_VkPipelineRasterizationStateRasterizationOrderAMD& src); 3498 safe_VkPipelineRasterizationStateRasterizationOrderAMD& operator=(const safe_VkPipelineRasterizationStateRasterizationOrderAMD& src); 3499 safe_VkPipelineRasterizationStateRasterizationOrderAMD(); 3500 ~safe_VkPipelineRasterizationStateRasterizationOrderAMD(); 3501 void initialize(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct); 3502 void initialize(const safe_VkPipelineRasterizationStateRasterizationOrderAMD* src); ptrsafe_VkPipelineRasterizationStateRasterizationOrderAMD3503 VkPipelineRasterizationStateRasterizationOrderAMD *ptr() { return reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD *>(this); } ptrsafe_VkPipelineRasterizationStateRasterizationOrderAMD3504 VkPipelineRasterizationStateRasterizationOrderAMD const *ptr() const { return reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD const *>(this); } 3505 }; 3506 3507 struct safe_VkDebugMarkerObjectNameInfoEXT { 3508 VkStructureType sType; 3509 const void* pNext; 3510 VkDebugReportObjectTypeEXT objectType; 3511 uint64_t object; 3512 const char* pObjectName; 3513 safe_VkDebugMarkerObjectNameInfoEXT(const VkDebugMarkerObjectNameInfoEXT* in_struct); 3514 safe_VkDebugMarkerObjectNameInfoEXT(const safe_VkDebugMarkerObjectNameInfoEXT& src); 3515 safe_VkDebugMarkerObjectNameInfoEXT& operator=(const safe_VkDebugMarkerObjectNameInfoEXT& src); 3516 safe_VkDebugMarkerObjectNameInfoEXT(); 3517 ~safe_VkDebugMarkerObjectNameInfoEXT(); 3518 void initialize(const VkDebugMarkerObjectNameInfoEXT* in_struct); 3519 void initialize(const safe_VkDebugMarkerObjectNameInfoEXT* src); ptrsafe_VkDebugMarkerObjectNameInfoEXT3520 VkDebugMarkerObjectNameInfoEXT *ptr() { return reinterpret_cast<VkDebugMarkerObjectNameInfoEXT *>(this); } ptrsafe_VkDebugMarkerObjectNameInfoEXT3521 VkDebugMarkerObjectNameInfoEXT const *ptr() const { return reinterpret_cast<VkDebugMarkerObjectNameInfoEXT const *>(this); } 3522 }; 3523 3524 struct safe_VkDebugMarkerObjectTagInfoEXT { 3525 VkStructureType sType; 3526 const void* pNext; 3527 VkDebugReportObjectTypeEXT objectType; 3528 uint64_t object; 3529 uint64_t tagName; 3530 size_t tagSize; 3531 const void* pTag; 3532 safe_VkDebugMarkerObjectTagInfoEXT(const VkDebugMarkerObjectTagInfoEXT* in_struct); 3533 safe_VkDebugMarkerObjectTagInfoEXT(const safe_VkDebugMarkerObjectTagInfoEXT& src); 3534 safe_VkDebugMarkerObjectTagInfoEXT& operator=(const safe_VkDebugMarkerObjectTagInfoEXT& src); 3535 safe_VkDebugMarkerObjectTagInfoEXT(); 3536 ~safe_VkDebugMarkerObjectTagInfoEXT(); 3537 void initialize(const VkDebugMarkerObjectTagInfoEXT* in_struct); 3538 void initialize(const safe_VkDebugMarkerObjectTagInfoEXT* src); ptrsafe_VkDebugMarkerObjectTagInfoEXT3539 VkDebugMarkerObjectTagInfoEXT *ptr() { return reinterpret_cast<VkDebugMarkerObjectTagInfoEXT *>(this); } ptrsafe_VkDebugMarkerObjectTagInfoEXT3540 VkDebugMarkerObjectTagInfoEXT const *ptr() const { return reinterpret_cast<VkDebugMarkerObjectTagInfoEXT const *>(this); } 3541 }; 3542 3543 struct safe_VkDebugMarkerMarkerInfoEXT { 3544 VkStructureType sType; 3545 const void* pNext; 3546 const char* pMarkerName; 3547 float color[4]; 3548 safe_VkDebugMarkerMarkerInfoEXT(const VkDebugMarkerMarkerInfoEXT* in_struct); 3549 safe_VkDebugMarkerMarkerInfoEXT(const safe_VkDebugMarkerMarkerInfoEXT& src); 3550 safe_VkDebugMarkerMarkerInfoEXT& operator=(const safe_VkDebugMarkerMarkerInfoEXT& src); 3551 safe_VkDebugMarkerMarkerInfoEXT(); 3552 ~safe_VkDebugMarkerMarkerInfoEXT(); 3553 void initialize(const VkDebugMarkerMarkerInfoEXT* in_struct); 3554 void initialize(const safe_VkDebugMarkerMarkerInfoEXT* src); ptrsafe_VkDebugMarkerMarkerInfoEXT3555 VkDebugMarkerMarkerInfoEXT *ptr() { return reinterpret_cast<VkDebugMarkerMarkerInfoEXT *>(this); } ptrsafe_VkDebugMarkerMarkerInfoEXT3556 VkDebugMarkerMarkerInfoEXT const *ptr() const { return reinterpret_cast<VkDebugMarkerMarkerInfoEXT const *>(this); } 3557 }; 3558 3559 struct safe_VkDedicatedAllocationImageCreateInfoNV { 3560 VkStructureType sType; 3561 const void* pNext; 3562 VkBool32 dedicatedAllocation; 3563 safe_VkDedicatedAllocationImageCreateInfoNV(const VkDedicatedAllocationImageCreateInfoNV* in_struct); 3564 safe_VkDedicatedAllocationImageCreateInfoNV(const safe_VkDedicatedAllocationImageCreateInfoNV& src); 3565 safe_VkDedicatedAllocationImageCreateInfoNV& operator=(const safe_VkDedicatedAllocationImageCreateInfoNV& src); 3566 safe_VkDedicatedAllocationImageCreateInfoNV(); 3567 ~safe_VkDedicatedAllocationImageCreateInfoNV(); 3568 void initialize(const VkDedicatedAllocationImageCreateInfoNV* in_struct); 3569 void initialize(const safe_VkDedicatedAllocationImageCreateInfoNV* src); ptrsafe_VkDedicatedAllocationImageCreateInfoNV3570 VkDedicatedAllocationImageCreateInfoNV *ptr() { return reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV *>(this); } ptrsafe_VkDedicatedAllocationImageCreateInfoNV3571 VkDedicatedAllocationImageCreateInfoNV const *ptr() const { return reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV const *>(this); } 3572 }; 3573 3574 struct safe_VkDedicatedAllocationBufferCreateInfoNV { 3575 VkStructureType sType; 3576 const void* pNext; 3577 VkBool32 dedicatedAllocation; 3578 safe_VkDedicatedAllocationBufferCreateInfoNV(const VkDedicatedAllocationBufferCreateInfoNV* in_struct); 3579 safe_VkDedicatedAllocationBufferCreateInfoNV(const safe_VkDedicatedAllocationBufferCreateInfoNV& src); 3580 safe_VkDedicatedAllocationBufferCreateInfoNV& operator=(const safe_VkDedicatedAllocationBufferCreateInfoNV& src); 3581 safe_VkDedicatedAllocationBufferCreateInfoNV(); 3582 ~safe_VkDedicatedAllocationBufferCreateInfoNV(); 3583 void initialize(const VkDedicatedAllocationBufferCreateInfoNV* in_struct); 3584 void initialize(const safe_VkDedicatedAllocationBufferCreateInfoNV* src); ptrsafe_VkDedicatedAllocationBufferCreateInfoNV3585 VkDedicatedAllocationBufferCreateInfoNV *ptr() { return reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV *>(this); } ptrsafe_VkDedicatedAllocationBufferCreateInfoNV3586 VkDedicatedAllocationBufferCreateInfoNV const *ptr() const { return reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV const *>(this); } 3587 }; 3588 3589 struct safe_VkDedicatedAllocationMemoryAllocateInfoNV { 3590 VkStructureType sType; 3591 const void* pNext; 3592 VkImage image; 3593 VkBuffer buffer; 3594 safe_VkDedicatedAllocationMemoryAllocateInfoNV(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct); 3595 safe_VkDedicatedAllocationMemoryAllocateInfoNV(const safe_VkDedicatedAllocationMemoryAllocateInfoNV& src); 3596 safe_VkDedicatedAllocationMemoryAllocateInfoNV& operator=(const safe_VkDedicatedAllocationMemoryAllocateInfoNV& src); 3597 safe_VkDedicatedAllocationMemoryAllocateInfoNV(); 3598 ~safe_VkDedicatedAllocationMemoryAllocateInfoNV(); 3599 void initialize(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct); 3600 void initialize(const safe_VkDedicatedAllocationMemoryAllocateInfoNV* src); ptrsafe_VkDedicatedAllocationMemoryAllocateInfoNV3601 VkDedicatedAllocationMemoryAllocateInfoNV *ptr() { return reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV *>(this); } ptrsafe_VkDedicatedAllocationMemoryAllocateInfoNV3602 VkDedicatedAllocationMemoryAllocateInfoNV const *ptr() const { return reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV const *>(this); } 3603 }; 3604 3605 struct safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT { 3606 VkStructureType sType; 3607 void* pNext; 3608 VkBool32 transformFeedback; 3609 VkBool32 geometryStreams; 3610 safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct); 3611 safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& src); 3612 safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& operator=(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& src); 3613 safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(); 3614 ~safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(); 3615 void initialize(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct); 3616 void initialize(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT* src); ptrsafe_VkPhysicalDeviceTransformFeedbackFeaturesEXT3617 VkPhysicalDeviceTransformFeedbackFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT *>(this); } ptrsafe_VkPhysicalDeviceTransformFeedbackFeaturesEXT3618 VkPhysicalDeviceTransformFeedbackFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT const *>(this); } 3619 }; 3620 3621 struct safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT { 3622 VkStructureType sType; 3623 void* pNext; 3624 uint32_t maxTransformFeedbackStreams; 3625 uint32_t maxTransformFeedbackBuffers; 3626 VkDeviceSize maxTransformFeedbackBufferSize; 3627 uint32_t maxTransformFeedbackStreamDataSize; 3628 uint32_t maxTransformFeedbackBufferDataSize; 3629 uint32_t maxTransformFeedbackBufferDataStride; 3630 VkBool32 transformFeedbackQueries; 3631 VkBool32 transformFeedbackStreamsLinesTriangles; 3632 VkBool32 transformFeedbackRasterizationStreamSelect; 3633 VkBool32 transformFeedbackDraw; 3634 safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct); 3635 safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& src); 3636 safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& operator=(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& src); 3637 safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(); 3638 ~safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(); 3639 void initialize(const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct); 3640 void initialize(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT* src); ptrsafe_VkPhysicalDeviceTransformFeedbackPropertiesEXT3641 VkPhysicalDeviceTransformFeedbackPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT *>(this); } ptrsafe_VkPhysicalDeviceTransformFeedbackPropertiesEXT3642 VkPhysicalDeviceTransformFeedbackPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT const *>(this); } 3643 }; 3644 3645 struct safe_VkPipelineRasterizationStateStreamCreateInfoEXT { 3646 VkStructureType sType; 3647 const void* pNext; 3648 VkPipelineRasterizationStateStreamCreateFlagsEXT flags; 3649 uint32_t rasterizationStream; 3650 safe_VkPipelineRasterizationStateStreamCreateInfoEXT(const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct); 3651 safe_VkPipelineRasterizationStateStreamCreateInfoEXT(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& src); 3652 safe_VkPipelineRasterizationStateStreamCreateInfoEXT& operator=(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& src); 3653 safe_VkPipelineRasterizationStateStreamCreateInfoEXT(); 3654 ~safe_VkPipelineRasterizationStateStreamCreateInfoEXT(); 3655 void initialize(const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct); 3656 void initialize(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT* src); ptrsafe_VkPipelineRasterizationStateStreamCreateInfoEXT3657 VkPipelineRasterizationStateStreamCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT *>(this); } ptrsafe_VkPipelineRasterizationStateStreamCreateInfoEXT3658 VkPipelineRasterizationStateStreamCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT const *>(this); } 3659 }; 3660 3661 struct safe_VkImageViewHandleInfoNVX { 3662 VkStructureType sType; 3663 const void* pNext; 3664 VkImageView imageView; 3665 VkDescriptorType descriptorType; 3666 VkSampler sampler; 3667 safe_VkImageViewHandleInfoNVX(const VkImageViewHandleInfoNVX* in_struct); 3668 safe_VkImageViewHandleInfoNVX(const safe_VkImageViewHandleInfoNVX& src); 3669 safe_VkImageViewHandleInfoNVX& operator=(const safe_VkImageViewHandleInfoNVX& src); 3670 safe_VkImageViewHandleInfoNVX(); 3671 ~safe_VkImageViewHandleInfoNVX(); 3672 void initialize(const VkImageViewHandleInfoNVX* in_struct); 3673 void initialize(const safe_VkImageViewHandleInfoNVX* src); ptrsafe_VkImageViewHandleInfoNVX3674 VkImageViewHandleInfoNVX *ptr() { return reinterpret_cast<VkImageViewHandleInfoNVX *>(this); } ptrsafe_VkImageViewHandleInfoNVX3675 VkImageViewHandleInfoNVX const *ptr() const { return reinterpret_cast<VkImageViewHandleInfoNVX const *>(this); } 3676 }; 3677 3678 struct safe_VkTextureLODGatherFormatPropertiesAMD { 3679 VkStructureType sType; 3680 void* pNext; 3681 VkBool32 supportsTextureGatherLODBiasAMD; 3682 safe_VkTextureLODGatherFormatPropertiesAMD(const VkTextureLODGatherFormatPropertiesAMD* in_struct); 3683 safe_VkTextureLODGatherFormatPropertiesAMD(const safe_VkTextureLODGatherFormatPropertiesAMD& src); 3684 safe_VkTextureLODGatherFormatPropertiesAMD& operator=(const safe_VkTextureLODGatherFormatPropertiesAMD& src); 3685 safe_VkTextureLODGatherFormatPropertiesAMD(); 3686 ~safe_VkTextureLODGatherFormatPropertiesAMD(); 3687 void initialize(const VkTextureLODGatherFormatPropertiesAMD* in_struct); 3688 void initialize(const safe_VkTextureLODGatherFormatPropertiesAMD* src); ptrsafe_VkTextureLODGatherFormatPropertiesAMD3689 VkTextureLODGatherFormatPropertiesAMD *ptr() { return reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD *>(this); } ptrsafe_VkTextureLODGatherFormatPropertiesAMD3690 VkTextureLODGatherFormatPropertiesAMD const *ptr() const { return reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD const *>(this); } 3691 }; 3692 3693 #ifdef VK_USE_PLATFORM_GGP 3694 struct safe_VkStreamDescriptorSurfaceCreateInfoGGP { 3695 VkStructureType sType; 3696 const void* pNext; 3697 VkStreamDescriptorSurfaceCreateFlagsGGP flags; 3698 GgpStreamDescriptor streamDescriptor; 3699 safe_VkStreamDescriptorSurfaceCreateInfoGGP(const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct); 3700 safe_VkStreamDescriptorSurfaceCreateInfoGGP(const safe_VkStreamDescriptorSurfaceCreateInfoGGP& src); 3701 safe_VkStreamDescriptorSurfaceCreateInfoGGP& operator=(const safe_VkStreamDescriptorSurfaceCreateInfoGGP& src); 3702 safe_VkStreamDescriptorSurfaceCreateInfoGGP(); 3703 ~safe_VkStreamDescriptorSurfaceCreateInfoGGP(); 3704 void initialize(const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct); 3705 void initialize(const safe_VkStreamDescriptorSurfaceCreateInfoGGP* src); ptrsafe_VkStreamDescriptorSurfaceCreateInfoGGP3706 VkStreamDescriptorSurfaceCreateInfoGGP *ptr() { return reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP *>(this); } ptrsafe_VkStreamDescriptorSurfaceCreateInfoGGP3707 VkStreamDescriptorSurfaceCreateInfoGGP const *ptr() const { return reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP const *>(this); } 3708 }; 3709 #endif // VK_USE_PLATFORM_GGP 3710 3711 struct safe_VkPhysicalDeviceCornerSampledImageFeaturesNV { 3712 VkStructureType sType; 3713 void* pNext; 3714 VkBool32 cornerSampledImage; 3715 safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct); 3716 safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& src); 3717 safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& operator=(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& src); 3718 safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(); 3719 ~safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(); 3720 void initialize(const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct); 3721 void initialize(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV* src); ptrsafe_VkPhysicalDeviceCornerSampledImageFeaturesNV3722 VkPhysicalDeviceCornerSampledImageFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV *>(this); } ptrsafe_VkPhysicalDeviceCornerSampledImageFeaturesNV3723 VkPhysicalDeviceCornerSampledImageFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV const *>(this); } 3724 }; 3725 3726 struct safe_VkExternalMemoryImageCreateInfoNV { 3727 VkStructureType sType; 3728 const void* pNext; 3729 VkExternalMemoryHandleTypeFlagsNV handleTypes; 3730 safe_VkExternalMemoryImageCreateInfoNV(const VkExternalMemoryImageCreateInfoNV* in_struct); 3731 safe_VkExternalMemoryImageCreateInfoNV(const safe_VkExternalMemoryImageCreateInfoNV& src); 3732 safe_VkExternalMemoryImageCreateInfoNV& operator=(const safe_VkExternalMemoryImageCreateInfoNV& src); 3733 safe_VkExternalMemoryImageCreateInfoNV(); 3734 ~safe_VkExternalMemoryImageCreateInfoNV(); 3735 void initialize(const VkExternalMemoryImageCreateInfoNV* in_struct); 3736 void initialize(const safe_VkExternalMemoryImageCreateInfoNV* src); ptrsafe_VkExternalMemoryImageCreateInfoNV3737 VkExternalMemoryImageCreateInfoNV *ptr() { return reinterpret_cast<VkExternalMemoryImageCreateInfoNV *>(this); } ptrsafe_VkExternalMemoryImageCreateInfoNV3738 VkExternalMemoryImageCreateInfoNV const *ptr() const { return reinterpret_cast<VkExternalMemoryImageCreateInfoNV const *>(this); } 3739 }; 3740 3741 struct safe_VkExportMemoryAllocateInfoNV { 3742 VkStructureType sType; 3743 const void* pNext; 3744 VkExternalMemoryHandleTypeFlagsNV handleTypes; 3745 safe_VkExportMemoryAllocateInfoNV(const VkExportMemoryAllocateInfoNV* in_struct); 3746 safe_VkExportMemoryAllocateInfoNV(const safe_VkExportMemoryAllocateInfoNV& src); 3747 safe_VkExportMemoryAllocateInfoNV& operator=(const safe_VkExportMemoryAllocateInfoNV& src); 3748 safe_VkExportMemoryAllocateInfoNV(); 3749 ~safe_VkExportMemoryAllocateInfoNV(); 3750 void initialize(const VkExportMemoryAllocateInfoNV* in_struct); 3751 void initialize(const safe_VkExportMemoryAllocateInfoNV* src); ptrsafe_VkExportMemoryAllocateInfoNV3752 VkExportMemoryAllocateInfoNV *ptr() { return reinterpret_cast<VkExportMemoryAllocateInfoNV *>(this); } ptrsafe_VkExportMemoryAllocateInfoNV3753 VkExportMemoryAllocateInfoNV const *ptr() const { return reinterpret_cast<VkExportMemoryAllocateInfoNV const *>(this); } 3754 }; 3755 3756 #ifdef VK_USE_PLATFORM_WIN32_KHR 3757 struct safe_VkImportMemoryWin32HandleInfoNV { 3758 VkStructureType sType; 3759 const void* pNext; 3760 VkExternalMemoryHandleTypeFlagsNV handleType; 3761 HANDLE handle; 3762 safe_VkImportMemoryWin32HandleInfoNV(const VkImportMemoryWin32HandleInfoNV* in_struct); 3763 safe_VkImportMemoryWin32HandleInfoNV(const safe_VkImportMemoryWin32HandleInfoNV& src); 3764 safe_VkImportMemoryWin32HandleInfoNV& operator=(const safe_VkImportMemoryWin32HandleInfoNV& src); 3765 safe_VkImportMemoryWin32HandleInfoNV(); 3766 ~safe_VkImportMemoryWin32HandleInfoNV(); 3767 void initialize(const VkImportMemoryWin32HandleInfoNV* in_struct); 3768 void initialize(const safe_VkImportMemoryWin32HandleInfoNV* src); ptrsafe_VkImportMemoryWin32HandleInfoNV3769 VkImportMemoryWin32HandleInfoNV *ptr() { return reinterpret_cast<VkImportMemoryWin32HandleInfoNV *>(this); } ptrsafe_VkImportMemoryWin32HandleInfoNV3770 VkImportMemoryWin32HandleInfoNV const *ptr() const { return reinterpret_cast<VkImportMemoryWin32HandleInfoNV const *>(this); } 3771 }; 3772 #endif // VK_USE_PLATFORM_WIN32_KHR 3773 3774 #ifdef VK_USE_PLATFORM_WIN32_KHR 3775 struct safe_VkExportMemoryWin32HandleInfoNV { 3776 VkStructureType sType; 3777 const void* pNext; 3778 const SECURITY_ATTRIBUTES* pAttributes; 3779 DWORD dwAccess; 3780 safe_VkExportMemoryWin32HandleInfoNV(const VkExportMemoryWin32HandleInfoNV* in_struct); 3781 safe_VkExportMemoryWin32HandleInfoNV(const safe_VkExportMemoryWin32HandleInfoNV& src); 3782 safe_VkExportMemoryWin32HandleInfoNV& operator=(const safe_VkExportMemoryWin32HandleInfoNV& src); 3783 safe_VkExportMemoryWin32HandleInfoNV(); 3784 ~safe_VkExportMemoryWin32HandleInfoNV(); 3785 void initialize(const VkExportMemoryWin32HandleInfoNV* in_struct); 3786 void initialize(const safe_VkExportMemoryWin32HandleInfoNV* src); ptrsafe_VkExportMemoryWin32HandleInfoNV3787 VkExportMemoryWin32HandleInfoNV *ptr() { return reinterpret_cast<VkExportMemoryWin32HandleInfoNV *>(this); } ptrsafe_VkExportMemoryWin32HandleInfoNV3788 VkExportMemoryWin32HandleInfoNV const *ptr() const { return reinterpret_cast<VkExportMemoryWin32HandleInfoNV const *>(this); } 3789 }; 3790 #endif // VK_USE_PLATFORM_WIN32_KHR 3791 3792 #ifdef VK_USE_PLATFORM_WIN32_KHR 3793 struct safe_VkWin32KeyedMutexAcquireReleaseInfoNV { 3794 VkStructureType sType; 3795 const void* pNext; 3796 uint32_t acquireCount; 3797 VkDeviceMemory* pAcquireSyncs; 3798 const uint64_t* pAcquireKeys; 3799 const uint32_t* pAcquireTimeoutMilliseconds; 3800 uint32_t releaseCount; 3801 VkDeviceMemory* pReleaseSyncs; 3802 const uint64_t* pReleaseKeys; 3803 safe_VkWin32KeyedMutexAcquireReleaseInfoNV(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct); 3804 safe_VkWin32KeyedMutexAcquireReleaseInfoNV(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& src); 3805 safe_VkWin32KeyedMutexAcquireReleaseInfoNV& operator=(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& src); 3806 safe_VkWin32KeyedMutexAcquireReleaseInfoNV(); 3807 ~safe_VkWin32KeyedMutexAcquireReleaseInfoNV(); 3808 void initialize(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct); 3809 void initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV* src); ptrsafe_VkWin32KeyedMutexAcquireReleaseInfoNV3810 VkWin32KeyedMutexAcquireReleaseInfoNV *ptr() { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV *>(this); } ptrsafe_VkWin32KeyedMutexAcquireReleaseInfoNV3811 VkWin32KeyedMutexAcquireReleaseInfoNV const *ptr() const { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV const *>(this); } 3812 }; 3813 #endif // VK_USE_PLATFORM_WIN32_KHR 3814 3815 struct safe_VkValidationFlagsEXT { 3816 VkStructureType sType; 3817 const void* pNext; 3818 uint32_t disabledValidationCheckCount; 3819 const VkValidationCheckEXT* pDisabledValidationChecks; 3820 safe_VkValidationFlagsEXT(const VkValidationFlagsEXT* in_struct); 3821 safe_VkValidationFlagsEXT(const safe_VkValidationFlagsEXT& src); 3822 safe_VkValidationFlagsEXT& operator=(const safe_VkValidationFlagsEXT& src); 3823 safe_VkValidationFlagsEXT(); 3824 ~safe_VkValidationFlagsEXT(); 3825 void initialize(const VkValidationFlagsEXT* in_struct); 3826 void initialize(const safe_VkValidationFlagsEXT* src); ptrsafe_VkValidationFlagsEXT3827 VkValidationFlagsEXT *ptr() { return reinterpret_cast<VkValidationFlagsEXT *>(this); } ptrsafe_VkValidationFlagsEXT3828 VkValidationFlagsEXT const *ptr() const { return reinterpret_cast<VkValidationFlagsEXT const *>(this); } 3829 }; 3830 3831 #ifdef VK_USE_PLATFORM_VI_NN 3832 struct safe_VkViSurfaceCreateInfoNN { 3833 VkStructureType sType; 3834 const void* pNext; 3835 VkViSurfaceCreateFlagsNN flags; 3836 void* window; 3837 safe_VkViSurfaceCreateInfoNN(const VkViSurfaceCreateInfoNN* in_struct); 3838 safe_VkViSurfaceCreateInfoNN(const safe_VkViSurfaceCreateInfoNN& src); 3839 safe_VkViSurfaceCreateInfoNN& operator=(const safe_VkViSurfaceCreateInfoNN& src); 3840 safe_VkViSurfaceCreateInfoNN(); 3841 ~safe_VkViSurfaceCreateInfoNN(); 3842 void initialize(const VkViSurfaceCreateInfoNN* in_struct); 3843 void initialize(const safe_VkViSurfaceCreateInfoNN* src); ptrsafe_VkViSurfaceCreateInfoNN3844 VkViSurfaceCreateInfoNN *ptr() { return reinterpret_cast<VkViSurfaceCreateInfoNN *>(this); } ptrsafe_VkViSurfaceCreateInfoNN3845 VkViSurfaceCreateInfoNN const *ptr() const { return reinterpret_cast<VkViSurfaceCreateInfoNN const *>(this); } 3846 }; 3847 #endif // VK_USE_PLATFORM_VI_NN 3848 3849 struct safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT { 3850 VkStructureType sType; 3851 const void* pNext; 3852 VkBool32 textureCompressionASTC_HDR; 3853 safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* in_struct); 3854 safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& src); 3855 safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& operator=(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& src); 3856 safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(); 3857 ~safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(); 3858 void initialize(const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* in_struct); 3859 void initialize(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* src); ptrsafe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT3860 VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *>(this); } ptrsafe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT3861 VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const *>(this); } 3862 }; 3863 3864 struct safe_VkImageViewASTCDecodeModeEXT { 3865 VkStructureType sType; 3866 const void* pNext; 3867 VkFormat decodeMode; 3868 safe_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT* in_struct); 3869 safe_VkImageViewASTCDecodeModeEXT(const safe_VkImageViewASTCDecodeModeEXT& src); 3870 safe_VkImageViewASTCDecodeModeEXT& operator=(const safe_VkImageViewASTCDecodeModeEXT& src); 3871 safe_VkImageViewASTCDecodeModeEXT(); 3872 ~safe_VkImageViewASTCDecodeModeEXT(); 3873 void initialize(const VkImageViewASTCDecodeModeEXT* in_struct); 3874 void initialize(const safe_VkImageViewASTCDecodeModeEXT* src); ptrsafe_VkImageViewASTCDecodeModeEXT3875 VkImageViewASTCDecodeModeEXT *ptr() { return reinterpret_cast<VkImageViewASTCDecodeModeEXT *>(this); } ptrsafe_VkImageViewASTCDecodeModeEXT3876 VkImageViewASTCDecodeModeEXT const *ptr() const { return reinterpret_cast<VkImageViewASTCDecodeModeEXT const *>(this); } 3877 }; 3878 3879 struct safe_VkPhysicalDeviceASTCDecodeFeaturesEXT { 3880 VkStructureType sType; 3881 void* pNext; 3882 VkBool32 decodeModeSharedExponent; 3883 safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct); 3884 safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& src); 3885 safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& operator=(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& src); 3886 safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(); 3887 ~safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(); 3888 void initialize(const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct); 3889 void initialize(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT* src); ptrsafe_VkPhysicalDeviceASTCDecodeFeaturesEXT3890 VkPhysicalDeviceASTCDecodeFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT *>(this); } ptrsafe_VkPhysicalDeviceASTCDecodeFeaturesEXT3891 VkPhysicalDeviceASTCDecodeFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT const *>(this); } 3892 }; 3893 3894 struct safe_VkConditionalRenderingBeginInfoEXT { 3895 VkStructureType sType; 3896 const void* pNext; 3897 VkBuffer buffer; 3898 VkDeviceSize offset; 3899 VkConditionalRenderingFlagsEXT flags; 3900 safe_VkConditionalRenderingBeginInfoEXT(const VkConditionalRenderingBeginInfoEXT* in_struct); 3901 safe_VkConditionalRenderingBeginInfoEXT(const safe_VkConditionalRenderingBeginInfoEXT& src); 3902 safe_VkConditionalRenderingBeginInfoEXT& operator=(const safe_VkConditionalRenderingBeginInfoEXT& src); 3903 safe_VkConditionalRenderingBeginInfoEXT(); 3904 ~safe_VkConditionalRenderingBeginInfoEXT(); 3905 void initialize(const VkConditionalRenderingBeginInfoEXT* in_struct); 3906 void initialize(const safe_VkConditionalRenderingBeginInfoEXT* src); ptrsafe_VkConditionalRenderingBeginInfoEXT3907 VkConditionalRenderingBeginInfoEXT *ptr() { return reinterpret_cast<VkConditionalRenderingBeginInfoEXT *>(this); } ptrsafe_VkConditionalRenderingBeginInfoEXT3908 VkConditionalRenderingBeginInfoEXT const *ptr() const { return reinterpret_cast<VkConditionalRenderingBeginInfoEXT const *>(this); } 3909 }; 3910 3911 struct safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT { 3912 VkStructureType sType; 3913 void* pNext; 3914 VkBool32 conditionalRendering; 3915 VkBool32 inheritedConditionalRendering; 3916 safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct); 3917 safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& src); 3918 safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& operator=(const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& src); 3919 safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(); 3920 ~safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(); 3921 void initialize(const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct); 3922 void initialize(const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT* src); ptrsafe_VkPhysicalDeviceConditionalRenderingFeaturesEXT3923 VkPhysicalDeviceConditionalRenderingFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(this); } ptrsafe_VkPhysicalDeviceConditionalRenderingFeaturesEXT3924 VkPhysicalDeviceConditionalRenderingFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT const *>(this); } 3925 }; 3926 3927 struct safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT { 3928 VkStructureType sType; 3929 const void* pNext; 3930 VkBool32 conditionalRenderingEnable; 3931 safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct); 3932 safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& src); 3933 safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& operator=(const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& src); 3934 safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(); 3935 ~safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(); 3936 void initialize(const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct); 3937 void initialize(const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT* src); ptrsafe_VkCommandBufferInheritanceConditionalRenderingInfoEXT3938 VkCommandBufferInheritanceConditionalRenderingInfoEXT *ptr() { return reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT *>(this); } ptrsafe_VkCommandBufferInheritanceConditionalRenderingInfoEXT3939 VkCommandBufferInheritanceConditionalRenderingInfoEXT const *ptr() const { return reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT const *>(this); } 3940 }; 3941 3942 struct safe_VkDeviceGeneratedCommandsFeaturesNVX { 3943 VkStructureType sType; 3944 const void* pNext; 3945 VkBool32 computeBindingPointSupport; 3946 safe_VkDeviceGeneratedCommandsFeaturesNVX(const VkDeviceGeneratedCommandsFeaturesNVX* in_struct); 3947 safe_VkDeviceGeneratedCommandsFeaturesNVX(const safe_VkDeviceGeneratedCommandsFeaturesNVX& src); 3948 safe_VkDeviceGeneratedCommandsFeaturesNVX& operator=(const safe_VkDeviceGeneratedCommandsFeaturesNVX& src); 3949 safe_VkDeviceGeneratedCommandsFeaturesNVX(); 3950 ~safe_VkDeviceGeneratedCommandsFeaturesNVX(); 3951 void initialize(const VkDeviceGeneratedCommandsFeaturesNVX* in_struct); 3952 void initialize(const safe_VkDeviceGeneratedCommandsFeaturesNVX* src); ptrsafe_VkDeviceGeneratedCommandsFeaturesNVX3953 VkDeviceGeneratedCommandsFeaturesNVX *ptr() { return reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX *>(this); } ptrsafe_VkDeviceGeneratedCommandsFeaturesNVX3954 VkDeviceGeneratedCommandsFeaturesNVX const *ptr() const { return reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX const *>(this); } 3955 }; 3956 3957 struct safe_VkDeviceGeneratedCommandsLimitsNVX { 3958 VkStructureType sType; 3959 const void* pNext; 3960 uint32_t maxIndirectCommandsLayoutTokenCount; 3961 uint32_t maxObjectEntryCounts; 3962 uint32_t minSequenceCountBufferOffsetAlignment; 3963 uint32_t minSequenceIndexBufferOffsetAlignment; 3964 uint32_t minCommandsTokenBufferOffsetAlignment; 3965 safe_VkDeviceGeneratedCommandsLimitsNVX(const VkDeviceGeneratedCommandsLimitsNVX* in_struct); 3966 safe_VkDeviceGeneratedCommandsLimitsNVX(const safe_VkDeviceGeneratedCommandsLimitsNVX& src); 3967 safe_VkDeviceGeneratedCommandsLimitsNVX& operator=(const safe_VkDeviceGeneratedCommandsLimitsNVX& src); 3968 safe_VkDeviceGeneratedCommandsLimitsNVX(); 3969 ~safe_VkDeviceGeneratedCommandsLimitsNVX(); 3970 void initialize(const VkDeviceGeneratedCommandsLimitsNVX* in_struct); 3971 void initialize(const safe_VkDeviceGeneratedCommandsLimitsNVX* src); ptrsafe_VkDeviceGeneratedCommandsLimitsNVX3972 VkDeviceGeneratedCommandsLimitsNVX *ptr() { return reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX *>(this); } ptrsafe_VkDeviceGeneratedCommandsLimitsNVX3973 VkDeviceGeneratedCommandsLimitsNVX const *ptr() const { return reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX const *>(this); } 3974 }; 3975 3976 struct safe_VkIndirectCommandsLayoutCreateInfoNVX { 3977 VkStructureType sType; 3978 const void* pNext; 3979 VkPipelineBindPoint pipelineBindPoint; 3980 VkIndirectCommandsLayoutUsageFlagsNVX flags; 3981 uint32_t tokenCount; 3982 const VkIndirectCommandsLayoutTokenNVX* pTokens; 3983 safe_VkIndirectCommandsLayoutCreateInfoNVX(const VkIndirectCommandsLayoutCreateInfoNVX* in_struct); 3984 safe_VkIndirectCommandsLayoutCreateInfoNVX(const safe_VkIndirectCommandsLayoutCreateInfoNVX& src); 3985 safe_VkIndirectCommandsLayoutCreateInfoNVX& operator=(const safe_VkIndirectCommandsLayoutCreateInfoNVX& src); 3986 safe_VkIndirectCommandsLayoutCreateInfoNVX(); 3987 ~safe_VkIndirectCommandsLayoutCreateInfoNVX(); 3988 void initialize(const VkIndirectCommandsLayoutCreateInfoNVX* in_struct); 3989 void initialize(const safe_VkIndirectCommandsLayoutCreateInfoNVX* src); ptrsafe_VkIndirectCommandsLayoutCreateInfoNVX3990 VkIndirectCommandsLayoutCreateInfoNVX *ptr() { return reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNVX *>(this); } ptrsafe_VkIndirectCommandsLayoutCreateInfoNVX3991 VkIndirectCommandsLayoutCreateInfoNVX const *ptr() const { return reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNVX const *>(this); } 3992 }; 3993 3994 struct safe_VkCmdProcessCommandsInfoNVX { 3995 VkStructureType sType; 3996 const void* pNext; 3997 VkObjectTableNVX objectTable; 3998 VkIndirectCommandsLayoutNVX indirectCommandsLayout; 3999 uint32_t indirectCommandsTokenCount; 4000 VkIndirectCommandsTokenNVX* pIndirectCommandsTokens; 4001 uint32_t maxSequencesCount; 4002 VkCommandBuffer targetCommandBuffer; 4003 VkBuffer sequencesCountBuffer; 4004 VkDeviceSize sequencesCountOffset; 4005 VkBuffer sequencesIndexBuffer; 4006 VkDeviceSize sequencesIndexOffset; 4007 safe_VkCmdProcessCommandsInfoNVX(const VkCmdProcessCommandsInfoNVX* in_struct); 4008 safe_VkCmdProcessCommandsInfoNVX(const safe_VkCmdProcessCommandsInfoNVX& src); 4009 safe_VkCmdProcessCommandsInfoNVX& operator=(const safe_VkCmdProcessCommandsInfoNVX& src); 4010 safe_VkCmdProcessCommandsInfoNVX(); 4011 ~safe_VkCmdProcessCommandsInfoNVX(); 4012 void initialize(const VkCmdProcessCommandsInfoNVX* in_struct); 4013 void initialize(const safe_VkCmdProcessCommandsInfoNVX* src); ptrsafe_VkCmdProcessCommandsInfoNVX4014 VkCmdProcessCommandsInfoNVX *ptr() { return reinterpret_cast<VkCmdProcessCommandsInfoNVX *>(this); } ptrsafe_VkCmdProcessCommandsInfoNVX4015 VkCmdProcessCommandsInfoNVX const *ptr() const { return reinterpret_cast<VkCmdProcessCommandsInfoNVX const *>(this); } 4016 }; 4017 4018 struct safe_VkCmdReserveSpaceForCommandsInfoNVX { 4019 VkStructureType sType; 4020 const void* pNext; 4021 VkObjectTableNVX objectTable; 4022 VkIndirectCommandsLayoutNVX indirectCommandsLayout; 4023 uint32_t maxSequencesCount; 4024 safe_VkCmdReserveSpaceForCommandsInfoNVX(const VkCmdReserveSpaceForCommandsInfoNVX* in_struct); 4025 safe_VkCmdReserveSpaceForCommandsInfoNVX(const safe_VkCmdReserveSpaceForCommandsInfoNVX& src); 4026 safe_VkCmdReserveSpaceForCommandsInfoNVX& operator=(const safe_VkCmdReserveSpaceForCommandsInfoNVX& src); 4027 safe_VkCmdReserveSpaceForCommandsInfoNVX(); 4028 ~safe_VkCmdReserveSpaceForCommandsInfoNVX(); 4029 void initialize(const VkCmdReserveSpaceForCommandsInfoNVX* in_struct); 4030 void initialize(const safe_VkCmdReserveSpaceForCommandsInfoNVX* src); ptrsafe_VkCmdReserveSpaceForCommandsInfoNVX4031 VkCmdReserveSpaceForCommandsInfoNVX *ptr() { return reinterpret_cast<VkCmdReserveSpaceForCommandsInfoNVX *>(this); } ptrsafe_VkCmdReserveSpaceForCommandsInfoNVX4032 VkCmdReserveSpaceForCommandsInfoNVX const *ptr() const { return reinterpret_cast<VkCmdReserveSpaceForCommandsInfoNVX const *>(this); } 4033 }; 4034 4035 struct safe_VkObjectTableCreateInfoNVX { 4036 VkStructureType sType; 4037 const void* pNext; 4038 uint32_t objectCount; 4039 const VkObjectEntryTypeNVX* pObjectEntryTypes; 4040 const uint32_t* pObjectEntryCounts; 4041 const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags; 4042 uint32_t maxUniformBuffersPerDescriptor; 4043 uint32_t maxStorageBuffersPerDescriptor; 4044 uint32_t maxStorageImagesPerDescriptor; 4045 uint32_t maxSampledImagesPerDescriptor; 4046 uint32_t maxPipelineLayouts; 4047 safe_VkObjectTableCreateInfoNVX(const VkObjectTableCreateInfoNVX* in_struct); 4048 safe_VkObjectTableCreateInfoNVX(const safe_VkObjectTableCreateInfoNVX& src); 4049 safe_VkObjectTableCreateInfoNVX& operator=(const safe_VkObjectTableCreateInfoNVX& src); 4050 safe_VkObjectTableCreateInfoNVX(); 4051 ~safe_VkObjectTableCreateInfoNVX(); 4052 void initialize(const VkObjectTableCreateInfoNVX* in_struct); 4053 void initialize(const safe_VkObjectTableCreateInfoNVX* src); ptrsafe_VkObjectTableCreateInfoNVX4054 VkObjectTableCreateInfoNVX *ptr() { return reinterpret_cast<VkObjectTableCreateInfoNVX *>(this); } ptrsafe_VkObjectTableCreateInfoNVX4055 VkObjectTableCreateInfoNVX const *ptr() const { return reinterpret_cast<VkObjectTableCreateInfoNVX const *>(this); } 4056 }; 4057 4058 struct safe_VkPipelineViewportWScalingStateCreateInfoNV { 4059 VkStructureType sType; 4060 const void* pNext; 4061 VkBool32 viewportWScalingEnable; 4062 uint32_t viewportCount; 4063 const VkViewportWScalingNV* pViewportWScalings; 4064 safe_VkPipelineViewportWScalingStateCreateInfoNV(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct); 4065 safe_VkPipelineViewportWScalingStateCreateInfoNV(const safe_VkPipelineViewportWScalingStateCreateInfoNV& src); 4066 safe_VkPipelineViewportWScalingStateCreateInfoNV& operator=(const safe_VkPipelineViewportWScalingStateCreateInfoNV& src); 4067 safe_VkPipelineViewportWScalingStateCreateInfoNV(); 4068 ~safe_VkPipelineViewportWScalingStateCreateInfoNV(); 4069 void initialize(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct); 4070 void initialize(const safe_VkPipelineViewportWScalingStateCreateInfoNV* src); ptrsafe_VkPipelineViewportWScalingStateCreateInfoNV4071 VkPipelineViewportWScalingStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV *>(this); } ptrsafe_VkPipelineViewportWScalingStateCreateInfoNV4072 VkPipelineViewportWScalingStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV const *>(this); } 4073 }; 4074 4075 struct safe_VkSurfaceCapabilities2EXT { 4076 VkStructureType sType; 4077 void* pNext; 4078 uint32_t minImageCount; 4079 uint32_t maxImageCount; 4080 VkExtent2D currentExtent; 4081 VkExtent2D minImageExtent; 4082 VkExtent2D maxImageExtent; 4083 uint32_t maxImageArrayLayers; 4084 VkSurfaceTransformFlagsKHR supportedTransforms; 4085 VkSurfaceTransformFlagBitsKHR currentTransform; 4086 VkCompositeAlphaFlagsKHR supportedCompositeAlpha; 4087 VkImageUsageFlags supportedUsageFlags; 4088 VkSurfaceCounterFlagsEXT supportedSurfaceCounters; 4089 safe_VkSurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT* in_struct); 4090 safe_VkSurfaceCapabilities2EXT(const safe_VkSurfaceCapabilities2EXT& src); 4091 safe_VkSurfaceCapabilities2EXT& operator=(const safe_VkSurfaceCapabilities2EXT& src); 4092 safe_VkSurfaceCapabilities2EXT(); 4093 ~safe_VkSurfaceCapabilities2EXT(); 4094 void initialize(const VkSurfaceCapabilities2EXT* in_struct); 4095 void initialize(const safe_VkSurfaceCapabilities2EXT* src); ptrsafe_VkSurfaceCapabilities2EXT4096 VkSurfaceCapabilities2EXT *ptr() { return reinterpret_cast<VkSurfaceCapabilities2EXT *>(this); } ptrsafe_VkSurfaceCapabilities2EXT4097 VkSurfaceCapabilities2EXT const *ptr() const { return reinterpret_cast<VkSurfaceCapabilities2EXT const *>(this); } 4098 }; 4099 4100 struct safe_VkDisplayPowerInfoEXT { 4101 VkStructureType sType; 4102 const void* pNext; 4103 VkDisplayPowerStateEXT powerState; 4104 safe_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT* in_struct); 4105 safe_VkDisplayPowerInfoEXT(const safe_VkDisplayPowerInfoEXT& src); 4106 safe_VkDisplayPowerInfoEXT& operator=(const safe_VkDisplayPowerInfoEXT& src); 4107 safe_VkDisplayPowerInfoEXT(); 4108 ~safe_VkDisplayPowerInfoEXT(); 4109 void initialize(const VkDisplayPowerInfoEXT* in_struct); 4110 void initialize(const safe_VkDisplayPowerInfoEXT* src); ptrsafe_VkDisplayPowerInfoEXT4111 VkDisplayPowerInfoEXT *ptr() { return reinterpret_cast<VkDisplayPowerInfoEXT *>(this); } ptrsafe_VkDisplayPowerInfoEXT4112 VkDisplayPowerInfoEXT const *ptr() const { return reinterpret_cast<VkDisplayPowerInfoEXT const *>(this); } 4113 }; 4114 4115 struct safe_VkDeviceEventInfoEXT { 4116 VkStructureType sType; 4117 const void* pNext; 4118 VkDeviceEventTypeEXT deviceEvent; 4119 safe_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT* in_struct); 4120 safe_VkDeviceEventInfoEXT(const safe_VkDeviceEventInfoEXT& src); 4121 safe_VkDeviceEventInfoEXT& operator=(const safe_VkDeviceEventInfoEXT& src); 4122 safe_VkDeviceEventInfoEXT(); 4123 ~safe_VkDeviceEventInfoEXT(); 4124 void initialize(const VkDeviceEventInfoEXT* in_struct); 4125 void initialize(const safe_VkDeviceEventInfoEXT* src); ptrsafe_VkDeviceEventInfoEXT4126 VkDeviceEventInfoEXT *ptr() { return reinterpret_cast<VkDeviceEventInfoEXT *>(this); } ptrsafe_VkDeviceEventInfoEXT4127 VkDeviceEventInfoEXT const *ptr() const { return reinterpret_cast<VkDeviceEventInfoEXT const *>(this); } 4128 }; 4129 4130 struct safe_VkDisplayEventInfoEXT { 4131 VkStructureType sType; 4132 const void* pNext; 4133 VkDisplayEventTypeEXT displayEvent; 4134 safe_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT* in_struct); 4135 safe_VkDisplayEventInfoEXT(const safe_VkDisplayEventInfoEXT& src); 4136 safe_VkDisplayEventInfoEXT& operator=(const safe_VkDisplayEventInfoEXT& src); 4137 safe_VkDisplayEventInfoEXT(); 4138 ~safe_VkDisplayEventInfoEXT(); 4139 void initialize(const VkDisplayEventInfoEXT* in_struct); 4140 void initialize(const safe_VkDisplayEventInfoEXT* src); ptrsafe_VkDisplayEventInfoEXT4141 VkDisplayEventInfoEXT *ptr() { return reinterpret_cast<VkDisplayEventInfoEXT *>(this); } ptrsafe_VkDisplayEventInfoEXT4142 VkDisplayEventInfoEXT const *ptr() const { return reinterpret_cast<VkDisplayEventInfoEXT const *>(this); } 4143 }; 4144 4145 struct safe_VkSwapchainCounterCreateInfoEXT { 4146 VkStructureType sType; 4147 const void* pNext; 4148 VkSurfaceCounterFlagsEXT surfaceCounters; 4149 safe_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT* in_struct); 4150 safe_VkSwapchainCounterCreateInfoEXT(const safe_VkSwapchainCounterCreateInfoEXT& src); 4151 safe_VkSwapchainCounterCreateInfoEXT& operator=(const safe_VkSwapchainCounterCreateInfoEXT& src); 4152 safe_VkSwapchainCounterCreateInfoEXT(); 4153 ~safe_VkSwapchainCounterCreateInfoEXT(); 4154 void initialize(const VkSwapchainCounterCreateInfoEXT* in_struct); 4155 void initialize(const safe_VkSwapchainCounterCreateInfoEXT* src); ptrsafe_VkSwapchainCounterCreateInfoEXT4156 VkSwapchainCounterCreateInfoEXT *ptr() { return reinterpret_cast<VkSwapchainCounterCreateInfoEXT *>(this); } ptrsafe_VkSwapchainCounterCreateInfoEXT4157 VkSwapchainCounterCreateInfoEXT const *ptr() const { return reinterpret_cast<VkSwapchainCounterCreateInfoEXT const *>(this); } 4158 }; 4159 4160 struct safe_VkPresentTimesInfoGOOGLE { 4161 VkStructureType sType; 4162 const void* pNext; 4163 uint32_t swapchainCount; 4164 const VkPresentTimeGOOGLE* pTimes; 4165 safe_VkPresentTimesInfoGOOGLE(const VkPresentTimesInfoGOOGLE* in_struct); 4166 safe_VkPresentTimesInfoGOOGLE(const safe_VkPresentTimesInfoGOOGLE& src); 4167 safe_VkPresentTimesInfoGOOGLE& operator=(const safe_VkPresentTimesInfoGOOGLE& src); 4168 safe_VkPresentTimesInfoGOOGLE(); 4169 ~safe_VkPresentTimesInfoGOOGLE(); 4170 void initialize(const VkPresentTimesInfoGOOGLE* in_struct); 4171 void initialize(const safe_VkPresentTimesInfoGOOGLE* src); ptrsafe_VkPresentTimesInfoGOOGLE4172 VkPresentTimesInfoGOOGLE *ptr() { return reinterpret_cast<VkPresentTimesInfoGOOGLE *>(this); } ptrsafe_VkPresentTimesInfoGOOGLE4173 VkPresentTimesInfoGOOGLE const *ptr() const { return reinterpret_cast<VkPresentTimesInfoGOOGLE const *>(this); } 4174 }; 4175 4176 struct safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { 4177 VkStructureType sType; 4178 void* pNext; 4179 VkBool32 perViewPositionAllComponents; 4180 safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct); 4181 safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& src); 4182 safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& operator=(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& src); 4183 safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(); 4184 ~safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(); 4185 void initialize(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct); 4186 void initialize(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* src); ptrsafe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX4187 VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *ptr() { return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>(this); } ptrsafe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX4188 VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const *>(this); } 4189 }; 4190 4191 struct safe_VkPipelineViewportSwizzleStateCreateInfoNV { 4192 VkStructureType sType; 4193 const void* pNext; 4194 VkPipelineViewportSwizzleStateCreateFlagsNV flags; 4195 uint32_t viewportCount; 4196 const VkViewportSwizzleNV* pViewportSwizzles; 4197 safe_VkPipelineViewportSwizzleStateCreateInfoNV(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct); 4198 safe_VkPipelineViewportSwizzleStateCreateInfoNV(const safe_VkPipelineViewportSwizzleStateCreateInfoNV& src); 4199 safe_VkPipelineViewportSwizzleStateCreateInfoNV& operator=(const safe_VkPipelineViewportSwizzleStateCreateInfoNV& src); 4200 safe_VkPipelineViewportSwizzleStateCreateInfoNV(); 4201 ~safe_VkPipelineViewportSwizzleStateCreateInfoNV(); 4202 void initialize(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct); 4203 void initialize(const safe_VkPipelineViewportSwizzleStateCreateInfoNV* src); ptrsafe_VkPipelineViewportSwizzleStateCreateInfoNV4204 VkPipelineViewportSwizzleStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV *>(this); } ptrsafe_VkPipelineViewportSwizzleStateCreateInfoNV4205 VkPipelineViewportSwizzleStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV const *>(this); } 4206 }; 4207 4208 struct safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT { 4209 VkStructureType sType; 4210 void* pNext; 4211 uint32_t maxDiscardRectangles; 4212 safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct); 4213 safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& src); 4214 safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& operator=(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& src); 4215 safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(); 4216 ~safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(); 4217 void initialize(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct); 4218 void initialize(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT* src); ptrsafe_VkPhysicalDeviceDiscardRectanglePropertiesEXT4219 VkPhysicalDeviceDiscardRectanglePropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT *>(this); } ptrsafe_VkPhysicalDeviceDiscardRectanglePropertiesEXT4220 VkPhysicalDeviceDiscardRectanglePropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT const *>(this); } 4221 }; 4222 4223 struct safe_VkPipelineDiscardRectangleStateCreateInfoEXT { 4224 VkStructureType sType; 4225 const void* pNext; 4226 VkPipelineDiscardRectangleStateCreateFlagsEXT flags; 4227 VkDiscardRectangleModeEXT discardRectangleMode; 4228 uint32_t discardRectangleCount; 4229 const VkRect2D* pDiscardRectangles; 4230 safe_VkPipelineDiscardRectangleStateCreateInfoEXT(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct); 4231 safe_VkPipelineDiscardRectangleStateCreateInfoEXT(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT& src); 4232 safe_VkPipelineDiscardRectangleStateCreateInfoEXT& operator=(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT& src); 4233 safe_VkPipelineDiscardRectangleStateCreateInfoEXT(); 4234 ~safe_VkPipelineDiscardRectangleStateCreateInfoEXT(); 4235 void initialize(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct); 4236 void initialize(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT* src); ptrsafe_VkPipelineDiscardRectangleStateCreateInfoEXT4237 VkPipelineDiscardRectangleStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT *>(this); } ptrsafe_VkPipelineDiscardRectangleStateCreateInfoEXT4238 VkPipelineDiscardRectangleStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT const *>(this); } 4239 }; 4240 4241 struct safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT { 4242 VkStructureType sType; 4243 void* pNext; 4244 float primitiveOverestimationSize; 4245 float maxExtraPrimitiveOverestimationSize; 4246 float extraPrimitiveOverestimationSizeGranularity; 4247 VkBool32 primitiveUnderestimation; 4248 VkBool32 conservativePointAndLineRasterization; 4249 VkBool32 degenerateTrianglesRasterized; 4250 VkBool32 degenerateLinesRasterized; 4251 VkBool32 fullyCoveredFragmentShaderInputVariable; 4252 VkBool32 conservativeRasterizationPostDepthCoverage; 4253 safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct); 4254 safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& src); 4255 safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& operator=(const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& src); 4256 safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(); 4257 ~safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(); 4258 void initialize(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct); 4259 void initialize(const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT* src); ptrsafe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT4260 VkPhysicalDeviceConservativeRasterizationPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>(this); } ptrsafe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT4261 VkPhysicalDeviceConservativeRasterizationPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT const *>(this); } 4262 }; 4263 4264 struct safe_VkPipelineRasterizationConservativeStateCreateInfoEXT { 4265 VkStructureType sType; 4266 const void* pNext; 4267 VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; 4268 VkConservativeRasterizationModeEXT conservativeRasterizationMode; 4269 float extraPrimitiveOverestimationSize; 4270 safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct); 4271 safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& src); 4272 safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& operator=(const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& src); 4273 safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(); 4274 ~safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(); 4275 void initialize(const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct); 4276 void initialize(const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT* src); ptrsafe_VkPipelineRasterizationConservativeStateCreateInfoEXT4277 VkPipelineRasterizationConservativeStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT *>(this); } ptrsafe_VkPipelineRasterizationConservativeStateCreateInfoEXT4278 VkPipelineRasterizationConservativeStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT const *>(this); } 4279 }; 4280 4281 struct safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT { 4282 VkStructureType sType; 4283 void* pNext; 4284 VkBool32 depthClipEnable; 4285 safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct); 4286 safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& src); 4287 safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& operator=(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& src); 4288 safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(); 4289 ~safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(); 4290 void initialize(const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct); 4291 void initialize(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT* src); ptrsafe_VkPhysicalDeviceDepthClipEnableFeaturesEXT4292 VkPhysicalDeviceDepthClipEnableFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(this); } ptrsafe_VkPhysicalDeviceDepthClipEnableFeaturesEXT4293 VkPhysicalDeviceDepthClipEnableFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT const *>(this); } 4294 }; 4295 4296 struct safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT { 4297 VkStructureType sType; 4298 const void* pNext; 4299 VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags; 4300 VkBool32 depthClipEnable; 4301 safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct); 4302 safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& src); 4303 safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& operator=(const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& src); 4304 safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(); 4305 ~safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(); 4306 void initialize(const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct); 4307 void initialize(const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT* src); ptrsafe_VkPipelineRasterizationDepthClipStateCreateInfoEXT4308 VkPipelineRasterizationDepthClipStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT *>(this); } ptrsafe_VkPipelineRasterizationDepthClipStateCreateInfoEXT4309 VkPipelineRasterizationDepthClipStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT const *>(this); } 4310 }; 4311 4312 struct safe_VkHdrMetadataEXT { 4313 VkStructureType sType; 4314 const void* pNext; 4315 VkXYColorEXT displayPrimaryRed; 4316 VkXYColorEXT displayPrimaryGreen; 4317 VkXYColorEXT displayPrimaryBlue; 4318 VkXYColorEXT whitePoint; 4319 float maxLuminance; 4320 float minLuminance; 4321 float maxContentLightLevel; 4322 float maxFrameAverageLightLevel; 4323 safe_VkHdrMetadataEXT(const VkHdrMetadataEXT* in_struct); 4324 safe_VkHdrMetadataEXT(const safe_VkHdrMetadataEXT& src); 4325 safe_VkHdrMetadataEXT& operator=(const safe_VkHdrMetadataEXT& src); 4326 safe_VkHdrMetadataEXT(); 4327 ~safe_VkHdrMetadataEXT(); 4328 void initialize(const VkHdrMetadataEXT* in_struct); 4329 void initialize(const safe_VkHdrMetadataEXT* src); ptrsafe_VkHdrMetadataEXT4330 VkHdrMetadataEXT *ptr() { return reinterpret_cast<VkHdrMetadataEXT *>(this); } ptrsafe_VkHdrMetadataEXT4331 VkHdrMetadataEXT const *ptr() const { return reinterpret_cast<VkHdrMetadataEXT const *>(this); } 4332 }; 4333 4334 #ifdef VK_USE_PLATFORM_IOS_MVK 4335 struct safe_VkIOSSurfaceCreateInfoMVK { 4336 VkStructureType sType; 4337 const void* pNext; 4338 VkIOSSurfaceCreateFlagsMVK flags; 4339 const void* pView; 4340 safe_VkIOSSurfaceCreateInfoMVK(const VkIOSSurfaceCreateInfoMVK* in_struct); 4341 safe_VkIOSSurfaceCreateInfoMVK(const safe_VkIOSSurfaceCreateInfoMVK& src); 4342 safe_VkIOSSurfaceCreateInfoMVK& operator=(const safe_VkIOSSurfaceCreateInfoMVK& src); 4343 safe_VkIOSSurfaceCreateInfoMVK(); 4344 ~safe_VkIOSSurfaceCreateInfoMVK(); 4345 void initialize(const VkIOSSurfaceCreateInfoMVK* in_struct); 4346 void initialize(const safe_VkIOSSurfaceCreateInfoMVK* src); ptrsafe_VkIOSSurfaceCreateInfoMVK4347 VkIOSSurfaceCreateInfoMVK *ptr() { return reinterpret_cast<VkIOSSurfaceCreateInfoMVK *>(this); } ptrsafe_VkIOSSurfaceCreateInfoMVK4348 VkIOSSurfaceCreateInfoMVK const *ptr() const { return reinterpret_cast<VkIOSSurfaceCreateInfoMVK const *>(this); } 4349 }; 4350 #endif // VK_USE_PLATFORM_IOS_MVK 4351 4352 #ifdef VK_USE_PLATFORM_MACOS_MVK 4353 struct safe_VkMacOSSurfaceCreateInfoMVK { 4354 VkStructureType sType; 4355 const void* pNext; 4356 VkMacOSSurfaceCreateFlagsMVK flags; 4357 const void* pView; 4358 safe_VkMacOSSurfaceCreateInfoMVK(const VkMacOSSurfaceCreateInfoMVK* in_struct); 4359 safe_VkMacOSSurfaceCreateInfoMVK(const safe_VkMacOSSurfaceCreateInfoMVK& src); 4360 safe_VkMacOSSurfaceCreateInfoMVK& operator=(const safe_VkMacOSSurfaceCreateInfoMVK& src); 4361 safe_VkMacOSSurfaceCreateInfoMVK(); 4362 ~safe_VkMacOSSurfaceCreateInfoMVK(); 4363 void initialize(const VkMacOSSurfaceCreateInfoMVK* in_struct); 4364 void initialize(const safe_VkMacOSSurfaceCreateInfoMVK* src); ptrsafe_VkMacOSSurfaceCreateInfoMVK4365 VkMacOSSurfaceCreateInfoMVK *ptr() { return reinterpret_cast<VkMacOSSurfaceCreateInfoMVK *>(this); } ptrsafe_VkMacOSSurfaceCreateInfoMVK4366 VkMacOSSurfaceCreateInfoMVK const *ptr() const { return reinterpret_cast<VkMacOSSurfaceCreateInfoMVK const *>(this); } 4367 }; 4368 #endif // VK_USE_PLATFORM_MACOS_MVK 4369 4370 struct safe_VkDebugUtilsObjectNameInfoEXT { 4371 VkStructureType sType; 4372 const void* pNext; 4373 VkObjectType objectType; 4374 uint64_t objectHandle; 4375 const char* pObjectName; 4376 safe_VkDebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT* in_struct); 4377 safe_VkDebugUtilsObjectNameInfoEXT(const safe_VkDebugUtilsObjectNameInfoEXT& src); 4378 safe_VkDebugUtilsObjectNameInfoEXT& operator=(const safe_VkDebugUtilsObjectNameInfoEXT& src); 4379 safe_VkDebugUtilsObjectNameInfoEXT(); 4380 ~safe_VkDebugUtilsObjectNameInfoEXT(); 4381 void initialize(const VkDebugUtilsObjectNameInfoEXT* in_struct); 4382 void initialize(const safe_VkDebugUtilsObjectNameInfoEXT* src); ptrsafe_VkDebugUtilsObjectNameInfoEXT4383 VkDebugUtilsObjectNameInfoEXT *ptr() { return reinterpret_cast<VkDebugUtilsObjectNameInfoEXT *>(this); } ptrsafe_VkDebugUtilsObjectNameInfoEXT4384