Home | History | Annotate | Download | only in include 
      1 /* THIS FILE IS GENERATED.  DO NOT EDIT. */
      2 
      3 /*
      4  * Vulkan
      5  *
      6  * Copyright (c) 2015-2016 The Khronos Group Inc.
      7  * Copyright (c) 2015-2016 Valve Corporation.
      8  * Copyright (c) 2015-2016 LunarG, Inc.
      9  * Copyright (c) 2015-2016 Google Inc.
     10  *
     11  * Licensed under the Apache License, Version 2.0 (the "License");
     12  * you may not use this file except in compliance with the License.
     13  * You may obtain a copy of the License at
     14  *
     15  *     http://www.apache.org/licenses/LICENSE-2.0
     16  *
     17  * Unless required by applicable law or agreed to in writing, software
     18  * distributed under the License is distributed on an "AS IS" BASIS,
     19  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     20  * See the License for the specific language governing permissions and
     21  * limitations under the License.
     22  *
     23  * Author: Courtney Goeltzenleuchter <courtney (at) LunarG.com>
     24  * Author: Tobin Ehlis <tobin (at) lunarg.com>
     25  */
     26 //#includes, #defines, globals and such...
     27 #pragma once
     28 #include "vulkan/vulkan.h"
     29 struct safe_VkApplicationInfo {
     30     VkStructureType sType;
     31     const void* pNext;
     32     const char* pApplicationName;
     33     uint32_t applicationVersion;
     34     const char* pEngineName;
     35     uint32_t engineVersion;
     36     uint32_t apiVersion;
     37     safe_VkApplicationInfo(const VkApplicationInfo* pInStruct);
     38     safe_VkApplicationInfo(const safe_VkApplicationInfo& src);
     39     safe_VkApplicationInfo();
     40     ~safe_VkApplicationInfo();
     41     void initialize(const VkApplicationInfo* pInStruct);
     42     void initialize(const safe_VkApplicationInfo* src);
     43     VkApplicationInfo *ptr() { return reinterpret_cast<VkApplicationInfo *>(this); }
     44     VkApplicationInfo const *ptr() const { return reinterpret_cast<VkApplicationInfo const *>(this); }
     45 };
     46 
     47 struct safe_VkInstanceCreateInfo {
     48     VkStructureType sType;
     49     const void* pNext;
     50     VkInstanceCreateFlags flags;
     51     safe_VkApplicationInfo* pApplicationInfo;
     52     uint32_t enabledLayerCount;
     53     const char* const* ppEnabledLayerNames;
     54     uint32_t enabledExtensionCount;
     55     const char* const* ppEnabledExtensionNames;
     56     safe_VkInstanceCreateInfo(const VkInstanceCreateInfo* pInStruct);
     57     safe_VkInstanceCreateInfo(const safe_VkInstanceCreateInfo& src);
     58     safe_VkInstanceCreateInfo();
     59     ~safe_VkInstanceCreateInfo();
     60     void initialize(const VkInstanceCreateInfo* pInStruct);
     61     void initialize(const safe_VkInstanceCreateInfo* src);
     62     VkInstanceCreateInfo *ptr() { return reinterpret_cast<VkInstanceCreateInfo *>(this); }
     63     VkInstanceCreateInfo const *ptr() const { return reinterpret_cast<VkInstanceCreateInfo const *>(this); }
     64 };
     65 
     66 struct safe_VkAllocationCallbacks {
     67     void* pUserData;
     68     PFN_vkAllocationFunction pfnAllocation;
     69     PFN_vkReallocationFunction pfnReallocation;
     70     PFN_vkFreeFunction pfnFree;
     71     PFN_vkInternalAllocationNotification pfnInternalAllocation;
     72     PFN_vkInternalFreeNotification pfnInternalFree;
     73     safe_VkAllocationCallbacks(const VkAllocationCallbacks* pInStruct);
     74     safe_VkAllocationCallbacks(const safe_VkAllocationCallbacks& src);
     75     safe_VkAllocationCallbacks();
     76     ~safe_VkAllocationCallbacks();
     77     void initialize(const VkAllocationCallbacks* pInStruct);
     78     void initialize(const safe_VkAllocationCallbacks* src);
     79     VkAllocationCallbacks *ptr() { return reinterpret_cast<VkAllocationCallbacks *>(this); }
     80     VkAllocationCallbacks const *ptr() const { return reinterpret_cast<VkAllocationCallbacks const *>(this); }
     81 };
     82 
     83 struct safe_VkDeviceQueueCreateInfo {
     84     VkStructureType sType;
     85     const void* pNext;
     86     VkDeviceQueueCreateFlags flags;
     87     uint32_t queueFamilyIndex;
     88     uint32_t queueCount;
     89     const float* pQueuePriorities;
     90     safe_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo* pInStruct);
     91     safe_VkDeviceQueueCreateInfo(const safe_VkDeviceQueueCreateInfo& src);
     92     safe_VkDeviceQueueCreateInfo();
     93     ~safe_VkDeviceQueueCreateInfo();
     94     void initialize(const VkDeviceQueueCreateInfo* pInStruct);
     95     void initialize(const safe_VkDeviceQueueCreateInfo* src);
     96     VkDeviceQueueCreateInfo *ptr() { return reinterpret_cast<VkDeviceQueueCreateInfo *>(this); }
     97     VkDeviceQueueCreateInfo const *ptr() const { return reinterpret_cast<VkDeviceQueueCreateInfo const *>(this); }
     98 };
     99 
    100 struct safe_VkDeviceCreateInfo {
    101     VkStructureType sType;
    102     const void* pNext;
    103     VkDeviceCreateFlags flags;
    104     uint32_t queueCreateInfoCount;
    105     safe_VkDeviceQueueCreateInfo* pQueueCreateInfos;
    106     uint32_t enabledLayerCount;
    107     const char* const* ppEnabledLayerNames;
    108     uint32_t enabledExtensionCount;
    109     const char* const* ppEnabledExtensionNames;
    110     const VkPhysicalDeviceFeatures* pEnabledFeatures;
    111     safe_VkDeviceCreateInfo(const VkDeviceCreateInfo* pInStruct);
    112     safe_VkDeviceCreateInfo(const safe_VkDeviceCreateInfo& src);
    113     safe_VkDeviceCreateInfo();
    114     ~safe_VkDeviceCreateInfo();
    115     void initialize(const VkDeviceCreateInfo* pInStruct);
    116     void initialize(const safe_VkDeviceCreateInfo* src);
    117     VkDeviceCreateInfo *ptr() { return reinterpret_cast<VkDeviceCreateInfo *>(this); }
    118     VkDeviceCreateInfo const *ptr() const { return reinterpret_cast<VkDeviceCreateInfo const *>(this); }
    119 };
    120 
    121 struct safe_VkSubmitInfo {
    122     VkStructureType sType;
    123     const void* pNext;
    124     uint32_t waitSemaphoreCount;
    125     VkSemaphore* pWaitSemaphores;
    126     const VkPipelineStageFlags* pWaitDstStageMask;
    127     uint32_t commandBufferCount;
    128     const VkCommandBuffer* pCommandBuffers;
    129     uint32_t signalSemaphoreCount;
    130     VkSemaphore* pSignalSemaphores;
    131     safe_VkSubmitInfo(const VkSubmitInfo* pInStruct);
    132     safe_VkSubmitInfo(const safe_VkSubmitInfo& src);
    133     safe_VkSubmitInfo();
    134     ~safe_VkSubmitInfo();
    135     void initialize(const VkSubmitInfo* pInStruct);
    136     void initialize(const safe_VkSubmitInfo* src);
    137     VkSubmitInfo *ptr() { return reinterpret_cast<VkSubmitInfo *>(this); }
    138     VkSubmitInfo const *ptr() const { return reinterpret_cast<VkSubmitInfo const *>(this); }
    139 };
    140 
    141 struct safe_VkMemoryAllocateInfo {
    142     VkStructureType sType;
    143     const void* pNext;
    144     VkDeviceSize allocationSize;
    145     uint32_t memoryTypeIndex;
    146     safe_VkMemoryAllocateInfo(const VkMemoryAllocateInfo* pInStruct);
    147     safe_VkMemoryAllocateInfo(const safe_VkMemoryAllocateInfo& src);
    148     safe_VkMemoryAllocateInfo();
    149     ~safe_VkMemoryAllocateInfo();
    150     void initialize(const VkMemoryAllocateInfo* pInStruct);
    151     void initialize(const safe_VkMemoryAllocateInfo* src);
    152     VkMemoryAllocateInfo *ptr() { return reinterpret_cast<VkMemoryAllocateInfo *>(this); }
    153     VkMemoryAllocateInfo const *ptr() const { return reinterpret_cast<VkMemoryAllocateInfo const *>(this); }
    154 };
    155 
    156 struct safe_VkMappedMemoryRange {
    157     VkStructureType sType;
    158     const void* pNext;
    159     VkDeviceMemory memory;
    160     VkDeviceSize offset;
    161     VkDeviceSize size;
    162     safe_VkMappedMemoryRange(const VkMappedMemoryRange* pInStruct);
    163     safe_VkMappedMemoryRange(const safe_VkMappedMemoryRange& src);
    164     safe_VkMappedMemoryRange();
    165     ~safe_VkMappedMemoryRange();
    166     void initialize(const VkMappedMemoryRange* pInStruct);
    167     void initialize(const safe_VkMappedMemoryRange* src);
    168     VkMappedMemoryRange *ptr() { return reinterpret_cast<VkMappedMemoryRange *>(this); }
    169     VkMappedMemoryRange const *ptr() const { return reinterpret_cast<VkMappedMemoryRange const *>(this); }
    170 };
    171 
    172 struct safe_VkSparseBufferMemoryBindInfo {
    173     VkBuffer buffer;
    174     uint32_t bindCount;
    175     VkSparseMemoryBind* pBinds;
    176     safe_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo* pInStruct);
    177     safe_VkSparseBufferMemoryBindInfo(const safe_VkSparseBufferMemoryBindInfo& src);
    178     safe_VkSparseBufferMemoryBindInfo();
    179     ~safe_VkSparseBufferMemoryBindInfo();
    180     void initialize(const VkSparseBufferMemoryBindInfo* pInStruct);
    181     void initialize(const safe_VkSparseBufferMemoryBindInfo* src);
    182     VkSparseBufferMemoryBindInfo *ptr() { return reinterpret_cast<VkSparseBufferMemoryBindInfo *>(this); }
    183     VkSparseBufferMemoryBindInfo const *ptr() const { return reinterpret_cast<VkSparseBufferMemoryBindInfo const *>(this); }
    184 };
    185 
    186 struct safe_VkSparseImageOpaqueMemoryBindInfo {
    187     VkImage image;
    188     uint32_t bindCount;
    189     VkSparseMemoryBind* pBinds;
    190     safe_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo* pInStruct);
    191     safe_VkSparseImageOpaqueMemoryBindInfo(const safe_VkSparseImageOpaqueMemoryBindInfo& src);
    192     safe_VkSparseImageOpaqueMemoryBindInfo();
    193     ~safe_VkSparseImageOpaqueMemoryBindInfo();
    194     void initialize(const VkSparseImageOpaqueMemoryBindInfo* pInStruct);
    195     void initialize(const safe_VkSparseImageOpaqueMemoryBindInfo* src);
    196     VkSparseImageOpaqueMemoryBindInfo *ptr() { return reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo *>(this); }
    197     VkSparseImageOpaqueMemoryBindInfo const *ptr() const { return reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo const *>(this); }
    198 };
    199 
    200 struct safe_VkSparseImageMemoryBindInfo {
    201     VkImage image;
    202     uint32_t bindCount;
    203     VkSparseImageMemoryBind* pBinds;
    204     safe_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo* pInStruct);
    205     safe_VkSparseImageMemoryBindInfo(const safe_VkSparseImageMemoryBindInfo& src);
    206     safe_VkSparseImageMemoryBindInfo();
    207     ~safe_VkSparseImageMemoryBindInfo();
    208     void initialize(const VkSparseImageMemoryBindInfo* pInStruct);
    209     void initialize(const safe_VkSparseImageMemoryBindInfo* src);
    210     VkSparseImageMemoryBindInfo *ptr() { return reinterpret_cast<VkSparseImageMemoryBindInfo *>(this); }
    211     VkSparseImageMemoryBindInfo const *ptr() const { return reinterpret_cast<VkSparseImageMemoryBindInfo const *>(this); }
    212 };
    213 
    214 struct safe_VkBindSparseInfo {
    215     VkStructureType sType;
    216     const void* pNext;
    217     uint32_t waitSemaphoreCount;
    218     VkSemaphore* pWaitSemaphores;
    219     uint32_t bufferBindCount;
    220     safe_VkSparseBufferMemoryBindInfo* pBufferBinds;
    221     uint32_t imageOpaqueBindCount;
    222     safe_VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
    223     uint32_t imageBindCount;
    224     safe_VkSparseImageMemoryBindInfo* pImageBinds;
    225     uint32_t signalSemaphoreCount;
    226     VkSemaphore* pSignalSemaphores;
    227     safe_VkBindSparseInfo(const VkBindSparseInfo* pInStruct);
    228     safe_VkBindSparseInfo(const safe_VkBindSparseInfo& src);
    229     safe_VkBindSparseInfo();
    230     ~safe_VkBindSparseInfo();
    231     void initialize(const VkBindSparseInfo* pInStruct);
    232     void initialize(const safe_VkBindSparseInfo* src);
    233     VkBindSparseInfo *ptr() { return reinterpret_cast<VkBindSparseInfo *>(this); }
    234     VkBindSparseInfo const *ptr() const { return reinterpret_cast<VkBindSparseInfo const *>(this); }
    235 };
    236 
    237 struct safe_VkFenceCreateInfo {
    238     VkStructureType sType;
    239     const void* pNext;
    240     VkFenceCreateFlags flags;
    241     safe_VkFenceCreateInfo(const VkFenceCreateInfo* pInStruct);
    242     safe_VkFenceCreateInfo(const safe_VkFenceCreateInfo& src);
    243     safe_VkFenceCreateInfo();
    244     ~safe_VkFenceCreateInfo();
    245     void initialize(const VkFenceCreateInfo* pInStruct);
    246     void initialize(const safe_VkFenceCreateInfo* src);
    247     VkFenceCreateInfo *ptr() { return reinterpret_cast<VkFenceCreateInfo *>(this); }
    248     VkFenceCreateInfo const *ptr() const { return reinterpret_cast<VkFenceCreateInfo const *>(this); }
    249 };
    250 
    251 struct safe_VkSemaphoreCreateInfo {
    252     VkStructureType sType;
    253     const void* pNext;
    254     VkSemaphoreCreateFlags flags;
    255     safe_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo* pInStruct);
    256     safe_VkSemaphoreCreateInfo(const safe_VkSemaphoreCreateInfo& src);
    257     safe_VkSemaphoreCreateInfo();
    258     ~safe_VkSemaphoreCreateInfo();
    259     void initialize(const VkSemaphoreCreateInfo* pInStruct);
    260     void initialize(const safe_VkSemaphoreCreateInfo* src);
    261     VkSemaphoreCreateInfo *ptr() { return reinterpret_cast<VkSemaphoreCreateInfo *>(this); }
    262     VkSemaphoreCreateInfo const *ptr() const { return reinterpret_cast<VkSemaphoreCreateInfo const *>(this); }
    263 };
    264 
    265 struct safe_VkEventCreateInfo {
    266     VkStructureType sType;
    267     const void* pNext;
    268     VkEventCreateFlags flags;
    269     safe_VkEventCreateInfo(const VkEventCreateInfo* pInStruct);
    270     safe_VkEventCreateInfo(const safe_VkEventCreateInfo& src);
    271     safe_VkEventCreateInfo();
    272     ~safe_VkEventCreateInfo();
    273     void initialize(const VkEventCreateInfo* pInStruct);
    274     void initialize(const safe_VkEventCreateInfo* src);
    275     VkEventCreateInfo *ptr() { return reinterpret_cast<VkEventCreateInfo *>(this); }
    276     VkEventCreateInfo const *ptr() const { return reinterpret_cast<VkEventCreateInfo const *>(this); }
    277 };
    278 
    279 struct safe_VkQueryPoolCreateInfo {
    280     VkStructureType sType;
    281     const void* pNext;
    282     VkQueryPoolCreateFlags flags;
    283     VkQueryType queryType;
    284     uint32_t queryCount;
    285     VkQueryPipelineStatisticFlags pipelineStatistics;
    286     safe_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo* pInStruct);
    287     safe_VkQueryPoolCreateInfo(const safe_VkQueryPoolCreateInfo& src);
    288     safe_VkQueryPoolCreateInfo();
    289     ~safe_VkQueryPoolCreateInfo();
    290     void initialize(const VkQueryPoolCreateInfo* pInStruct);
    291     void initialize(const safe_VkQueryPoolCreateInfo* src);
    292     VkQueryPoolCreateInfo *ptr() { return reinterpret_cast<VkQueryPoolCreateInfo *>(this); }
    293     VkQueryPoolCreateInfo const *ptr() const { return reinterpret_cast<VkQueryPoolCreateInfo const *>(this); }
    294 };
    295 
    296 struct safe_VkBufferCreateInfo {
    297     VkStructureType sType;
    298     const void* pNext;
    299     VkBufferCreateFlags flags;
    300     VkDeviceSize size;
    301     VkBufferUsageFlags usage;
    302     VkSharingMode sharingMode;
    303     uint32_t queueFamilyIndexCount;
    304     const uint32_t* pQueueFamilyIndices;
    305     safe_VkBufferCreateInfo(const VkBufferCreateInfo* pInStruct);
    306     safe_VkBufferCreateInfo(const safe_VkBufferCreateInfo& src);
    307     safe_VkBufferCreateInfo();
    308     ~safe_VkBufferCreateInfo();
    309     void initialize(const VkBufferCreateInfo* pInStruct);
    310     void initialize(const safe_VkBufferCreateInfo* src);
    311     VkBufferCreateInfo *ptr() { return reinterpret_cast<VkBufferCreateInfo *>(this); }
    312     VkBufferCreateInfo const *ptr() const { return reinterpret_cast<VkBufferCreateInfo const *>(this); }
    313 };
    314 
    315 struct safe_VkBufferViewCreateInfo {
    316     VkStructureType sType;
    317     const void* pNext;
    318     VkBufferViewCreateFlags flags;
    319     VkBuffer buffer;
    320     VkFormat format;
    321     VkDeviceSize offset;
    322     VkDeviceSize range;
    323     safe_VkBufferViewCreateInfo(const VkBufferViewCreateInfo* pInStruct);
    324     safe_VkBufferViewCreateInfo(const safe_VkBufferViewCreateInfo& src);
    325     safe_VkBufferViewCreateInfo();
    326     ~safe_VkBufferViewCreateInfo();
    327     void initialize(const VkBufferViewCreateInfo* pInStruct);
    328     void initialize(const safe_VkBufferViewCreateInfo* src);
    329     VkBufferViewCreateInfo *ptr() { return reinterpret_cast<VkBufferViewCreateInfo *>(this); }
    330     VkBufferViewCreateInfo const *ptr() const { return reinterpret_cast<VkBufferViewCreateInfo const *>(this); }
    331 };
    332 
    333 struct safe_VkImageCreateInfo {
    334     VkStructureType sType;
    335     const void* pNext;
    336     VkImageCreateFlags flags;
    337     VkImageType imageType;
    338     VkFormat format;
    339     VkExtent3D extent;
    340     uint32_t mipLevels;
    341     uint32_t arrayLayers;
    342     VkSampleCountFlagBits samples;
    343     VkImageTiling tiling;
    344     VkImageUsageFlags usage;
    345     VkSharingMode sharingMode;
    346     uint32_t queueFamilyIndexCount;
    347     const uint32_t* pQueueFamilyIndices;
    348     VkImageLayout initialLayout;
    349     safe_VkImageCreateInfo(const VkImageCreateInfo* pInStruct);
    350     safe_VkImageCreateInfo(const safe_VkImageCreateInfo& src);
    351     safe_VkImageCreateInfo();
    352     ~safe_VkImageCreateInfo();
    353     void initialize(const VkImageCreateInfo* pInStruct);
    354     void initialize(const safe_VkImageCreateInfo* src);
    355     VkImageCreateInfo *ptr() { return reinterpret_cast<VkImageCreateInfo *>(this); }
    356     VkImageCreateInfo const *ptr() const { return reinterpret_cast<VkImageCreateInfo const *>(this); }
    357 };
    358 
    359 struct safe_VkImageViewCreateInfo {
    360     VkStructureType sType;
    361     const void* pNext;
    362     VkImageViewCreateFlags flags;
    363     VkImage image;
    364     VkImageViewType viewType;
    365     VkFormat format;
    366     VkComponentMapping components;
    367     VkImageSubresourceRange subresourceRange;
    368     safe_VkImageViewCreateInfo(const VkImageViewCreateInfo* pInStruct);
    369     safe_VkImageViewCreateInfo(const safe_VkImageViewCreateInfo& src);
    370     safe_VkImageViewCreateInfo();
    371     ~safe_VkImageViewCreateInfo();
    372     void initialize(const VkImageViewCreateInfo* pInStruct);
    373     void initialize(const safe_VkImageViewCreateInfo* src);
    374     VkImageViewCreateInfo *ptr() { return reinterpret_cast<VkImageViewCreateInfo *>(this); }
    375     VkImageViewCreateInfo const *ptr() const { return reinterpret_cast<VkImageViewCreateInfo const *>(this); }
    376 };
    377 
    378 struct safe_VkShaderModuleCreateInfo {
    379     VkStructureType sType;
    380     const void* pNext;
    381     VkShaderModuleCreateFlags flags;
    382     size_t codeSize;
    383     const uint32_t* pCode;
    384     safe_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo* pInStruct);
    385     safe_VkShaderModuleCreateInfo(const safe_VkShaderModuleCreateInfo& src);
    386     safe_VkShaderModuleCreateInfo();
    387     ~safe_VkShaderModuleCreateInfo();
    388     void initialize(const VkShaderModuleCreateInfo* pInStruct);
    389     void initialize(const safe_VkShaderModuleCreateInfo* src);
    390     VkShaderModuleCreateInfo *ptr() { return reinterpret_cast<VkShaderModuleCreateInfo *>(this); }
    391     VkShaderModuleCreateInfo const *ptr() const { return reinterpret_cast<VkShaderModuleCreateInfo const *>(this); }
    392 };
    393 
    394 struct safe_VkPipelineCacheCreateInfo {
    395     VkStructureType sType;
    396     const void* pNext;
    397     VkPipelineCacheCreateFlags flags;
    398     size_t initialDataSize;
    399     const void* pInitialData;
    400     safe_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo* pInStruct);
    401     safe_VkPipelineCacheCreateInfo(const safe_VkPipelineCacheCreateInfo& src);
    402     safe_VkPipelineCacheCreateInfo();
    403     ~safe_VkPipelineCacheCreateInfo();
    404     void initialize(const VkPipelineCacheCreateInfo* pInStruct);
    405     void initialize(const safe_VkPipelineCacheCreateInfo* src);
    406     VkPipelineCacheCreateInfo *ptr() { return reinterpret_cast<VkPipelineCacheCreateInfo *>(this); }
    407     VkPipelineCacheCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineCacheCreateInfo const *>(this); }
    408 };
    409 
    410 struct safe_VkSpecializationInfo {
    411     uint32_t mapEntryCount;
    412     const VkSpecializationMapEntry* pMapEntries;
    413     size_t dataSize;
    414     const void* pData;
    415     safe_VkSpecializationInfo(const VkSpecializationInfo* pInStruct);
    416     safe_VkSpecializationInfo(const safe_VkSpecializationInfo& src);
    417     safe_VkSpecializationInfo();
    418     ~safe_VkSpecializationInfo();
    419     void initialize(const VkSpecializationInfo* pInStruct);
    420     void initialize(const safe_VkSpecializationInfo* src);
    421     VkSpecializationInfo *ptr() { return reinterpret_cast<VkSpecializationInfo *>(this); }
    422     VkSpecializationInfo const *ptr() const { return reinterpret_cast<VkSpecializationInfo const *>(this); }
    423 };
    424 
    425 struct safe_VkPipelineShaderStageCreateInfo {
    426     VkStructureType sType;
    427     const void* pNext;
    428     VkPipelineShaderStageCreateFlags flags;
    429     VkShaderStageFlagBits stage;
    430     VkShaderModule module;
    431     const char* pName;
    432     safe_VkSpecializationInfo* pSpecializationInfo;
    433     safe_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo* pInStruct);
    434     safe_VkPipelineShaderStageCreateInfo(const safe_VkPipelineShaderStageCreateInfo& src);
    435     safe_VkPipelineShaderStageCreateInfo();
    436     ~safe_VkPipelineShaderStageCreateInfo();
    437     void initialize(const VkPipelineShaderStageCreateInfo* pInStruct);
    438     void initialize(const safe_VkPipelineShaderStageCreateInfo* src);
    439     VkPipelineShaderStageCreateInfo *ptr() { return reinterpret_cast<VkPipelineShaderStageCreateInfo *>(this); }
    440     VkPipelineShaderStageCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineShaderStageCreateInfo const *>(this); }
    441 };
    442 
    443 struct safe_VkPipelineVertexInputStateCreateInfo {
    444     VkStructureType sType;
    445     const void* pNext;
    446     VkPipelineVertexInputStateCreateFlags flags;
    447     uint32_t vertexBindingDescriptionCount;
    448     const VkVertexInputBindingDescription* pVertexBindingDescriptions;
    449     uint32_t vertexAttributeDescriptionCount;
    450     const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
    451     safe_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo* pInStruct);
    452     safe_VkPipelineVertexInputStateCreateInfo(const safe_VkPipelineVertexInputStateCreateInfo& src);
    453     safe_VkPipelineVertexInputStateCreateInfo();
    454     ~safe_VkPipelineVertexInputStateCreateInfo();
    455     void initialize(const VkPipelineVertexInputStateCreateInfo* pInStruct);
    456     void initialize(const safe_VkPipelineVertexInputStateCreateInfo* src);
    457     VkPipelineVertexInputStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineVertexInputStateCreateInfo *>(this); }
    458     VkPipelineVertexInputStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineVertexInputStateCreateInfo const *>(this); }
    459 };
    460 
    461 struct safe_VkPipelineInputAssemblyStateCreateInfo {
    462     VkStructureType sType;
    463     const void* pNext;
    464     VkPipelineInputAssemblyStateCreateFlags flags;
    465     VkPrimitiveTopology topology;
    466     VkBool32 primitiveRestartEnable;
    467     safe_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo* pInStruct);
    468     safe_VkPipelineInputAssemblyStateCreateInfo(const safe_VkPipelineInputAssemblyStateCreateInfo& src);
    469     safe_VkPipelineInputAssemblyStateCreateInfo();
    470     ~safe_VkPipelineInputAssemblyStateCreateInfo();
    471     void initialize(const VkPipelineInputAssemblyStateCreateInfo* pInStruct);
    472     void initialize(const safe_VkPipelineInputAssemblyStateCreateInfo* src);
    473     VkPipelineInputAssemblyStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo *>(this); }
    474     VkPipelineInputAssemblyStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo const *>(this); }
    475 };
    476 
    477 struct safe_VkPipelineTessellationStateCreateInfo {
    478     VkStructureType sType;
    479     const void* pNext;
    480     VkPipelineTessellationStateCreateFlags flags;
    481     uint32_t patchControlPoints;
    482     safe_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo* pInStruct);
    483     safe_VkPipelineTessellationStateCreateInfo(const safe_VkPipelineTessellationStateCreateInfo& src);
    484     safe_VkPipelineTessellationStateCreateInfo();
    485     ~safe_VkPipelineTessellationStateCreateInfo();
    486     void initialize(const VkPipelineTessellationStateCreateInfo* pInStruct);
    487     void initialize(const safe_VkPipelineTessellationStateCreateInfo* src);
    488     VkPipelineTessellationStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineTessellationStateCreateInfo *>(this); }
    489     VkPipelineTessellationStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineTessellationStateCreateInfo const *>(this); }
    490 };
    491 
    492 struct safe_VkPipelineViewportStateCreateInfo {
    493     VkStructureType sType;
    494     const void* pNext;
    495     VkPipelineViewportStateCreateFlags flags;
    496     uint32_t viewportCount;
    497     const VkViewport* pViewports;
    498     uint32_t scissorCount;
    499     const VkRect2D* pScissors;
    500     safe_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo* pInStruct);
    501     safe_VkPipelineViewportStateCreateInfo(const safe_VkPipelineViewportStateCreateInfo& src);
    502     safe_VkPipelineViewportStateCreateInfo();
    503     ~safe_VkPipelineViewportStateCreateInfo();
    504     void initialize(const VkPipelineViewportStateCreateInfo* pInStruct);
    505     void initialize(const safe_VkPipelineViewportStateCreateInfo* src);
    506     VkPipelineViewportStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineViewportStateCreateInfo *>(this); }
    507     VkPipelineViewportStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineViewportStateCreateInfo const *>(this); }
    508 };
    509 
    510 struct safe_VkPipelineRasterizationStateCreateInfo {
    511     VkStructureType sType;
    512     const void* pNext;
    513     VkPipelineRasterizationStateCreateFlags flags;
    514     VkBool32 depthClampEnable;
    515     VkBool32 rasterizerDiscardEnable;
    516     VkPolygonMode polygonMode;
    517     VkCullModeFlags cullMode;
    518     VkFrontFace frontFace;
    519     VkBool32 depthBiasEnable;
    520     float depthBiasConstantFactor;
    521     float depthBiasClamp;
    522     float depthBiasSlopeFactor;
    523     float lineWidth;
    524     safe_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo* pInStruct);
    525     safe_VkPipelineRasterizationStateCreateInfo(const safe_VkPipelineRasterizationStateCreateInfo& src);
    526     safe_VkPipelineRasterizationStateCreateInfo();
    527     ~safe_VkPipelineRasterizationStateCreateInfo();
    528     void initialize(const VkPipelineRasterizationStateCreateInfo* pInStruct);
    529     void initialize(const safe_VkPipelineRasterizationStateCreateInfo* src);
    530     VkPipelineRasterizationStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineRasterizationStateCreateInfo *>(this); }
    531     VkPipelineRasterizationStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineRasterizationStateCreateInfo const *>(this); }
    532 };
    533 
    534 struct safe_VkPipelineMultisampleStateCreateInfo {
    535     VkStructureType sType;
    536     const void* pNext;
    537     VkPipelineMultisampleStateCreateFlags flags;
    538     VkSampleCountFlagBits rasterizationSamples;
    539     VkBool32 sampleShadingEnable;
    540     float minSampleShading;
    541     const VkSampleMask* pSampleMask;
    542     VkBool32 alphaToCoverageEnable;
    543     VkBool32 alphaToOneEnable;
    544     safe_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo* pInStruct);
    545     safe_VkPipelineMultisampleStateCreateInfo(const safe_VkPipelineMultisampleStateCreateInfo& src);
    546     safe_VkPipelineMultisampleStateCreateInfo();
    547     ~safe_VkPipelineMultisampleStateCreateInfo();
    548     void initialize(const VkPipelineMultisampleStateCreateInfo* pInStruct);
    549     void initialize(const safe_VkPipelineMultisampleStateCreateInfo* src);
    550     VkPipelineMultisampleStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineMultisampleStateCreateInfo *>(this); }
    551     VkPipelineMultisampleStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineMultisampleStateCreateInfo const *>(this); }
    552 };
    553 
    554 struct safe_VkPipelineDepthStencilStateCreateInfo {
    555     VkStructureType sType;
    556     const void* pNext;
    557     VkPipelineDepthStencilStateCreateFlags flags;
    558     VkBool32 depthTestEnable;
    559     VkBool32 depthWriteEnable;
    560     VkCompareOp depthCompareOp;
    561     VkBool32 depthBoundsTestEnable;
    562     VkBool32 stencilTestEnable;
    563     VkStencilOpState front;
    564     VkStencilOpState back;
    565     float minDepthBounds;
    566     float maxDepthBounds;
    567     safe_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo* pInStruct);
    568     safe_VkPipelineDepthStencilStateCreateInfo(const safe_VkPipelineDepthStencilStateCreateInfo& src);
    569     safe_VkPipelineDepthStencilStateCreateInfo();
    570     ~safe_VkPipelineDepthStencilStateCreateInfo();
    571     void initialize(const VkPipelineDepthStencilStateCreateInfo* pInStruct);
    572     void initialize(const safe_VkPipelineDepthStencilStateCreateInfo* src);
    573     VkPipelineDepthStencilStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo *>(this); }
    574     VkPipelineDepthStencilStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo const *>(this); }
    575 };
    576 
    577 struct safe_VkPipelineDynamicStateCreateInfo {
    578     VkStructureType sType;
    579     const void* pNext;
    580     VkPipelineDynamicStateCreateFlags flags;
    581     uint32_t dynamicStateCount;
    582     const VkDynamicState* pDynamicStates;
    583     safe_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* pInStruct);
    584     safe_VkPipelineDynamicStateCreateInfo(const safe_VkPipelineDynamicStateCreateInfo& src);
    585     safe_VkPipelineDynamicStateCreateInfo();
    586     ~safe_VkPipelineDynamicStateCreateInfo();
    587     void initialize(const VkPipelineDynamicStateCreateInfo* pInStruct);
    588     void initialize(const safe_VkPipelineDynamicStateCreateInfo* src);
    589     VkPipelineDynamicStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineDynamicStateCreateInfo *>(this); }
    590     VkPipelineDynamicStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineDynamicStateCreateInfo const *>(this); }
    591 };
    592 
    593 struct safe_VkGraphicsPipelineCreateInfo {
    594     VkStructureType sType;
    595     const void* pNext;
    596     VkPipelineCreateFlags flags;
    597     uint32_t stageCount;
    598     safe_VkPipelineShaderStageCreateInfo* pStages;
    599     safe_VkPipelineVertexInputStateCreateInfo* pVertexInputState;
    600     safe_VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
    601     safe_VkPipelineTessellationStateCreateInfo* pTessellationState;
    602     safe_VkPipelineViewportStateCreateInfo* pViewportState;
    603     safe_VkPipelineRasterizationStateCreateInfo* pRasterizationState;
    604     safe_VkPipelineMultisampleStateCreateInfo* pMultisampleState;
    605     safe_VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
    606     const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
    607     safe_VkPipelineDynamicStateCreateInfo* pDynamicState;
    608     VkPipelineLayout layout;
    609     VkRenderPass renderPass;
    610     uint32_t subpass;
    611     VkPipeline basePipelineHandle;
    612     int32_t basePipelineIndex;
    613     safe_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo* pInStruct);
    614     safe_VkGraphicsPipelineCreateInfo(const safe_VkGraphicsPipelineCreateInfo& src);
    615     safe_VkGraphicsPipelineCreateInfo();
    616     ~safe_VkGraphicsPipelineCreateInfo();
    617     void initialize(const VkGraphicsPipelineCreateInfo* pInStruct);
    618     void initialize(const safe_VkGraphicsPipelineCreateInfo* src);
    619     VkGraphicsPipelineCreateInfo *ptr() { return reinterpret_cast<VkGraphicsPipelineCreateInfo *>(this); }
    620     VkGraphicsPipelineCreateInfo const *ptr() const { return reinterpret_cast<VkGraphicsPipelineCreateInfo const *>(this); }
    621 };
    622 
    623 struct safe_VkComputePipelineCreateInfo {
    624     VkStructureType sType;
    625     const void* pNext;
    626     VkPipelineCreateFlags flags;
    627     safe_VkPipelineShaderStageCreateInfo stage;
    628     VkPipelineLayout layout;
    629     VkPipeline basePipelineHandle;
    630     int32_t basePipelineIndex;
    631     safe_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo* pInStruct);
    632     safe_VkComputePipelineCreateInfo(const safe_VkComputePipelineCreateInfo& src);
    633     safe_VkComputePipelineCreateInfo();
    634     ~safe_VkComputePipelineCreateInfo();
    635     void initialize(const VkComputePipelineCreateInfo* pInStruct);
    636     void initialize(const safe_VkComputePipelineCreateInfo* src);
    637     VkComputePipelineCreateInfo *ptr() { return reinterpret_cast<VkComputePipelineCreateInfo *>(this); }
    638     VkComputePipelineCreateInfo const *ptr() const { return reinterpret_cast<VkComputePipelineCreateInfo const *>(this); }
    639 };
    640 
    641 struct safe_VkPipelineLayoutCreateInfo {
    642     VkStructureType sType;
    643     const void* pNext;
    644     VkPipelineLayoutCreateFlags flags;
    645     uint32_t setLayoutCount;
    646     VkDescriptorSetLayout* pSetLayouts;
    647     uint32_t pushConstantRangeCount;
    648     const VkPushConstantRange* pPushConstantRanges;
    649     safe_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo* pInStruct);
    650     safe_VkPipelineLayoutCreateInfo(const safe_VkPipelineLayoutCreateInfo& src);
    651     safe_VkPipelineLayoutCreateInfo();
    652     ~safe_VkPipelineLayoutCreateInfo();
    653     void initialize(const VkPipelineLayoutCreateInfo* pInStruct);
    654     void initialize(const safe_VkPipelineLayoutCreateInfo* src);
    655     VkPipelineLayoutCreateInfo *ptr() { return reinterpret_cast<VkPipelineLayoutCreateInfo *>(this); }
    656     VkPipelineLayoutCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineLayoutCreateInfo const *>(this); }
    657 };
    658 
    659 struct safe_VkSamplerCreateInfo {
    660     VkStructureType sType;
    661     const void* pNext;
    662     VkSamplerCreateFlags flags;
    663     VkFilter magFilter;
    664     VkFilter minFilter;
    665     VkSamplerMipmapMode mipmapMode;
    666     VkSamplerAddressMode addressModeU;
    667     VkSamplerAddressMode addressModeV;
    668     VkSamplerAddressMode addressModeW;
    669     float mipLodBias;
    670     VkBool32 anisotropyEnable;
    671     float maxAnisotropy;
    672     VkBool32 compareEnable;
    673     VkCompareOp compareOp;
    674     float minLod;
    675     float maxLod;
    676     VkBorderColor borderColor;
    677     VkBool32 unnormalizedCoordinates;
    678     safe_VkSamplerCreateInfo(const VkSamplerCreateInfo* pInStruct);
    679     safe_VkSamplerCreateInfo(const safe_VkSamplerCreateInfo& src);
    680     safe_VkSamplerCreateInfo();
    681     ~safe_VkSamplerCreateInfo();
    682     void initialize(const VkSamplerCreateInfo* pInStruct);
    683     void initialize(const safe_VkSamplerCreateInfo* src);
    684     VkSamplerCreateInfo *ptr() { return reinterpret_cast<VkSamplerCreateInfo *>(this); }
    685     VkSamplerCreateInfo const *ptr() const { return reinterpret_cast<VkSamplerCreateInfo const *>(this); }
    686 };
    687 
    688 struct safe_VkDescriptorSetLayoutBinding {
    689     uint32_t binding;
    690     VkDescriptorType descriptorType;
    691     uint32_t descriptorCount;
    692     VkShaderStageFlags stageFlags;
    693     VkSampler* pImmutableSamplers;
    694     safe_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding* pInStruct);
    695     safe_VkDescriptorSetLayoutBinding(const safe_VkDescriptorSetLayoutBinding& src);
    696     safe_VkDescriptorSetLayoutBinding();
    697     ~safe_VkDescriptorSetLayoutBinding();
    698     void initialize(const VkDescriptorSetLayoutBinding* pInStruct);
    699     void initialize(const safe_VkDescriptorSetLayoutBinding* src);
    700     VkDescriptorSetLayoutBinding *ptr() { return reinterpret_cast<VkDescriptorSetLayoutBinding *>(this); }
    701     VkDescriptorSetLayoutBinding const *ptr() const { return reinterpret_cast<VkDescriptorSetLayoutBinding const *>(this); }
    702 };
    703 
    704 struct safe_VkDescriptorSetLayoutCreateInfo {
    705     VkStructureType sType;
    706     const void* pNext;
    707     VkDescriptorSetLayoutCreateFlags flags;
    708     uint32_t bindingCount;
    709     safe_VkDescriptorSetLayoutBinding* pBindings;
    710     safe_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo* pInStruct);
    711     safe_VkDescriptorSetLayoutCreateInfo(const safe_VkDescriptorSetLayoutCreateInfo& src);
    712     safe_VkDescriptorSetLayoutCreateInfo();
    713     ~safe_VkDescriptorSetLayoutCreateInfo();
    714     void initialize(const VkDescriptorSetLayoutCreateInfo* pInStruct);
    715     void initialize(const safe_VkDescriptorSetLayoutCreateInfo* src);
    716     VkDescriptorSetLayoutCreateInfo *ptr() { return reinterpret_cast<VkDescriptorSetLayoutCreateInfo *>(this); }
    717     VkDescriptorSetLayoutCreateInfo const *ptr() const { return reinterpret_cast<VkDescriptorSetLayoutCreateInfo const *>(this); }
    718 };
    719 
    720 struct safe_VkDescriptorPoolCreateInfo {
    721     VkStructureType sType;
    722     const void* pNext;
    723     VkDescriptorPoolCreateFlags flags;
    724     uint32_t maxSets;
    725     uint32_t poolSizeCount;
    726     const VkDescriptorPoolSize* pPoolSizes;
    727     safe_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo* pInStruct);
    728     safe_VkDescriptorPoolCreateInfo(const safe_VkDescriptorPoolCreateInfo& src);
    729     safe_VkDescriptorPoolCreateInfo();
    730     ~safe_VkDescriptorPoolCreateInfo();
    731     void initialize(const VkDescriptorPoolCreateInfo* pInStruct);
    732     void initialize(const safe_VkDescriptorPoolCreateInfo* src);
    733     VkDescriptorPoolCreateInfo *ptr() { return reinterpret_cast<VkDescriptorPoolCreateInfo *>(this); }
    734     VkDescriptorPoolCreateInfo const *ptr() const { return reinterpret_cast<VkDescriptorPoolCreateInfo const *>(this); }
    735 };
    736 
    737 struct safe_VkDescriptorSetAllocateInfo {
    738     VkStructureType sType;
    739     const void* pNext;
    740     VkDescriptorPool descriptorPool;
    741     uint32_t descriptorSetCount;
    742     VkDescriptorSetLayout* pSetLayouts;
    743     safe_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo* pInStruct);
    744     safe_VkDescriptorSetAllocateInfo(const safe_VkDescriptorSetAllocateInfo& src);
    745     safe_VkDescriptorSetAllocateInfo();
    746     ~safe_VkDescriptorSetAllocateInfo();
    747     void initialize(const VkDescriptorSetAllocateInfo* pInStruct);
    748     void initialize(const safe_VkDescriptorSetAllocateInfo* src);
    749     VkDescriptorSetAllocateInfo *ptr() { return reinterpret_cast<VkDescriptorSetAllocateInfo *>(this); }
    750     VkDescriptorSetAllocateInfo const *ptr() const { return reinterpret_cast<VkDescriptorSetAllocateInfo const *>(this); }
    751 };
    752 
    753 struct safe_VkWriteDescriptorSet {
    754     VkStructureType sType;
    755     const void* pNext;
    756     VkDescriptorSet dstSet;
    757     uint32_t dstBinding;
    758     uint32_t dstArrayElement;
    759     uint32_t descriptorCount;
    760     VkDescriptorType descriptorType;
    761     VkDescriptorImageInfo* pImageInfo;
    762     VkDescriptorBufferInfo* pBufferInfo;
    763     VkBufferView* pTexelBufferView;
    764     safe_VkWriteDescriptorSet(const VkWriteDescriptorSet* pInStruct);
    765     safe_VkWriteDescriptorSet(const safe_VkWriteDescriptorSet& src);
    766     safe_VkWriteDescriptorSet();
    767     ~safe_VkWriteDescriptorSet();
    768     void initialize(const VkWriteDescriptorSet* pInStruct);
    769     void initialize(const safe_VkWriteDescriptorSet* src);
    770     VkWriteDescriptorSet *ptr() { return reinterpret_cast<VkWriteDescriptorSet *>(this); }
    771     VkWriteDescriptorSet const *ptr() const { return reinterpret_cast<VkWriteDescriptorSet const *>(this); }
    772 };
    773 
    774 struct safe_VkCopyDescriptorSet {
    775     VkStructureType sType;
    776     const void* pNext;
    777     VkDescriptorSet srcSet;
    778     uint32_t srcBinding;
    779     uint32_t srcArrayElement;
    780     VkDescriptorSet dstSet;
    781     uint32_t dstBinding;
    782     uint32_t dstArrayElement;
    783     uint32_t descriptorCount;
    784     safe_VkCopyDescriptorSet(const VkCopyDescriptorSet* pInStruct);
    785     safe_VkCopyDescriptorSet(const safe_VkCopyDescriptorSet& src);
    786     safe_VkCopyDescriptorSet();
    787     ~safe_VkCopyDescriptorSet();
    788     void initialize(const VkCopyDescriptorSet* pInStruct);
    789     void initialize(const safe_VkCopyDescriptorSet* src);
    790     VkCopyDescriptorSet *ptr() { return reinterpret_cast<VkCopyDescriptorSet *>(this); }
    791     VkCopyDescriptorSet const *ptr() const { return reinterpret_cast<VkCopyDescriptorSet const *>(this); }
    792 };
    793 
    794 struct safe_VkFramebufferCreateInfo {
    795     VkStructureType sType;
    796     const void* pNext;
    797     VkFramebufferCreateFlags flags;
    798     VkRenderPass renderPass;
    799     uint32_t attachmentCount;
    800     VkImageView* pAttachments;
    801     uint32_t width;
    802     uint32_t height;
    803     uint32_t layers;
    804     safe_VkFramebufferCreateInfo(const VkFramebufferCreateInfo* pInStruct);
    805     safe_VkFramebufferCreateInfo(const safe_VkFramebufferCreateInfo& src);
    806     safe_VkFramebufferCreateInfo();
    807     ~safe_VkFramebufferCreateInfo();
    808     void initialize(const VkFramebufferCreateInfo* pInStruct);
    809     void initialize(const safe_VkFramebufferCreateInfo* src);
    810     VkFramebufferCreateInfo *ptr() { return reinterpret_cast<VkFramebufferCreateInfo *>(this); }
    811     VkFramebufferCreateInfo const *ptr() const { return reinterpret_cast<VkFramebufferCreateInfo const *>(this); }
    812 };
    813 
    814 struct safe_VkSubpassDescription {
    815     VkSubpassDescriptionFlags flags;
    816     VkPipelineBindPoint pipelineBindPoint;
    817     uint32_t inputAttachmentCount;
    818     const VkAttachmentReference* pInputAttachments;
    819     uint32_t colorAttachmentCount;
    820     const VkAttachmentReference* pColorAttachments;
    821     const VkAttachmentReference* pResolveAttachments;
    822     const VkAttachmentReference* pDepthStencilAttachment;
    823     uint32_t preserveAttachmentCount;
    824     const uint32_t* pPreserveAttachments;
    825     safe_VkSubpassDescription(const VkSubpassDescription* pInStruct);
    826     safe_VkSubpassDescription(const safe_VkSubpassDescription& src);
    827     safe_VkSubpassDescription();
    828     ~safe_VkSubpassDescription();
    829     void initialize(const VkSubpassDescription* pInStruct);
    830     void initialize(const safe_VkSubpassDescription* src);
    831     VkSubpassDescription *ptr() { return reinterpret_cast<VkSubpassDescription *>(this); }
    832     VkSubpassDescription const *ptr() const { return reinterpret_cast<VkSubpassDescription const *>(this); }
    833 };
    834 
    835 struct safe_VkRenderPassCreateInfo {
    836     VkStructureType sType;
    837     const void* pNext;
    838     VkRenderPassCreateFlags flags;
    839     uint32_t attachmentCount;
    840     const VkAttachmentDescription* pAttachments;
    841     uint32_t subpassCount;
    842     safe_VkSubpassDescription* pSubpasses;
    843     uint32_t dependencyCount;
    844     const VkSubpassDependency* pDependencies;
    845     safe_VkRenderPassCreateInfo(const VkRenderPassCreateInfo* pInStruct);
    846     safe_VkRenderPassCreateInfo(const safe_VkRenderPassCreateInfo& src);
    847     safe_VkRenderPassCreateInfo();
    848     ~safe_VkRenderPassCreateInfo();
    849     void initialize(const VkRenderPassCreateInfo* pInStruct);
    850     void initialize(const safe_VkRenderPassCreateInfo* src);
    851     VkRenderPassCreateInfo *ptr() { return reinterpret_cast<VkRenderPassCreateInfo *>(this); }
    852     VkRenderPassCreateInfo const *ptr() const { return reinterpret_cast<VkRenderPassCreateInfo const *>(this); }
    853 };
    854 
    855 struct safe_VkCommandPoolCreateInfo {
    856     VkStructureType sType;
    857     const void* pNext;
    858     VkCommandPoolCreateFlags flags;
    859     uint32_t queueFamilyIndex;
    860     safe_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo* pInStruct);
    861     safe_VkCommandPoolCreateInfo(const safe_VkCommandPoolCreateInfo& src);
    862     safe_VkCommandPoolCreateInfo();
    863     ~safe_VkCommandPoolCreateInfo();
    864     void initialize(const VkCommandPoolCreateInfo* pInStruct);
    865     void initialize(const safe_VkCommandPoolCreateInfo* src);
    866     VkCommandPoolCreateInfo *ptr() { return reinterpret_cast<VkCommandPoolCreateInfo *>(this); }
    867     VkCommandPoolCreateInfo const *ptr() const { return reinterpret_cast<VkCommandPoolCreateInfo const *>(this); }
    868 };
    869 
    870 struct safe_VkCommandBufferAllocateInfo {
    871     VkStructureType sType;
    872     const void* pNext;
    873     VkCommandPool commandPool;
    874     VkCommandBufferLevel level;
    875     uint32_t commandBufferCount;
    876     safe_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo* pInStruct);
    877     safe_VkCommandBufferAllocateInfo(const safe_VkCommandBufferAllocateInfo& src);
    878     safe_VkCommandBufferAllocateInfo();
    879     ~safe_VkCommandBufferAllocateInfo();
    880     void initialize(const VkCommandBufferAllocateInfo* pInStruct);
    881     void initialize(const safe_VkCommandBufferAllocateInfo* src);
    882     VkCommandBufferAllocateInfo *ptr() { return reinterpret_cast<VkCommandBufferAllocateInfo *>(this); }
    883     VkCommandBufferAllocateInfo const *ptr() const { return reinterpret_cast<VkCommandBufferAllocateInfo const *>(this); }
    884 };
    885 
    886 struct safe_VkCommandBufferInheritanceInfo {
    887     VkStructureType sType;
    888     const void* pNext;
    889     VkRenderPass renderPass;
    890     uint32_t subpass;
    891     VkFramebuffer framebuffer;
    892     VkBool32 occlusionQueryEnable;
    893     VkQueryControlFlags queryFlags;
    894     VkQueryPipelineStatisticFlags pipelineStatistics;
    895     safe_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo* pInStruct);
    896     safe_VkCommandBufferInheritanceInfo(const safe_VkCommandBufferInheritanceInfo& src);
    897     safe_VkCommandBufferInheritanceInfo();
    898     ~safe_VkCommandBufferInheritanceInfo();
    899     void initialize(const VkCommandBufferInheritanceInfo* pInStruct);
    900     void initialize(const safe_VkCommandBufferInheritanceInfo* src);
    901     VkCommandBufferInheritanceInfo *ptr() { return reinterpret_cast<VkCommandBufferInheritanceInfo *>(this); }
    902     VkCommandBufferInheritanceInfo const *ptr() const { return reinterpret_cast<VkCommandBufferInheritanceInfo const *>(this); }
    903 };
    904 
    905 struct safe_VkCommandBufferBeginInfo {
    906     VkStructureType sType;
    907     const void* pNext;
    908     VkCommandBufferUsageFlags flags;
    909     safe_VkCommandBufferInheritanceInfo* pInheritanceInfo;
    910     safe_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo* pInStruct);
    911     safe_VkCommandBufferBeginInfo(const safe_VkCommandBufferBeginInfo& src);
    912     safe_VkCommandBufferBeginInfo();
    913     ~safe_VkCommandBufferBeginInfo();
    914     void initialize(const VkCommandBufferBeginInfo* pInStruct);
    915     void initialize(const safe_VkCommandBufferBeginInfo* src);
    916     VkCommandBufferBeginInfo *ptr() { return reinterpret_cast<VkCommandBufferBeginInfo *>(this); }
    917     VkCommandBufferBeginInfo const *ptr() const { return reinterpret_cast<VkCommandBufferBeginInfo const *>(this); }
    918 };
    919 
    920 struct safe_VkMemoryBarrier {
    921     VkStructureType sType;
    922     const void* pNext;
    923     VkAccessFlags srcAccessMask;
    924     VkAccessFlags dstAccessMask;
    925     safe_VkMemoryBarrier(const VkMemoryBarrier* pInStruct);
    926     safe_VkMemoryBarrier(const safe_VkMemoryBarrier& src);
    927     safe_VkMemoryBarrier();
    928     ~safe_VkMemoryBarrier();
    929     void initialize(const VkMemoryBarrier* pInStruct);
    930     void initialize(const safe_VkMemoryBarrier* src);
    931     VkMemoryBarrier *ptr() { return reinterpret_cast<VkMemoryBarrier *>(this); }
    932     VkMemoryBarrier const *ptr() const { return reinterpret_cast<VkMemoryBarrier const *>(this); }
    933 };
    934 
    935 struct safe_VkBufferMemoryBarrier {
    936     VkStructureType sType;
    937     const void* pNext;
    938     VkAccessFlags srcAccessMask;
    939     VkAccessFlags dstAccessMask;
    940     uint32_t srcQueueFamilyIndex;
    941     uint32_t dstQueueFamilyIndex;
    942     VkBuffer buffer;
    943     VkDeviceSize offset;
    944     VkDeviceSize size;
    945     safe_VkBufferMemoryBarrier(const VkBufferMemoryBarrier* pInStruct);
    946     safe_VkBufferMemoryBarrier(const safe_VkBufferMemoryBarrier& src);
    947     safe_VkBufferMemoryBarrier();
    948     ~safe_VkBufferMemoryBarrier();
    949     void initialize(const VkBufferMemoryBarrier* pInStruct);
    950     void initialize(const safe_VkBufferMemoryBarrier* src);
    951     VkBufferMemoryBarrier *ptr() { return reinterpret_cast<VkBufferMemoryBarrier *>(this); }
    952     VkBufferMemoryBarrier const *ptr() const { return reinterpret_cast<VkBufferMemoryBarrier const *>(this); }
    953 };
    954 
    955 struct safe_VkImageMemoryBarrier {
    956     VkStructureType sType;
    957     const void* pNext;
    958     VkAccessFlags srcAccessMask;
    959     VkAccessFlags dstAccessMask;
    960     VkImageLayout oldLayout;
    961     VkImageLayout newLayout;
    962     uint32_t srcQueueFamilyIndex;
    963     uint32_t dstQueueFamilyIndex;
    964     VkImage image;
    965     VkImageSubresourceRange subresourceRange;
    966     safe_VkImageMemoryBarrier(const VkImageMemoryBarrier* pInStruct);
    967     safe_VkImageMemoryBarrier(const safe_VkImageMemoryBarrier& src);
    968     safe_VkImageMemoryBarrier();
    969     ~safe_VkImageMemoryBarrier();
    970     void initialize(const VkImageMemoryBarrier* pInStruct);
    971     void initialize(const safe_VkImageMemoryBarrier* src);
    972     VkImageMemoryBarrier *ptr() { return reinterpret_cast<VkImageMemoryBarrier *>(this); }
    973     VkImageMemoryBarrier const *ptr() const { return reinterpret_cast<VkImageMemoryBarrier const *>(this); }
    974 };
    975 
    976 struct safe_VkRenderPassBeginInfo {
    977     VkStructureType sType;
    978     const void* pNext;
    979     VkRenderPass renderPass;
    980     VkFramebuffer framebuffer;
    981     VkRect2D renderArea;
    982     uint32_t clearValueCount;
    983     const VkClearValue* pClearValues;
    984     safe_VkRenderPassBeginInfo(const VkRenderPassBeginInfo* pInStruct);
    985     safe_VkRenderPassBeginInfo(const safe_VkRenderPassBeginInfo& src);
    986     safe_VkRenderPassBeginInfo();
    987     ~safe_VkRenderPassBeginInfo();
    988     void initialize(const VkRenderPassBeginInfo* pInStruct);
    989     void initialize(const safe_VkRenderPassBeginInfo* src);
    990     VkRenderPassBeginInfo *ptr() { return reinterpret_cast<VkRenderPassBeginInfo *>(this); }
    991     VkRenderPassBeginInfo const *ptr() const { return reinterpret_cast<VkRenderPassBeginInfo const *>(this); }
    992 };
    993 
    994 struct safe_VkSwapchainCreateInfoKHR {
    995     VkStructureType sType;
    996     const void* pNext;
    997     VkSwapchainCreateFlagsKHR flags;
    998     VkSurfaceKHR surface;
    999     uint32_t minImageCount;
   1000     VkFormat imageFormat;
   1001     VkColorSpaceKHR imageColorSpace;
   1002     VkExtent2D imageExtent;
   1003     uint32_t imageArrayLayers;
   1004     VkImageUsageFlags imageUsage;
   1005     VkSharingMode imageSharingMode;
   1006     uint32_t queueFamilyIndexCount;
   1007     const uint32_t* pQueueFamilyIndices;
   1008     VkSurfaceTransformFlagBitsKHR preTransform;
   1009     VkCompositeAlphaFlagBitsKHR compositeAlpha;
   1010     VkPresentModeKHR presentMode;
   1011     VkBool32 clipped;
   1012     VkSwapchainKHR oldSwapchain;
   1013     safe_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR* pInStruct);
   1014     safe_VkSwapchainCreateInfoKHR(const safe_VkSwapchainCreateInfoKHR& src);
   1015     safe_VkSwapchainCreateInfoKHR();
   1016     ~safe_VkSwapchainCreateInfoKHR();
   1017     void initialize(const VkSwapchainCreateInfoKHR* pInStruct);
   1018     void initialize(const safe_VkSwapchainCreateInfoKHR* src);
   1019     VkSwapchainCreateInfoKHR *ptr() { return reinterpret_cast<VkSwapchainCreateInfoKHR *>(this); }
   1020     VkSwapchainCreateInfoKHR const *ptr() const { return reinterpret_cast<VkSwapchainCreateInfoKHR const *>(this); }
   1021 };
   1022 
   1023 struct safe_VkPresentInfoKHR {
   1024     VkStructureType sType;
   1025     const void* pNext;
   1026     uint32_t waitSemaphoreCount;
   1027     VkSemaphore* pWaitSemaphores;
   1028     uint32_t swapchainCount;
   1029     VkSwapchainKHR* pSwapchains;
   1030     const uint32_t* pImageIndices;
   1031     VkResult* pResults;
   1032     safe_VkPresentInfoKHR(const VkPresentInfoKHR* pInStruct);
   1033     safe_VkPresentInfoKHR(const safe_VkPresentInfoKHR& src);
   1034     safe_VkPresentInfoKHR();
   1035     ~safe_VkPresentInfoKHR();
   1036     void initialize(const VkPresentInfoKHR* pInStruct);
   1037     void initialize(const safe_VkPresentInfoKHR* src);
   1038     VkPresentInfoKHR *ptr() { return reinterpret_cast<VkPresentInfoKHR *>(this); }
   1039     VkPresentInfoKHR const *ptr() const { return reinterpret_cast<VkPresentInfoKHR const *>(this); }
   1040 };
   1041 
   1042 struct safe_VkDisplayPropertiesKHR {
   1043     VkDisplayKHR display;
   1044     const char* displayName;
   1045     VkExtent2D physicalDimensions;
   1046     VkExtent2D physicalResolution;
   1047     VkSurfaceTransformFlagsKHR supportedTransforms;
   1048     VkBool32 planeReorderPossible;
   1049     VkBool32 persistentContent;
   1050     safe_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR* pInStruct);
   1051     safe_VkDisplayPropertiesKHR(const safe_VkDisplayPropertiesKHR& src);
   1052     safe_VkDisplayPropertiesKHR();
   1053     ~safe_VkDisplayPropertiesKHR();
   1054     void initialize(const VkDisplayPropertiesKHR* pInStruct);
   1055     void initialize(const safe_VkDisplayPropertiesKHR* src);
   1056     VkDisplayPropertiesKHR *ptr() { return reinterpret_cast<VkDisplayPropertiesKHR *>(this); }
   1057     VkDisplayPropertiesKHR const *ptr() const { return reinterpret_cast<VkDisplayPropertiesKHR const *>(this); }
   1058 };
   1059 
   1060 struct safe_VkDisplayModeCreateInfoKHR {
   1061     VkStructureType sType;
   1062     const void* pNext;
   1063     VkDisplayModeCreateFlagsKHR flags;
   1064     VkDisplayModeParametersKHR parameters;
   1065     safe_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR* pInStruct);
   1066     safe_VkDisplayModeCreateInfoKHR(const safe_VkDisplayModeCreateInfoKHR& src);
   1067     safe_VkDisplayModeCreateInfoKHR();
   1068     ~safe_VkDisplayModeCreateInfoKHR();
   1069     void initialize(const VkDisplayModeCreateInfoKHR* pInStruct);
   1070     void initialize(const safe_VkDisplayModeCreateInfoKHR* src);
   1071     VkDisplayModeCreateInfoKHR *ptr() { return reinterpret_cast<VkDisplayModeCreateInfoKHR *>(this); }
   1072     VkDisplayModeCreateInfoKHR const *ptr() const { return reinterpret_cast<VkDisplayModeCreateInfoKHR const *>(this); }
   1073 };
   1074 
   1075 struct safe_VkDisplaySurfaceCreateInfoKHR {
   1076     VkStructureType sType;
   1077     const void* pNext;
   1078     VkDisplaySurfaceCreateFlagsKHR flags;
   1079     VkDisplayModeKHR displayMode;
   1080     uint32_t planeIndex;
   1081     uint32_t planeStackIndex;
   1082     VkSurfaceTransformFlagBitsKHR transform;
   1083     float globalAlpha;
   1084     VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
   1085     VkExtent2D imageExtent;
   1086     safe_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR* pInStruct);
   1087     safe_VkDisplaySurfaceCreateInfoKHR(const safe_VkDisplaySurfaceCreateInfoKHR& src);
   1088     safe_VkDisplaySurfaceCreateInfoKHR();
   1089     ~safe_VkDisplaySurfaceCreateInfoKHR();
   1090     void initialize(const VkDisplaySurfaceCreateInfoKHR* pInStruct);
   1091     void initialize(const safe_VkDisplaySurfaceCreateInfoKHR* src);
   1092     VkDisplaySurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkDisplaySurfaceCreateInfoKHR *>(this); }
   1093     VkDisplaySurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkDisplaySurfaceCreateInfoKHR const *>(this); }
   1094 };
   1095 
   1096 struct safe_VkDisplayPresentInfoKHR {
   1097     VkStructureType sType;
   1098     const void* pNext;
   1099     VkRect2D srcRect;
   1100     VkRect2D dstRect;
   1101     VkBool32 persistent;
   1102     safe_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR* pInStruct);
   1103     safe_VkDisplayPresentInfoKHR(const safe_VkDisplayPresentInfoKHR& src);
   1104     safe_VkDisplayPresentInfoKHR();
   1105     ~safe_VkDisplayPresentInfoKHR();
   1106     void initialize(const VkDisplayPresentInfoKHR* pInStruct);
   1107     void initialize(const safe_VkDisplayPresentInfoKHR* src);
   1108     VkDisplayPresentInfoKHR *ptr() { return reinterpret_cast<VkDisplayPresentInfoKHR *>(this); }
   1109     VkDisplayPresentInfoKHR const *ptr() const { return reinterpret_cast<VkDisplayPresentInfoKHR const *>(this); }
   1110 };
   1111 #ifdef VK_USE_PLATFORM_XLIB_KHR
   1112 
   1113 struct safe_VkXlibSurfaceCreateInfoKHR {
   1114     VkStructureType sType;
   1115     const void* pNext;
   1116     VkXlibSurfaceCreateFlagsKHR flags;
   1117     Display* dpy;
   1118     Window window;
   1119     safe_VkXlibSurfaceCreateInfoKHR(const VkXlibSurfaceCreateInfoKHR* pInStruct);
   1120     safe_VkXlibSurfaceCreateInfoKHR(const safe_VkXlibSurfaceCreateInfoKHR& src);
   1121     safe_VkXlibSurfaceCreateInfoKHR();
   1122     ~safe_VkXlibSurfaceCreateInfoKHR();
   1123     void initialize(const VkXlibSurfaceCreateInfoKHR* pInStruct);
   1124     void initialize(const safe_VkXlibSurfaceCreateInfoKHR* src);
   1125     VkXlibSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkXlibSurfaceCreateInfoKHR *>(this); }
   1126     VkXlibSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkXlibSurfaceCreateInfoKHR const *>(this); }
   1127 };
   1128 #endif
   1129 #ifdef VK_USE_PLATFORM_XCB_KHR
   1130 
   1131 struct safe_VkXcbSurfaceCreateInfoKHR {
   1132     VkStructureType sType;
   1133     const void* pNext;
   1134     VkXcbSurfaceCreateFlagsKHR flags;
   1135     xcb_connection_t* connection;
   1136     xcb_window_t window;
   1137     safe_VkXcbSurfaceCreateInfoKHR(const VkXcbSurfaceCreateInfoKHR* pInStruct);
   1138     safe_VkXcbSurfaceCreateInfoKHR(const safe_VkXcbSurfaceCreateInfoKHR& src);
   1139     safe_VkXcbSurfaceCreateInfoKHR();
   1140     ~safe_VkXcbSurfaceCreateInfoKHR();
   1141     void initialize(const VkXcbSurfaceCreateInfoKHR* pInStruct);
   1142     void initialize(const safe_VkXcbSurfaceCreateInfoKHR* src);
   1143     VkXcbSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkXcbSurfaceCreateInfoKHR *>(this); }
   1144     VkXcbSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkXcbSurfaceCreateInfoKHR const *>(this); }
   1145 };
   1146 #endif
   1147 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
   1148 
   1149 struct safe_VkWaylandSurfaceCreateInfoKHR {
   1150     VkStructureType sType;
   1151     const void* pNext;
   1152     VkWaylandSurfaceCreateFlagsKHR flags;
   1153     struct wl_display* display;
   1154     struct wl_surface* surface;
   1155     safe_VkWaylandSurfaceCreateInfoKHR(const VkWaylandSurfaceCreateInfoKHR* pInStruct);
   1156     safe_VkWaylandSurfaceCreateInfoKHR(const safe_VkWaylandSurfaceCreateInfoKHR& src);
   1157     safe_VkWaylandSurfaceCreateInfoKHR();
   1158     ~safe_VkWaylandSurfaceCreateInfoKHR();
   1159     void initialize(const VkWaylandSurfaceCreateInfoKHR* pInStruct);
   1160     void initialize(const safe_VkWaylandSurfaceCreateInfoKHR* src);
   1161     VkWaylandSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkWaylandSurfaceCreateInfoKHR *>(this); }
   1162     VkWaylandSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkWaylandSurfaceCreateInfoKHR const *>(this); }
   1163 };
   1164 #endif
   1165 #ifdef VK_USE_PLATFORM_MIR_KHR
   1166 
   1167 struct safe_VkMirSurfaceCreateInfoKHR {
   1168     VkStructureType sType;
   1169     const void* pNext;
   1170     VkMirSurfaceCreateFlagsKHR flags;
   1171     MirConnection* connection;
   1172     MirSurface* mirSurface;
   1173     safe_VkMirSurfaceCreateInfoKHR(const VkMirSurfaceCreateInfoKHR* pInStruct);
   1174     safe_VkMirSurfaceCreateInfoKHR(const safe_VkMirSurfaceCreateInfoKHR& src);
   1175     safe_VkMirSurfaceCreateInfoKHR();
   1176     ~safe_VkMirSurfaceCreateInfoKHR();
   1177     void initialize(const VkMirSurfaceCreateInfoKHR* pInStruct);
   1178     void initialize(const safe_VkMirSurfaceCreateInfoKHR* src);
   1179     VkMirSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkMirSurfaceCreateInfoKHR *>(this); }
   1180     VkMirSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkMirSurfaceCreateInfoKHR const *>(this); }
   1181 };
   1182 #endif
   1183 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   1184 
   1185 struct safe_VkAndroidSurfaceCreateInfoKHR {
   1186     VkStructureType sType;
   1187     const void* pNext;
   1188     VkAndroidSurfaceCreateFlagsKHR flags;
   1189     ANativeWindow* window;
   1190     safe_VkAndroidSurfaceCreateInfoKHR(const VkAndroidSurfaceCreateInfoKHR* pInStruct);
   1191     safe_VkAndroidSurfaceCreateInfoKHR(const safe_VkAndroidSurfaceCreateInfoKHR& src);
   1192     safe_VkAndroidSurfaceCreateInfoKHR();
   1193     ~safe_VkAndroidSurfaceCreateInfoKHR();
   1194     void initialize(const VkAndroidSurfaceCreateInfoKHR* pInStruct);
   1195     void initialize(const safe_VkAndroidSurfaceCreateInfoKHR* src);
   1196     VkAndroidSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkAndroidSurfaceCreateInfoKHR *>(this); }
   1197     VkAndroidSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkAndroidSurfaceCreateInfoKHR const *>(this); }
   1198 };
   1199 #endif
   1200 #ifdef VK_USE_PLATFORM_WIN32_KHR
   1201 
   1202 struct safe_VkWin32SurfaceCreateInfoKHR {
   1203     VkStructureType sType;
   1204     const void* pNext;
   1205     VkWin32SurfaceCreateFlagsKHR flags;
   1206     HINSTANCE hinstance;
   1207     HWND hwnd;
   1208     safe_VkWin32SurfaceCreateInfoKHR(const VkWin32SurfaceCreateInfoKHR* pInStruct);
   1209     safe_VkWin32SurfaceCreateInfoKHR(const safe_VkWin32SurfaceCreateInfoKHR& src);
   1210     safe_VkWin32SurfaceCreateInfoKHR();
   1211     ~safe_VkWin32SurfaceCreateInfoKHR();
   1212     void initialize(const VkWin32SurfaceCreateInfoKHR* pInStruct);
   1213     void initialize(const safe_VkWin32SurfaceCreateInfoKHR* src);
   1214     VkWin32SurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkWin32SurfaceCreateInfoKHR *>(this); }
   1215     VkWin32SurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkWin32SurfaceCreateInfoKHR const *>(this); }
   1216 };
   1217 #endif
   1218 
   1219 struct safe_VkDebugReportCallbackCreateInfoEXT {
   1220     VkStructureType sType;
   1221     const void* pNext;
   1222     VkDebugReportFlagsEXT flags;
   1223     PFN_vkDebugReportCallbackEXT pfnCallback;
   1224     void* pUserData;
   1225     safe_VkDebugReportCallbackCreateInfoEXT(const VkDebugReportCallbackCreateInfoEXT* pInStruct);
   1226     safe_VkDebugReportCallbackCreateInfoEXT(const safe_VkDebugReportCallbackCreateInfoEXT& src);
   1227     safe_VkDebugReportCallbackCreateInfoEXT();
   1228     ~safe_VkDebugReportCallbackCreateInfoEXT();
   1229     void initialize(const VkDebugReportCallbackCreateInfoEXT* pInStruct);
   1230     void initialize(const safe_VkDebugReportCallbackCreateInfoEXT* src);
   1231     VkDebugReportCallbackCreateInfoEXT *ptr() { return reinterpret_cast<VkDebugReportCallbackCreateInfoEXT *>(this); }
   1232     VkDebugReportCallbackCreateInfoEXT const *ptr() const { return reinterpret_cast<VkDebugReportCallbackCreateInfoEXT const *>(this); }
   1233 };
   1234 
   1235 struct safe_VkPipelineRasterizationStateRasterizationOrderAMD {
   1236     VkStructureType sType;
   1237     const void* pNext;
   1238     VkRasterizationOrderAMD rasterizationOrder;
   1239     safe_VkPipelineRasterizationStateRasterizationOrderAMD(const VkPipelineRasterizationStateRasterizationOrderAMD* pInStruct);
   1240     safe_VkPipelineRasterizationStateRasterizationOrderAMD(const safe_VkPipelineRasterizationStateRasterizationOrderAMD& src);
   1241     safe_VkPipelineRasterizationStateRasterizationOrderAMD();
   1242     ~safe_VkPipelineRasterizationStateRasterizationOrderAMD();
   1243     void initialize(const VkPipelineRasterizationStateRasterizationOrderAMD* pInStruct);
   1244     void initialize(const safe_VkPipelineRasterizationStateRasterizationOrderAMD* src);
   1245     VkPipelineRasterizationStateRasterizationOrderAMD *ptr() { return reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD *>(this); }
   1246     VkPipelineRasterizationStateRasterizationOrderAMD const *ptr() const { return reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD const *>(this); }
   1247 };
   1248 
   1249 struct safe_VkDebugMarkerObjectNameInfoEXT {
   1250     VkStructureType sType;
   1251     const void* pNext;
   1252     VkDebugReportObjectTypeEXT objectType;
   1253     uint64_t object;
   1254     const char* pObjectName;
   1255     safe_VkDebugMarkerObjectNameInfoEXT(const VkDebugMarkerObjectNameInfoEXT* pInStruct);
   1256     safe_VkDebugMarkerObjectNameInfoEXT(const safe_VkDebugMarkerObjectNameInfoEXT& src);
   1257     safe_VkDebugMarkerObjectNameInfoEXT();
   1258     ~safe_VkDebugMarkerObjectNameInfoEXT();
   1259     void initialize(const VkDebugMarkerObjectNameInfoEXT* pInStruct);
   1260     void initialize(const safe_VkDebugMarkerObjectNameInfoEXT* src);
   1261     VkDebugMarkerObjectNameInfoEXT *ptr() { return reinterpret_cast<VkDebugMarkerObjectNameInfoEXT *>(this); }
   1262     VkDebugMarkerObjectNameInfoEXT const *ptr() const { return reinterpret_cast<VkDebugMarkerObjectNameInfoEXT const *>(this); }
   1263 };
   1264 
   1265 struct safe_VkDebugMarkerObjectTagInfoEXT {
   1266     VkStructureType sType;
   1267     const void* pNext;
   1268     VkDebugReportObjectTypeEXT objectType;
   1269     uint64_t object;
   1270     uint64_t tagName;
   1271     size_t tagSize;
   1272     const void* pTag;
   1273     safe_VkDebugMarkerObjectTagInfoEXT(const VkDebugMarkerObjectTagInfoEXT* pInStruct);
   1274     safe_VkDebugMarkerObjectTagInfoEXT(const safe_VkDebugMarkerObjectTagInfoEXT& src);
   1275     safe_VkDebugMarkerObjectTagInfoEXT();
   1276     ~safe_VkDebugMarkerObjectTagInfoEXT();
   1277     void initialize(const VkDebugMarkerObjectTagInfoEXT* pInStruct);
   1278     void initialize(const safe_VkDebugMarkerObjectTagInfoEXT* src);
   1279     VkDebugMarkerObjectTagInfoEXT *ptr() { return reinterpret_cast<VkDebugMarkerObjectTagInfoEXT *>(this); }
   1280     VkDebugMarkerObjectTagInfoEXT const *ptr() const { return reinterpret_cast<VkDebugMarkerObjectTagInfoEXT const *>(this); }
   1281 };