1 // *** THIS FILE IS GENERATED - DO NOT EDIT ***
2 // See helper_file_generator.py for modifications
3 
4 
5 /***************************************************************************
6  *
7  * Copyright (c) 2015-2020 The Khronos Group Inc.
8  * Copyright (c) 2015-2020 Valve Corporation
9  * Copyright (c) 2015-2020 LunarG, Inc.
10  * Copyright (c) 2015-2020 Google Inc.
11  *
12  * Licensed under the Apache License, Version 2.0 (the "License");
13  * you may not use this file except in compliance with the License.
14  * You may obtain a copy of the License at
15  *
16  *     http://www.apache.org/licenses/LICENSE-2.0
17  *
18  * Unless required by applicable law or agreed to in writing, software
19  * distributed under the License is distributed on an "AS IS" BASIS,
20  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
21  * See the License for the specific language governing permissions and
22  * limitations under the License.
23  *
24  * Author: Mark Lobodzinski <mark@lunarg.com>
25  * Author: Courtney Goeltzenleuchter <courtneygo@google.com>
26  * Author: Tobin Ehlis <tobine@google.com>
27  * Author: Chris Forbes <chrisforbes@google.com>
28  * Author: John Zulauf<jzulauf@lunarg.com>
29  *
30  ****************************************************************************/
31 
32 
33 #pragma once
34 #include <vulkan/vulkan.h>
35 #include <stdlib.h>
36 
37 void *SafePnextCopy(const void *pNext);
38 void FreePnextChain(const void *pNext);
39 char *SafeStringCopy(const char *in_string);
40 
41 
42 struct safe_VkBufferMemoryBarrier {
43     VkStructureType sType;
44     const void* pNext;
45     VkAccessFlags srcAccessMask;
46     VkAccessFlags dstAccessMask;
47     uint32_t srcQueueFamilyIndex;
48     uint32_t dstQueueFamilyIndex;
49     VkBuffer buffer;
50     VkDeviceSize offset;
51     VkDeviceSize size;
52     safe_VkBufferMemoryBarrier(const VkBufferMemoryBarrier* in_struct);
53     safe_VkBufferMemoryBarrier(const safe_VkBufferMemoryBarrier& copy_src);
54     safe_VkBufferMemoryBarrier& operator=(const safe_VkBufferMemoryBarrier& copy_src);
55     safe_VkBufferMemoryBarrier();
56     ~safe_VkBufferMemoryBarrier();
57     void initialize(const VkBufferMemoryBarrier* in_struct);
58     void initialize(const safe_VkBufferMemoryBarrier* copy_src);
ptrsafe_VkBufferMemoryBarrier59     VkBufferMemoryBarrier *ptr() { return reinterpret_cast<VkBufferMemoryBarrier *>(this); }
ptrsafe_VkBufferMemoryBarrier60     VkBufferMemoryBarrier const *ptr() const { return reinterpret_cast<VkBufferMemoryBarrier const *>(this); }
61 };
62 
63 struct safe_VkImageMemoryBarrier {
64     VkStructureType sType;
65     const void* pNext;
66     VkAccessFlags srcAccessMask;
67     VkAccessFlags dstAccessMask;
68     VkImageLayout oldLayout;
69     VkImageLayout newLayout;
70     uint32_t srcQueueFamilyIndex;
71     uint32_t dstQueueFamilyIndex;
72     VkImage image;
73     VkImageSubresourceRange subresourceRange;
74     safe_VkImageMemoryBarrier(const VkImageMemoryBarrier* in_struct);
75     safe_VkImageMemoryBarrier(const safe_VkImageMemoryBarrier& copy_src);
76     safe_VkImageMemoryBarrier& operator=(const safe_VkImageMemoryBarrier& copy_src);
77     safe_VkImageMemoryBarrier();
78     ~safe_VkImageMemoryBarrier();
79     void initialize(const VkImageMemoryBarrier* in_struct);
80     void initialize(const safe_VkImageMemoryBarrier* copy_src);
ptrsafe_VkImageMemoryBarrier81     VkImageMemoryBarrier *ptr() { return reinterpret_cast<VkImageMemoryBarrier *>(this); }
ptrsafe_VkImageMemoryBarrier82     VkImageMemoryBarrier const *ptr() const { return reinterpret_cast<VkImageMemoryBarrier const *>(this); }
83 };
84 
85 struct safe_VkMemoryBarrier {
86     VkStructureType sType;
87     const void* pNext;
88     VkAccessFlags srcAccessMask;
89     VkAccessFlags dstAccessMask;
90     safe_VkMemoryBarrier(const VkMemoryBarrier* in_struct);
91     safe_VkMemoryBarrier(const safe_VkMemoryBarrier& copy_src);
92     safe_VkMemoryBarrier& operator=(const safe_VkMemoryBarrier& copy_src);
93     safe_VkMemoryBarrier();
94     ~safe_VkMemoryBarrier();
95     void initialize(const VkMemoryBarrier* in_struct);
96     void initialize(const safe_VkMemoryBarrier* copy_src);
ptrsafe_VkMemoryBarrier97     VkMemoryBarrier *ptr() { return reinterpret_cast<VkMemoryBarrier *>(this); }
ptrsafe_VkMemoryBarrier98     VkMemoryBarrier const *ptr() const { return reinterpret_cast<VkMemoryBarrier const *>(this); }
99 };
100 
101 struct safe_VkAllocationCallbacks {
102     void* pUserData;
103     PFN_vkAllocationFunction pfnAllocation;
104     PFN_vkReallocationFunction pfnReallocation;
105     PFN_vkFreeFunction pfnFree;
106     PFN_vkInternalAllocationNotification pfnInternalAllocation;
107     PFN_vkInternalFreeNotification pfnInternalFree;
108     safe_VkAllocationCallbacks(const VkAllocationCallbacks* in_struct);
109     safe_VkAllocationCallbacks(const safe_VkAllocationCallbacks& copy_src);
110     safe_VkAllocationCallbacks& operator=(const safe_VkAllocationCallbacks& copy_src);
111     safe_VkAllocationCallbacks();
112     ~safe_VkAllocationCallbacks();
113     void initialize(const VkAllocationCallbacks* in_struct);
114     void initialize(const safe_VkAllocationCallbacks* copy_src);
ptrsafe_VkAllocationCallbacks115     VkAllocationCallbacks *ptr() { return reinterpret_cast<VkAllocationCallbacks *>(this); }
ptrsafe_VkAllocationCallbacks116     VkAllocationCallbacks const *ptr() const { return reinterpret_cast<VkAllocationCallbacks const *>(this); }
117 };
118 
119 struct safe_VkApplicationInfo {
120     VkStructureType sType;
121     const void* pNext;
122     const char* pApplicationName;
123     uint32_t applicationVersion;
124     const char* pEngineName;
125     uint32_t engineVersion;
126     uint32_t apiVersion;
127     safe_VkApplicationInfo(const VkApplicationInfo* in_struct);
128     safe_VkApplicationInfo(const safe_VkApplicationInfo& copy_src);
129     safe_VkApplicationInfo& operator=(const safe_VkApplicationInfo& copy_src);
130     safe_VkApplicationInfo();
131     ~safe_VkApplicationInfo();
132     void initialize(const VkApplicationInfo* in_struct);
133     void initialize(const safe_VkApplicationInfo* copy_src);
ptrsafe_VkApplicationInfo134     VkApplicationInfo *ptr() { return reinterpret_cast<VkApplicationInfo *>(this); }
ptrsafe_VkApplicationInfo135     VkApplicationInfo const *ptr() const { return reinterpret_cast<VkApplicationInfo const *>(this); }
136 };
137 
138 struct safe_VkInstanceCreateInfo {
139     VkStructureType sType;
140     const void* pNext;
141     VkInstanceCreateFlags flags;
142     safe_VkApplicationInfo* pApplicationInfo;
143     uint32_t enabledLayerCount;
144     const char* const* ppEnabledLayerNames;
145     uint32_t enabledExtensionCount;
146     const char* const* ppEnabledExtensionNames;
147     safe_VkInstanceCreateInfo(const VkInstanceCreateInfo* in_struct);
148     safe_VkInstanceCreateInfo(const safe_VkInstanceCreateInfo& copy_src);
149     safe_VkInstanceCreateInfo& operator=(const safe_VkInstanceCreateInfo& copy_src);
150     safe_VkInstanceCreateInfo();
151     ~safe_VkInstanceCreateInfo();
152     void initialize(const VkInstanceCreateInfo* in_struct);
153     void initialize(const safe_VkInstanceCreateInfo* copy_src);
ptrsafe_VkInstanceCreateInfo154     VkInstanceCreateInfo *ptr() { return reinterpret_cast<VkInstanceCreateInfo *>(this); }
ptrsafe_VkInstanceCreateInfo155     VkInstanceCreateInfo const *ptr() const { return reinterpret_cast<VkInstanceCreateInfo const *>(this); }
156 };
157 
158 struct safe_VkDeviceQueueCreateInfo {
159     VkStructureType sType;
160     const void* pNext;
161     VkDeviceQueueCreateFlags flags;
162     uint32_t queueFamilyIndex;
163     uint32_t queueCount;
164     const float* pQueuePriorities;
165     safe_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo* in_struct);
166     safe_VkDeviceQueueCreateInfo(const safe_VkDeviceQueueCreateInfo& copy_src);
167     safe_VkDeviceQueueCreateInfo& operator=(const safe_VkDeviceQueueCreateInfo& copy_src);
168     safe_VkDeviceQueueCreateInfo();
169     ~safe_VkDeviceQueueCreateInfo();
170     void initialize(const VkDeviceQueueCreateInfo* in_struct);
171     void initialize(const safe_VkDeviceQueueCreateInfo* copy_src);
ptrsafe_VkDeviceQueueCreateInfo172     VkDeviceQueueCreateInfo *ptr() { return reinterpret_cast<VkDeviceQueueCreateInfo *>(this); }
ptrsafe_VkDeviceQueueCreateInfo173     VkDeviceQueueCreateInfo const *ptr() const { return reinterpret_cast<VkDeviceQueueCreateInfo const *>(this); }
174 };
175 
176 struct safe_VkDeviceCreateInfo {
177     VkStructureType sType;
178     const void* pNext;
179     VkDeviceCreateFlags flags;
180     uint32_t queueCreateInfoCount;
181     safe_VkDeviceQueueCreateInfo* pQueueCreateInfos;
182     uint32_t enabledLayerCount;
183     const char* const* ppEnabledLayerNames;
184     uint32_t enabledExtensionCount;
185     const char* const* ppEnabledExtensionNames;
186     const VkPhysicalDeviceFeatures* pEnabledFeatures;
187     safe_VkDeviceCreateInfo(const VkDeviceCreateInfo* in_struct);
188     safe_VkDeviceCreateInfo(const safe_VkDeviceCreateInfo& copy_src);
189     safe_VkDeviceCreateInfo& operator=(const safe_VkDeviceCreateInfo& copy_src);
190     safe_VkDeviceCreateInfo();
191     ~safe_VkDeviceCreateInfo();
192     void initialize(const VkDeviceCreateInfo* in_struct);
193     void initialize(const safe_VkDeviceCreateInfo* copy_src);
ptrsafe_VkDeviceCreateInfo194     VkDeviceCreateInfo *ptr() { return reinterpret_cast<VkDeviceCreateInfo *>(this); }
ptrsafe_VkDeviceCreateInfo195     VkDeviceCreateInfo const *ptr() const { return reinterpret_cast<VkDeviceCreateInfo const *>(this); }
196 };
197 
198 struct safe_VkSubmitInfo {
199     VkStructureType sType;
200     const void* pNext;
201     uint32_t waitSemaphoreCount;
202     VkSemaphore* pWaitSemaphores;
203     const VkPipelineStageFlags* pWaitDstStageMask;
204     uint32_t commandBufferCount;
205     VkCommandBuffer* pCommandBuffers;
206     uint32_t signalSemaphoreCount;
207     VkSemaphore* pSignalSemaphores;
208     safe_VkSubmitInfo(const VkSubmitInfo* in_struct);
209     safe_VkSubmitInfo(const safe_VkSubmitInfo& copy_src);
210     safe_VkSubmitInfo& operator=(const safe_VkSubmitInfo& copy_src);
211     safe_VkSubmitInfo();
212     ~safe_VkSubmitInfo();
213     void initialize(const VkSubmitInfo* in_struct);
214     void initialize(const safe_VkSubmitInfo* copy_src);
ptrsafe_VkSubmitInfo215     VkSubmitInfo *ptr() { return reinterpret_cast<VkSubmitInfo *>(this); }
ptrsafe_VkSubmitInfo216     VkSubmitInfo const *ptr() const { return reinterpret_cast<VkSubmitInfo const *>(this); }
217 };
218 
219 struct safe_VkMappedMemoryRange {
220     VkStructureType sType;
221     const void* pNext;
222     VkDeviceMemory memory;
223     VkDeviceSize offset;
224     VkDeviceSize size;
225     safe_VkMappedMemoryRange(const VkMappedMemoryRange* in_struct);
226     safe_VkMappedMemoryRange(const safe_VkMappedMemoryRange& copy_src);
227     safe_VkMappedMemoryRange& operator=(const safe_VkMappedMemoryRange& copy_src);
228     safe_VkMappedMemoryRange();
229     ~safe_VkMappedMemoryRange();
230     void initialize(const VkMappedMemoryRange* in_struct);
231     void initialize(const safe_VkMappedMemoryRange* copy_src);
ptrsafe_VkMappedMemoryRange232     VkMappedMemoryRange *ptr() { return reinterpret_cast<VkMappedMemoryRange *>(this); }
ptrsafe_VkMappedMemoryRange233     VkMappedMemoryRange const *ptr() const { return reinterpret_cast<VkMappedMemoryRange const *>(this); }
234 };
235 
236 struct safe_VkMemoryAllocateInfo {
237     VkStructureType sType;
238     const void* pNext;
239     VkDeviceSize allocationSize;
240     uint32_t memoryTypeIndex;
241     safe_VkMemoryAllocateInfo(const VkMemoryAllocateInfo* in_struct);
242     safe_VkMemoryAllocateInfo(const safe_VkMemoryAllocateInfo& copy_src);
243     safe_VkMemoryAllocateInfo& operator=(const safe_VkMemoryAllocateInfo& copy_src);
244     safe_VkMemoryAllocateInfo();
245     ~safe_VkMemoryAllocateInfo();
246     void initialize(const VkMemoryAllocateInfo* in_struct);
247     void initialize(const safe_VkMemoryAllocateInfo* copy_src);
ptrsafe_VkMemoryAllocateInfo248     VkMemoryAllocateInfo *ptr() { return reinterpret_cast<VkMemoryAllocateInfo *>(this); }
ptrsafe_VkMemoryAllocateInfo249     VkMemoryAllocateInfo const *ptr() const { return reinterpret_cast<VkMemoryAllocateInfo const *>(this); }
250 };
251 
252 struct safe_VkSparseBufferMemoryBindInfo {
253     VkBuffer buffer;
254     uint32_t bindCount;
255     VkSparseMemoryBind* pBinds;
256     safe_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo* in_struct);
257     safe_VkSparseBufferMemoryBindInfo(const safe_VkSparseBufferMemoryBindInfo& copy_src);
258     safe_VkSparseBufferMemoryBindInfo& operator=(const safe_VkSparseBufferMemoryBindInfo& copy_src);
259     safe_VkSparseBufferMemoryBindInfo();
260     ~safe_VkSparseBufferMemoryBindInfo();
261     void initialize(const VkSparseBufferMemoryBindInfo* in_struct);
262     void initialize(const safe_VkSparseBufferMemoryBindInfo* copy_src);
ptrsafe_VkSparseBufferMemoryBindInfo263     VkSparseBufferMemoryBindInfo *ptr() { return reinterpret_cast<VkSparseBufferMemoryBindInfo *>(this); }
ptrsafe_VkSparseBufferMemoryBindInfo264     VkSparseBufferMemoryBindInfo const *ptr() const { return reinterpret_cast<VkSparseBufferMemoryBindInfo const *>(this); }
265 };
266 
267 struct safe_VkSparseImageOpaqueMemoryBindInfo {
268     VkImage image;
269     uint32_t bindCount;
270     VkSparseMemoryBind* pBinds;
271     safe_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo* in_struct);
272     safe_VkSparseImageOpaqueMemoryBindInfo(const safe_VkSparseImageOpaqueMemoryBindInfo& copy_src);
273     safe_VkSparseImageOpaqueMemoryBindInfo& operator=(const safe_VkSparseImageOpaqueMemoryBindInfo& copy_src);
274     safe_VkSparseImageOpaqueMemoryBindInfo();
275     ~safe_VkSparseImageOpaqueMemoryBindInfo();
276     void initialize(const VkSparseImageOpaqueMemoryBindInfo* in_struct);
277     void initialize(const safe_VkSparseImageOpaqueMemoryBindInfo* copy_src);
ptrsafe_VkSparseImageOpaqueMemoryBindInfo278     VkSparseImageOpaqueMemoryBindInfo *ptr() { return reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo *>(this); }
ptrsafe_VkSparseImageOpaqueMemoryBindInfo279     VkSparseImageOpaqueMemoryBindInfo const *ptr() const { return reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo const *>(this); }
280 };
281 
282 struct safe_VkSparseImageMemoryBindInfo {
283     VkImage image;
284     uint32_t bindCount;
285     VkSparseImageMemoryBind* pBinds;
286     safe_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo* in_struct);
287     safe_VkSparseImageMemoryBindInfo(const safe_VkSparseImageMemoryBindInfo& copy_src);
288     safe_VkSparseImageMemoryBindInfo& operator=(const safe_VkSparseImageMemoryBindInfo& copy_src);
289     safe_VkSparseImageMemoryBindInfo();
290     ~safe_VkSparseImageMemoryBindInfo();
291     void initialize(const VkSparseImageMemoryBindInfo* in_struct);
292     void initialize(const safe_VkSparseImageMemoryBindInfo* copy_src);
ptrsafe_VkSparseImageMemoryBindInfo293     VkSparseImageMemoryBindInfo *ptr() { return reinterpret_cast<VkSparseImageMemoryBindInfo *>(this); }
ptrsafe_VkSparseImageMemoryBindInfo294     VkSparseImageMemoryBindInfo const *ptr() const { return reinterpret_cast<VkSparseImageMemoryBindInfo const *>(this); }
295 };
296 
297 struct safe_VkBindSparseInfo {
298     VkStructureType sType;
299     const void* pNext;
300     uint32_t waitSemaphoreCount;
301     VkSemaphore* pWaitSemaphores;
302     uint32_t bufferBindCount;
303     safe_VkSparseBufferMemoryBindInfo* pBufferBinds;
304     uint32_t imageOpaqueBindCount;
305     safe_VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
306     uint32_t imageBindCount;
307     safe_VkSparseImageMemoryBindInfo* pImageBinds;
308     uint32_t signalSemaphoreCount;
309     VkSemaphore* pSignalSemaphores;
310     safe_VkBindSparseInfo(const VkBindSparseInfo* in_struct);
311     safe_VkBindSparseInfo(const safe_VkBindSparseInfo& copy_src);
312     safe_VkBindSparseInfo& operator=(const safe_VkBindSparseInfo& copy_src);
313     safe_VkBindSparseInfo();
314     ~safe_VkBindSparseInfo();
315     void initialize(const VkBindSparseInfo* in_struct);
316     void initialize(const safe_VkBindSparseInfo* copy_src);
ptrsafe_VkBindSparseInfo317     VkBindSparseInfo *ptr() { return reinterpret_cast<VkBindSparseInfo *>(this); }
ptrsafe_VkBindSparseInfo318     VkBindSparseInfo const *ptr() const { return reinterpret_cast<VkBindSparseInfo const *>(this); }
319 };
320 
321 struct safe_VkFenceCreateInfo {
322     VkStructureType sType;
323     const void* pNext;
324     VkFenceCreateFlags flags;
325     safe_VkFenceCreateInfo(const VkFenceCreateInfo* in_struct);
326     safe_VkFenceCreateInfo(const safe_VkFenceCreateInfo& copy_src);
327     safe_VkFenceCreateInfo& operator=(const safe_VkFenceCreateInfo& copy_src);
328     safe_VkFenceCreateInfo();
329     ~safe_VkFenceCreateInfo();
330     void initialize(const VkFenceCreateInfo* in_struct);
331     void initialize(const safe_VkFenceCreateInfo* copy_src);
ptrsafe_VkFenceCreateInfo332     VkFenceCreateInfo *ptr() { return reinterpret_cast<VkFenceCreateInfo *>(this); }
ptrsafe_VkFenceCreateInfo333     VkFenceCreateInfo const *ptr() const { return reinterpret_cast<VkFenceCreateInfo const *>(this); }
334 };
335 
336 struct safe_VkSemaphoreCreateInfo {
337     VkStructureType sType;
338     const void* pNext;
339     VkSemaphoreCreateFlags flags;
340     safe_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo* in_struct);
341     safe_VkSemaphoreCreateInfo(const safe_VkSemaphoreCreateInfo& copy_src);
342     safe_VkSemaphoreCreateInfo& operator=(const safe_VkSemaphoreCreateInfo& copy_src);
343     safe_VkSemaphoreCreateInfo();
344     ~safe_VkSemaphoreCreateInfo();
345     void initialize(const VkSemaphoreCreateInfo* in_struct);
346     void initialize(const safe_VkSemaphoreCreateInfo* copy_src);
ptrsafe_VkSemaphoreCreateInfo347     VkSemaphoreCreateInfo *ptr() { return reinterpret_cast<VkSemaphoreCreateInfo *>(this); }
ptrsafe_VkSemaphoreCreateInfo348     VkSemaphoreCreateInfo const *ptr() const { return reinterpret_cast<VkSemaphoreCreateInfo const *>(this); }
349 };
350 
351 struct safe_VkEventCreateInfo {
352     VkStructureType sType;
353     const void* pNext;
354     VkEventCreateFlags flags;
355     safe_VkEventCreateInfo(const VkEventCreateInfo* in_struct);
356     safe_VkEventCreateInfo(const safe_VkEventCreateInfo& copy_src);
357     safe_VkEventCreateInfo& operator=(const safe_VkEventCreateInfo& copy_src);
358     safe_VkEventCreateInfo();
359     ~safe_VkEventCreateInfo();
360     void initialize(const VkEventCreateInfo* in_struct);
361     void initialize(const safe_VkEventCreateInfo* copy_src);
ptrsafe_VkEventCreateInfo362     VkEventCreateInfo *ptr() { return reinterpret_cast<VkEventCreateInfo *>(this); }
ptrsafe_VkEventCreateInfo363     VkEventCreateInfo const *ptr() const { return reinterpret_cast<VkEventCreateInfo const *>(this); }
364 };
365 
366 struct safe_VkQueryPoolCreateInfo {
367     VkStructureType sType;
368     const void* pNext;
369     VkQueryPoolCreateFlags flags;
370     VkQueryType queryType;
371     uint32_t queryCount;
372     VkQueryPipelineStatisticFlags pipelineStatistics;
373     safe_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo* in_struct);
374     safe_VkQueryPoolCreateInfo(const safe_VkQueryPoolCreateInfo& copy_src);
375     safe_VkQueryPoolCreateInfo& operator=(const safe_VkQueryPoolCreateInfo& copy_src);
376     safe_VkQueryPoolCreateInfo();
377     ~safe_VkQueryPoolCreateInfo();
378     void initialize(const VkQueryPoolCreateInfo* in_struct);
379     void initialize(const safe_VkQueryPoolCreateInfo* copy_src);
ptrsafe_VkQueryPoolCreateInfo380     VkQueryPoolCreateInfo *ptr() { return reinterpret_cast<VkQueryPoolCreateInfo *>(this); }
ptrsafe_VkQueryPoolCreateInfo381     VkQueryPoolCreateInfo const *ptr() const { return reinterpret_cast<VkQueryPoolCreateInfo const *>(this); }
382 };
383 
384 struct safe_VkBufferCreateInfo {
385     VkStructureType sType;
386     const void* pNext;
387     VkBufferCreateFlags flags;
388     VkDeviceSize size;
389     VkBufferUsageFlags usage;
390     VkSharingMode sharingMode;
391     uint32_t queueFamilyIndexCount;
392     const uint32_t* pQueueFamilyIndices;
393     safe_VkBufferCreateInfo(const VkBufferCreateInfo* in_struct);
394     safe_VkBufferCreateInfo(const safe_VkBufferCreateInfo& copy_src);
395     safe_VkBufferCreateInfo& operator=(const safe_VkBufferCreateInfo& copy_src);
396     safe_VkBufferCreateInfo();
397     ~safe_VkBufferCreateInfo();
398     void initialize(const VkBufferCreateInfo* in_struct);
399     void initialize(const safe_VkBufferCreateInfo* copy_src);
ptrsafe_VkBufferCreateInfo400     VkBufferCreateInfo *ptr() { return reinterpret_cast<VkBufferCreateInfo *>(this); }
ptrsafe_VkBufferCreateInfo401     VkBufferCreateInfo const *ptr() const { return reinterpret_cast<VkBufferCreateInfo const *>(this); }
402 };
403 
404 struct safe_VkBufferViewCreateInfo {
405     VkStructureType sType;
406     const void* pNext;
407     VkBufferViewCreateFlags flags;
408     VkBuffer buffer;
409     VkFormat format;
410     VkDeviceSize offset;
411     VkDeviceSize range;
412     safe_VkBufferViewCreateInfo(const VkBufferViewCreateInfo* in_struct);
413     safe_VkBufferViewCreateInfo(const safe_VkBufferViewCreateInfo& copy_src);
414     safe_VkBufferViewCreateInfo& operator=(const safe_VkBufferViewCreateInfo& copy_src);
415     safe_VkBufferViewCreateInfo();
416     ~safe_VkBufferViewCreateInfo();
417     void initialize(const VkBufferViewCreateInfo* in_struct);
418     void initialize(const safe_VkBufferViewCreateInfo* copy_src);
ptrsafe_VkBufferViewCreateInfo419     VkBufferViewCreateInfo *ptr() { return reinterpret_cast<VkBufferViewCreateInfo *>(this); }
ptrsafe_VkBufferViewCreateInfo420     VkBufferViewCreateInfo const *ptr() const { return reinterpret_cast<VkBufferViewCreateInfo const *>(this); }
421 };
422 
423 struct safe_VkImageCreateInfo {
424     VkStructureType sType;
425     const void* pNext;
426     VkImageCreateFlags flags;
427     VkImageType imageType;
428     VkFormat format;
429     VkExtent3D extent;
430     uint32_t mipLevels;
431     uint32_t arrayLayers;
432     VkSampleCountFlagBits samples;
433     VkImageTiling tiling;
434     VkImageUsageFlags usage;
435     VkSharingMode sharingMode;
436     uint32_t queueFamilyIndexCount;
437     const uint32_t* pQueueFamilyIndices;
438     VkImageLayout initialLayout;
439     safe_VkImageCreateInfo(const VkImageCreateInfo* in_struct);
440     safe_VkImageCreateInfo(const safe_VkImageCreateInfo& copy_src);
441     safe_VkImageCreateInfo& operator=(const safe_VkImageCreateInfo& copy_src);
442     safe_VkImageCreateInfo();
443     ~safe_VkImageCreateInfo();
444     void initialize(const VkImageCreateInfo* in_struct);
445     void initialize(const safe_VkImageCreateInfo* copy_src);
ptrsafe_VkImageCreateInfo446     VkImageCreateInfo *ptr() { return reinterpret_cast<VkImageCreateInfo *>(this); }
ptrsafe_VkImageCreateInfo447     VkImageCreateInfo const *ptr() const { return reinterpret_cast<VkImageCreateInfo const *>(this); }
448 };
449 
450 struct safe_VkImageViewCreateInfo {
451     VkStructureType sType;
452     const void* pNext;
453     VkImageViewCreateFlags flags;
454     VkImage image;
455     VkImageViewType viewType;
456     VkFormat format;
457     VkComponentMapping components;
458     VkImageSubresourceRange subresourceRange;
459     safe_VkImageViewCreateInfo(const VkImageViewCreateInfo* in_struct);
460     safe_VkImageViewCreateInfo(const safe_VkImageViewCreateInfo& copy_src);
461     safe_VkImageViewCreateInfo& operator=(const safe_VkImageViewCreateInfo& copy_src);
462     safe_VkImageViewCreateInfo();
463     ~safe_VkImageViewCreateInfo();
464     void initialize(const VkImageViewCreateInfo* in_struct);
465     void initialize(const safe_VkImageViewCreateInfo* copy_src);
ptrsafe_VkImageViewCreateInfo466     VkImageViewCreateInfo *ptr() { return reinterpret_cast<VkImageViewCreateInfo *>(this); }
ptrsafe_VkImageViewCreateInfo467     VkImageViewCreateInfo const *ptr() const { return reinterpret_cast<VkImageViewCreateInfo const *>(this); }
468 };
469 
470 struct safe_VkShaderModuleCreateInfo {
471     VkStructureType sType;
472     const void* pNext;
473     VkShaderModuleCreateFlags flags;
474     size_t codeSize;
475     const uint32_t* pCode;
476     safe_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo* in_struct);
477     safe_VkShaderModuleCreateInfo(const safe_VkShaderModuleCreateInfo& copy_src);
478     safe_VkShaderModuleCreateInfo& operator=(const safe_VkShaderModuleCreateInfo& copy_src);
479     safe_VkShaderModuleCreateInfo();
480     ~safe_VkShaderModuleCreateInfo();
481     void initialize(const VkShaderModuleCreateInfo* in_struct);
482     void initialize(const safe_VkShaderModuleCreateInfo* copy_src);
ptrsafe_VkShaderModuleCreateInfo483     VkShaderModuleCreateInfo *ptr() { return reinterpret_cast<VkShaderModuleCreateInfo *>(this); }
ptrsafe_VkShaderModuleCreateInfo484     VkShaderModuleCreateInfo const *ptr() const { return reinterpret_cast<VkShaderModuleCreateInfo const *>(this); }
485 };
486 
487 struct safe_VkPipelineCacheCreateInfo {
488     VkStructureType sType;
489     const void* pNext;
490     VkPipelineCacheCreateFlags flags;
491     size_t initialDataSize;
492     const void* pInitialData;
493     safe_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo* in_struct);
494     safe_VkPipelineCacheCreateInfo(const safe_VkPipelineCacheCreateInfo& copy_src);
495     safe_VkPipelineCacheCreateInfo& operator=(const safe_VkPipelineCacheCreateInfo& copy_src);
496     safe_VkPipelineCacheCreateInfo();
497     ~safe_VkPipelineCacheCreateInfo();
498     void initialize(const VkPipelineCacheCreateInfo* in_struct);
499     void initialize(const safe_VkPipelineCacheCreateInfo* copy_src);
ptrsafe_VkPipelineCacheCreateInfo500     VkPipelineCacheCreateInfo *ptr() { return reinterpret_cast<VkPipelineCacheCreateInfo *>(this); }
ptrsafe_VkPipelineCacheCreateInfo501     VkPipelineCacheCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineCacheCreateInfo const *>(this); }
502 };
503 
504 struct safe_VkSpecializationInfo {
505     uint32_t mapEntryCount;
506     const VkSpecializationMapEntry* pMapEntries;
507     size_t dataSize;
508     const void* pData;
509     safe_VkSpecializationInfo(const VkSpecializationInfo* in_struct);
510     safe_VkSpecializationInfo(const safe_VkSpecializationInfo& copy_src);
511     safe_VkSpecializationInfo& operator=(const safe_VkSpecializationInfo& copy_src);
512     safe_VkSpecializationInfo();
513     ~safe_VkSpecializationInfo();
514     void initialize(const VkSpecializationInfo* in_struct);
515     void initialize(const safe_VkSpecializationInfo* copy_src);
ptrsafe_VkSpecializationInfo516     VkSpecializationInfo *ptr() { return reinterpret_cast<VkSpecializationInfo *>(this); }
ptrsafe_VkSpecializationInfo517     VkSpecializationInfo const *ptr() const { return reinterpret_cast<VkSpecializationInfo const *>(this); }
518 };
519 
520 struct safe_VkPipelineShaderStageCreateInfo {
521     VkStructureType sType;
522     const void* pNext;
523     VkPipelineShaderStageCreateFlags flags;
524     VkShaderStageFlagBits stage;
525     VkShaderModule module;
526     const char* pName;
527     safe_VkSpecializationInfo* pSpecializationInfo;
528     safe_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo* in_struct);
529     safe_VkPipelineShaderStageCreateInfo(const safe_VkPipelineShaderStageCreateInfo& copy_src);
530     safe_VkPipelineShaderStageCreateInfo& operator=(const safe_VkPipelineShaderStageCreateInfo& copy_src);
531     safe_VkPipelineShaderStageCreateInfo();
532     ~safe_VkPipelineShaderStageCreateInfo();
533     void initialize(const VkPipelineShaderStageCreateInfo* in_struct);
534     void initialize(const safe_VkPipelineShaderStageCreateInfo* copy_src);
ptrsafe_VkPipelineShaderStageCreateInfo535     VkPipelineShaderStageCreateInfo *ptr() { return reinterpret_cast<VkPipelineShaderStageCreateInfo *>(this); }
ptrsafe_VkPipelineShaderStageCreateInfo536     VkPipelineShaderStageCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineShaderStageCreateInfo const *>(this); }
537 };
538 
539 struct safe_VkComputePipelineCreateInfo {
540     VkStructureType sType;
541     const void* pNext;
542     VkPipelineCreateFlags flags;
543     safe_VkPipelineShaderStageCreateInfo stage;
544     VkPipelineLayout layout;
545     VkPipeline basePipelineHandle;
546     int32_t basePipelineIndex;
547     safe_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo* in_struct);
548     safe_VkComputePipelineCreateInfo(const safe_VkComputePipelineCreateInfo& copy_src);
549     safe_VkComputePipelineCreateInfo& operator=(const safe_VkComputePipelineCreateInfo& copy_src);
550     safe_VkComputePipelineCreateInfo();
551     ~safe_VkComputePipelineCreateInfo();
552     void initialize(const VkComputePipelineCreateInfo* in_struct);
553     void initialize(const safe_VkComputePipelineCreateInfo* copy_src);
ptrsafe_VkComputePipelineCreateInfo554     VkComputePipelineCreateInfo *ptr() { return reinterpret_cast<VkComputePipelineCreateInfo *>(this); }
ptrsafe_VkComputePipelineCreateInfo555     VkComputePipelineCreateInfo const *ptr() const { return reinterpret_cast<VkComputePipelineCreateInfo const *>(this); }
556 };
557 
558 struct safe_VkPipelineVertexInputStateCreateInfo {
559     VkStructureType sType;
560     const void* pNext;
561     VkPipelineVertexInputStateCreateFlags flags;
562     uint32_t vertexBindingDescriptionCount;
563     const VkVertexInputBindingDescription* pVertexBindingDescriptions;
564     uint32_t vertexAttributeDescriptionCount;
565     const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
566     safe_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo* in_struct);
567     safe_VkPipelineVertexInputStateCreateInfo(const safe_VkPipelineVertexInputStateCreateInfo& copy_src);
568     safe_VkPipelineVertexInputStateCreateInfo& operator=(const safe_VkPipelineVertexInputStateCreateInfo& copy_src);
569     safe_VkPipelineVertexInputStateCreateInfo();
570     ~safe_VkPipelineVertexInputStateCreateInfo();
571     void initialize(const VkPipelineVertexInputStateCreateInfo* in_struct);
572     void initialize(const safe_VkPipelineVertexInputStateCreateInfo* copy_src);
ptrsafe_VkPipelineVertexInputStateCreateInfo573     VkPipelineVertexInputStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineVertexInputStateCreateInfo *>(this); }
ptrsafe_VkPipelineVertexInputStateCreateInfo574     VkPipelineVertexInputStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineVertexInputStateCreateInfo const *>(this); }
575 };
576 
577 struct safe_VkPipelineInputAssemblyStateCreateInfo {
578     VkStructureType sType;
579     const void* pNext;
580     VkPipelineInputAssemblyStateCreateFlags flags;
581     VkPrimitiveTopology topology;
582     VkBool32 primitiveRestartEnable;
583     safe_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo* in_struct);
584     safe_VkPipelineInputAssemblyStateCreateInfo(const safe_VkPipelineInputAssemblyStateCreateInfo& copy_src);
585     safe_VkPipelineInputAssemblyStateCreateInfo& operator=(const safe_VkPipelineInputAssemblyStateCreateInfo& copy_src);
586     safe_VkPipelineInputAssemblyStateCreateInfo();
587     ~safe_VkPipelineInputAssemblyStateCreateInfo();
588     void initialize(const VkPipelineInputAssemblyStateCreateInfo* in_struct);
589     void initialize(const safe_VkPipelineInputAssemblyStateCreateInfo* copy_src);
ptrsafe_VkPipelineInputAssemblyStateCreateInfo590     VkPipelineInputAssemblyStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo *>(this); }
ptrsafe_VkPipelineInputAssemblyStateCreateInfo591     VkPipelineInputAssemblyStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo const *>(this); }
592 };
593 
594 struct safe_VkPipelineTessellationStateCreateInfo {
595     VkStructureType sType;
596     const void* pNext;
597     VkPipelineTessellationStateCreateFlags flags;
598     uint32_t patchControlPoints;
599     safe_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo* in_struct);
600     safe_VkPipelineTessellationStateCreateInfo(const safe_VkPipelineTessellationStateCreateInfo& copy_src);
601     safe_VkPipelineTessellationStateCreateInfo& operator=(const safe_VkPipelineTessellationStateCreateInfo& copy_src);
602     safe_VkPipelineTessellationStateCreateInfo();
603     ~safe_VkPipelineTessellationStateCreateInfo();
604     void initialize(const VkPipelineTessellationStateCreateInfo* in_struct);
605     void initialize(const safe_VkPipelineTessellationStateCreateInfo* copy_src);
ptrsafe_VkPipelineTessellationStateCreateInfo606     VkPipelineTessellationStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineTessellationStateCreateInfo *>(this); }
ptrsafe_VkPipelineTessellationStateCreateInfo607     VkPipelineTessellationStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineTessellationStateCreateInfo const *>(this); }
608 };
609 
610 struct safe_VkPipelineViewportStateCreateInfo {
611     VkStructureType sType;
612     const void* pNext;
613     VkPipelineViewportStateCreateFlags flags;
614     uint32_t viewportCount;
615     const VkViewport* pViewports;
616     uint32_t scissorCount;
617     const VkRect2D* pScissors;
618     safe_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports, const bool is_dynamic_scissors);
619     safe_VkPipelineViewportStateCreateInfo(const safe_VkPipelineViewportStateCreateInfo& copy_src);
620     safe_VkPipelineViewportStateCreateInfo& operator=(const safe_VkPipelineViewportStateCreateInfo& copy_src);
621     safe_VkPipelineViewportStateCreateInfo();
622     ~safe_VkPipelineViewportStateCreateInfo();
623     void initialize(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports, const bool is_dynamic_scissors);
624     void initialize(const safe_VkPipelineViewportStateCreateInfo* copy_src);
ptrsafe_VkPipelineViewportStateCreateInfo625     VkPipelineViewportStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineViewportStateCreateInfo *>(this); }
ptrsafe_VkPipelineViewportStateCreateInfo626     VkPipelineViewportStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineViewportStateCreateInfo const *>(this); }
627 };
628 
629 struct safe_VkPipelineRasterizationStateCreateInfo {
630     VkStructureType sType;
631     const void* pNext;
632     VkPipelineRasterizationStateCreateFlags flags;
633     VkBool32 depthClampEnable;
634     VkBool32 rasterizerDiscardEnable;
635     VkPolygonMode polygonMode;
636     VkCullModeFlags cullMode;
637     VkFrontFace frontFace;
638     VkBool32 depthBiasEnable;
639     float depthBiasConstantFactor;
640     float depthBiasClamp;
641     float depthBiasSlopeFactor;
642     float lineWidth;
643     safe_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo* in_struct);
644     safe_VkPipelineRasterizationStateCreateInfo(const safe_VkPipelineRasterizationStateCreateInfo& copy_src);
645     safe_VkPipelineRasterizationStateCreateInfo& operator=(const safe_VkPipelineRasterizationStateCreateInfo& copy_src);
646     safe_VkPipelineRasterizationStateCreateInfo();
647     ~safe_VkPipelineRasterizationStateCreateInfo();
648     void initialize(const VkPipelineRasterizationStateCreateInfo* in_struct);
649     void initialize(const safe_VkPipelineRasterizationStateCreateInfo* copy_src);
ptrsafe_VkPipelineRasterizationStateCreateInfo650     VkPipelineRasterizationStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineRasterizationStateCreateInfo *>(this); }
ptrsafe_VkPipelineRasterizationStateCreateInfo651     VkPipelineRasterizationStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineRasterizationStateCreateInfo const *>(this); }
652 };
653 
654 struct safe_VkPipelineMultisampleStateCreateInfo {
655     VkStructureType sType;
656     const void* pNext;
657     VkPipelineMultisampleStateCreateFlags flags;
658     VkSampleCountFlagBits rasterizationSamples;
659     VkBool32 sampleShadingEnable;
660     float minSampleShading;
661     const VkSampleMask* pSampleMask;
662     VkBool32 alphaToCoverageEnable;
663     VkBool32 alphaToOneEnable;
664     safe_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo* in_struct);
665     safe_VkPipelineMultisampleStateCreateInfo(const safe_VkPipelineMultisampleStateCreateInfo& copy_src);
666     safe_VkPipelineMultisampleStateCreateInfo& operator=(const safe_VkPipelineMultisampleStateCreateInfo& copy_src);
667     safe_VkPipelineMultisampleStateCreateInfo();
668     ~safe_VkPipelineMultisampleStateCreateInfo();
669     void initialize(const VkPipelineMultisampleStateCreateInfo* in_struct);
670     void initialize(const safe_VkPipelineMultisampleStateCreateInfo* copy_src);
ptrsafe_VkPipelineMultisampleStateCreateInfo671     VkPipelineMultisampleStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineMultisampleStateCreateInfo *>(this); }
ptrsafe_VkPipelineMultisampleStateCreateInfo672     VkPipelineMultisampleStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineMultisampleStateCreateInfo const *>(this); }
673 };
674 
675 struct safe_VkPipelineDepthStencilStateCreateInfo {
676     VkStructureType sType;
677     const void* pNext;
678     VkPipelineDepthStencilStateCreateFlags flags;
679     VkBool32 depthTestEnable;
680     VkBool32 depthWriteEnable;
681     VkCompareOp depthCompareOp;
682     VkBool32 depthBoundsTestEnable;
683     VkBool32 stencilTestEnable;
684     VkStencilOpState front;
685     VkStencilOpState back;
686     float minDepthBounds;
687     float maxDepthBounds;
688     safe_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo* in_struct);
689     safe_VkPipelineDepthStencilStateCreateInfo(const safe_VkPipelineDepthStencilStateCreateInfo& copy_src);
690     safe_VkPipelineDepthStencilStateCreateInfo& operator=(const safe_VkPipelineDepthStencilStateCreateInfo& copy_src);
691     safe_VkPipelineDepthStencilStateCreateInfo();
692     ~safe_VkPipelineDepthStencilStateCreateInfo();
693     void initialize(const VkPipelineDepthStencilStateCreateInfo* in_struct);
694     void initialize(const safe_VkPipelineDepthStencilStateCreateInfo* copy_src);
ptrsafe_VkPipelineDepthStencilStateCreateInfo695     VkPipelineDepthStencilStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo *>(this); }
ptrsafe_VkPipelineDepthStencilStateCreateInfo696     VkPipelineDepthStencilStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo const *>(this); }
697 };
698 
699 struct safe_VkPipelineColorBlendStateCreateInfo {
700     VkStructureType sType;
701     const void* pNext;
702     VkPipelineColorBlendStateCreateFlags flags;
703     VkBool32 logicOpEnable;
704     VkLogicOp logicOp;
705     uint32_t attachmentCount;
706     const VkPipelineColorBlendAttachmentState* pAttachments;
707     float blendConstants[4];
708     safe_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo* in_struct);
709     safe_VkPipelineColorBlendStateCreateInfo(const safe_VkPipelineColorBlendStateCreateInfo& copy_src);
710     safe_VkPipelineColorBlendStateCreateInfo& operator=(const safe_VkPipelineColorBlendStateCreateInfo& copy_src);
711     safe_VkPipelineColorBlendStateCreateInfo();
712     ~safe_VkPipelineColorBlendStateCreateInfo();
713     void initialize(const VkPipelineColorBlendStateCreateInfo* in_struct);
714     void initialize(const safe_VkPipelineColorBlendStateCreateInfo* copy_src);
ptrsafe_VkPipelineColorBlendStateCreateInfo715     VkPipelineColorBlendStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineColorBlendStateCreateInfo *>(this); }
ptrsafe_VkPipelineColorBlendStateCreateInfo716     VkPipelineColorBlendStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineColorBlendStateCreateInfo const *>(this); }
717 };
718 
719 struct safe_VkPipelineDynamicStateCreateInfo {
720     VkStructureType sType;
721     const void* pNext;
722     VkPipelineDynamicStateCreateFlags flags;
723     uint32_t dynamicStateCount;
724     const VkDynamicState* pDynamicStates;
725     safe_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* in_struct);
726     safe_VkPipelineDynamicStateCreateInfo(const safe_VkPipelineDynamicStateCreateInfo& copy_src);
727     safe_VkPipelineDynamicStateCreateInfo& operator=(const safe_VkPipelineDynamicStateCreateInfo& copy_src);
728     safe_VkPipelineDynamicStateCreateInfo();
729     ~safe_VkPipelineDynamicStateCreateInfo();
730     void initialize(const VkPipelineDynamicStateCreateInfo* in_struct);
731     void initialize(const safe_VkPipelineDynamicStateCreateInfo* copy_src);
ptrsafe_VkPipelineDynamicStateCreateInfo732     VkPipelineDynamicStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineDynamicStateCreateInfo *>(this); }
ptrsafe_VkPipelineDynamicStateCreateInfo733     VkPipelineDynamicStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineDynamicStateCreateInfo const *>(this); }
734 };
735 
736 struct safe_VkGraphicsPipelineCreateInfo {
737     VkStructureType sType;
738     const void* pNext;
739     VkPipelineCreateFlags flags;
740     uint32_t stageCount;
741     safe_VkPipelineShaderStageCreateInfo* pStages;
742     safe_VkPipelineVertexInputStateCreateInfo* pVertexInputState;
743     safe_VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
744     safe_VkPipelineTessellationStateCreateInfo* pTessellationState;
745     safe_VkPipelineViewportStateCreateInfo* pViewportState;
746     safe_VkPipelineRasterizationStateCreateInfo* pRasterizationState;
747     safe_VkPipelineMultisampleStateCreateInfo* pMultisampleState;
748     safe_VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
749     safe_VkPipelineColorBlendStateCreateInfo* pColorBlendState;
750     safe_VkPipelineDynamicStateCreateInfo* pDynamicState;
751     VkPipelineLayout layout;
752     VkRenderPass renderPass;
753     uint32_t subpass;
754     VkPipeline basePipelineHandle;
755     int32_t basePipelineIndex;
756     safe_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment, const bool uses_depthstencil_attachment);
757     safe_VkGraphicsPipelineCreateInfo(const safe_VkGraphicsPipelineCreateInfo& copy_src);
758     safe_VkGraphicsPipelineCreateInfo& operator=(const safe_VkGraphicsPipelineCreateInfo& copy_src);
759     safe_VkGraphicsPipelineCreateInfo();
760     ~safe_VkGraphicsPipelineCreateInfo();
761     void initialize(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment, const bool uses_depthstencil_attachment);
762     void initialize(const safe_VkGraphicsPipelineCreateInfo* copy_src);
ptrsafe_VkGraphicsPipelineCreateInfo763     VkGraphicsPipelineCreateInfo *ptr() { return reinterpret_cast<VkGraphicsPipelineCreateInfo *>(this); }
ptrsafe_VkGraphicsPipelineCreateInfo764     VkGraphicsPipelineCreateInfo const *ptr() const { return reinterpret_cast<VkGraphicsPipelineCreateInfo const *>(this); }
765 };
766 
767 struct safe_VkPipelineLayoutCreateInfo {
768     VkStructureType sType;
769     const void* pNext;
770     VkPipelineLayoutCreateFlags flags;
771     uint32_t setLayoutCount;
772     VkDescriptorSetLayout* pSetLayouts;
773     uint32_t pushConstantRangeCount;
774     const VkPushConstantRange* pPushConstantRanges;
775     safe_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo* in_struct);
776     safe_VkPipelineLayoutCreateInfo(const safe_VkPipelineLayoutCreateInfo& copy_src);
777     safe_VkPipelineLayoutCreateInfo& operator=(const safe_VkPipelineLayoutCreateInfo& copy_src);
778     safe_VkPipelineLayoutCreateInfo();
779     ~safe_VkPipelineLayoutCreateInfo();
780     void initialize(const VkPipelineLayoutCreateInfo* in_struct);
781     void initialize(const safe_VkPipelineLayoutCreateInfo* copy_src);
ptrsafe_VkPipelineLayoutCreateInfo782     VkPipelineLayoutCreateInfo *ptr() { return reinterpret_cast<VkPipelineLayoutCreateInfo *>(this); }
ptrsafe_VkPipelineLayoutCreateInfo783     VkPipelineLayoutCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineLayoutCreateInfo const *>(this); }
784 };
785 
786 struct safe_VkSamplerCreateInfo {
787     VkStructureType sType;
788     const void* pNext;
789     VkSamplerCreateFlags flags;
790     VkFilter magFilter;
791     VkFilter minFilter;
792     VkSamplerMipmapMode mipmapMode;
793     VkSamplerAddressMode addressModeU;
794     VkSamplerAddressMode addressModeV;
795     VkSamplerAddressMode addressModeW;
796     float mipLodBias;
797     VkBool32 anisotropyEnable;
798     float maxAnisotropy;
799     VkBool32 compareEnable;
800     VkCompareOp compareOp;
801     float minLod;
802     float maxLod;
803     VkBorderColor borderColor;
804     VkBool32 unnormalizedCoordinates;
805     safe_VkSamplerCreateInfo(const VkSamplerCreateInfo* in_struct);
806     safe_VkSamplerCreateInfo(const safe_VkSamplerCreateInfo& copy_src);
807     safe_VkSamplerCreateInfo& operator=(const safe_VkSamplerCreateInfo& copy_src);
808     safe_VkSamplerCreateInfo();
809     ~safe_VkSamplerCreateInfo();
810     void initialize(const VkSamplerCreateInfo* in_struct);
811     void initialize(const safe_VkSamplerCreateInfo* copy_src);
ptrsafe_VkSamplerCreateInfo812     VkSamplerCreateInfo *ptr() { return reinterpret_cast<VkSamplerCreateInfo *>(this); }
ptrsafe_VkSamplerCreateInfo813     VkSamplerCreateInfo const *ptr() const { return reinterpret_cast<VkSamplerCreateInfo const *>(this); }
814 };
815 
816 struct safe_VkCopyDescriptorSet {
817     VkStructureType sType;
818     const void* pNext;
819     VkDescriptorSet srcSet;
820     uint32_t srcBinding;
821     uint32_t srcArrayElement;
822     VkDescriptorSet dstSet;
823     uint32_t dstBinding;
824     uint32_t dstArrayElement;
825     uint32_t descriptorCount;
826     safe_VkCopyDescriptorSet(const VkCopyDescriptorSet* in_struct);
827     safe_VkCopyDescriptorSet(const safe_VkCopyDescriptorSet& copy_src);
828     safe_VkCopyDescriptorSet& operator=(const safe_VkCopyDescriptorSet& copy_src);
829     safe_VkCopyDescriptorSet();
830     ~safe_VkCopyDescriptorSet();
831     void initialize(const VkCopyDescriptorSet* in_struct);
832     void initialize(const safe_VkCopyDescriptorSet* copy_src);
ptrsafe_VkCopyDescriptorSet833     VkCopyDescriptorSet *ptr() { return reinterpret_cast<VkCopyDescriptorSet *>(this); }
ptrsafe_VkCopyDescriptorSet834     VkCopyDescriptorSet const *ptr() const { return reinterpret_cast<VkCopyDescriptorSet const *>(this); }
835 };
836 
837 struct safe_VkDescriptorPoolCreateInfo {
838     VkStructureType sType;
839     const void* pNext;
840     VkDescriptorPoolCreateFlags flags;
841     uint32_t maxSets;
842     uint32_t poolSizeCount;
843     const VkDescriptorPoolSize* pPoolSizes;
844     safe_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo* in_struct);
845     safe_VkDescriptorPoolCreateInfo(const safe_VkDescriptorPoolCreateInfo& copy_src);
846     safe_VkDescriptorPoolCreateInfo& operator=(const safe_VkDescriptorPoolCreateInfo& copy_src);
847     safe_VkDescriptorPoolCreateInfo();
848     ~safe_VkDescriptorPoolCreateInfo();
849     void initialize(const VkDescriptorPoolCreateInfo* in_struct);
850     void initialize(const safe_VkDescriptorPoolCreateInfo* copy_src);
ptrsafe_VkDescriptorPoolCreateInfo851     VkDescriptorPoolCreateInfo *ptr() { return reinterpret_cast<VkDescriptorPoolCreateInfo *>(this); }
ptrsafe_VkDescriptorPoolCreateInfo852     VkDescriptorPoolCreateInfo const *ptr() const { return reinterpret_cast<VkDescriptorPoolCreateInfo const *>(this); }
853 };
854 
855 struct safe_VkDescriptorSetAllocateInfo {
856     VkStructureType sType;
857     const void* pNext;
858     VkDescriptorPool descriptorPool;
859     uint32_t descriptorSetCount;
860     VkDescriptorSetLayout* pSetLayouts;
861     safe_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo* in_struct);
862     safe_VkDescriptorSetAllocateInfo(const safe_VkDescriptorSetAllocateInfo& copy_src);
863     safe_VkDescriptorSetAllocateInfo& operator=(const safe_VkDescriptorSetAllocateInfo& copy_src);
864     safe_VkDescriptorSetAllocateInfo();
865     ~safe_VkDescriptorSetAllocateInfo();
866     void initialize(const VkDescriptorSetAllocateInfo* in_struct);
867     void initialize(const safe_VkDescriptorSetAllocateInfo* copy_src);
ptrsafe_VkDescriptorSetAllocateInfo868     VkDescriptorSetAllocateInfo *ptr() { return reinterpret_cast<VkDescriptorSetAllocateInfo *>(this); }
ptrsafe_VkDescriptorSetAllocateInfo869     VkDescriptorSetAllocateInfo const *ptr() const { return reinterpret_cast<VkDescriptorSetAllocateInfo const *>(this); }
870 };
871 
872 struct safe_VkDescriptorSetLayoutBinding {
873     uint32_t binding;
874     VkDescriptorType descriptorType;
875     uint32_t descriptorCount;
876     VkShaderStageFlags stageFlags;
877     VkSampler* pImmutableSamplers;
878     safe_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding* in_struct);
879     safe_VkDescriptorSetLayoutBinding(const safe_VkDescriptorSetLayoutBinding& copy_src);
880     safe_VkDescriptorSetLayoutBinding& operator=(const safe_VkDescriptorSetLayoutBinding& copy_src);
881     safe_VkDescriptorSetLayoutBinding();
882     ~safe_VkDescriptorSetLayoutBinding();
883     void initialize(const VkDescriptorSetLayoutBinding* in_struct);
884     void initialize(const safe_VkDescriptorSetLayoutBinding* copy_src);
ptrsafe_VkDescriptorSetLayoutBinding885     VkDescriptorSetLayoutBinding *ptr() { return reinterpret_cast<VkDescriptorSetLayoutBinding *>(this); }
ptrsafe_VkDescriptorSetLayoutBinding886     VkDescriptorSetLayoutBinding const *ptr() const { return reinterpret_cast<VkDescriptorSetLayoutBinding const *>(this); }
887 };
888 
889 struct safe_VkDescriptorSetLayoutCreateInfo {
890     VkStructureType sType;
891     const void* pNext;
892     VkDescriptorSetLayoutCreateFlags flags;
893     uint32_t bindingCount;
894     safe_VkDescriptorSetLayoutBinding* pBindings;
895     safe_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo* in_struct);
896     safe_VkDescriptorSetLayoutCreateInfo(const safe_VkDescriptorSetLayoutCreateInfo& copy_src);
897     safe_VkDescriptorSetLayoutCreateInfo& operator=(const safe_VkDescriptorSetLayoutCreateInfo& copy_src);
898     safe_VkDescriptorSetLayoutCreateInfo();
899     ~safe_VkDescriptorSetLayoutCreateInfo();
900     void initialize(const VkDescriptorSetLayoutCreateInfo* in_struct);
901     void initialize(const safe_VkDescriptorSetLayoutCreateInfo* copy_src);
ptrsafe_VkDescriptorSetLayoutCreateInfo902     VkDescriptorSetLayoutCreateInfo *ptr() { return reinterpret_cast<VkDescriptorSetLayoutCreateInfo *>(this); }
ptrsafe_VkDescriptorSetLayoutCreateInfo903     VkDescriptorSetLayoutCreateInfo const *ptr() const { return reinterpret_cast<VkDescriptorSetLayoutCreateInfo const *>(this); }
904 };
905 
906 struct safe_VkWriteDescriptorSet {
907     VkStructureType sType;
908     const void* pNext;
909     VkDescriptorSet dstSet;
910     uint32_t dstBinding;
911     uint32_t dstArrayElement;
912     uint32_t descriptorCount;
913     VkDescriptorType descriptorType;
914     VkDescriptorImageInfo* pImageInfo;
915     VkDescriptorBufferInfo* pBufferInfo;
916     VkBufferView* pTexelBufferView;
917     safe_VkWriteDescriptorSet(const VkWriteDescriptorSet* in_struct);
918     safe_VkWriteDescriptorSet(const safe_VkWriteDescriptorSet& copy_src);
919     safe_VkWriteDescriptorSet& operator=(const safe_VkWriteDescriptorSet& copy_src);
920     safe_VkWriteDescriptorSet();
921     ~safe_VkWriteDescriptorSet();
922     void initialize(const VkWriteDescriptorSet* in_struct);
923     void initialize(const safe_VkWriteDescriptorSet* copy_src);
ptrsafe_VkWriteDescriptorSet924     VkWriteDescriptorSet *ptr() { return reinterpret_cast<VkWriteDescriptorSet *>(this); }
ptrsafe_VkWriteDescriptorSet925     VkWriteDescriptorSet const *ptr() const { return reinterpret_cast<VkWriteDescriptorSet const *>(this); }
926 };
927 
928 struct safe_VkFramebufferCreateInfo {
929     VkStructureType sType;
930     const void* pNext;
931     VkFramebufferCreateFlags flags;
932     VkRenderPass renderPass;
933     uint32_t attachmentCount;
934     VkImageView* pAttachments;
935     uint32_t width;
936     uint32_t height;
937     uint32_t layers;
938     safe_VkFramebufferCreateInfo(const VkFramebufferCreateInfo* in_struct);
939     safe_VkFramebufferCreateInfo(const safe_VkFramebufferCreateInfo& copy_src);
940     safe_VkFramebufferCreateInfo& operator=(const safe_VkFramebufferCreateInfo& copy_src);
941     safe_VkFramebufferCreateInfo();
942     ~safe_VkFramebufferCreateInfo();
943     void initialize(const VkFramebufferCreateInfo* in_struct);
944     void initialize(const safe_VkFramebufferCreateInfo* copy_src);
ptrsafe_VkFramebufferCreateInfo945     VkFramebufferCreateInfo *ptr() { return reinterpret_cast<VkFramebufferCreateInfo *>(this); }
ptrsafe_VkFramebufferCreateInfo946     VkFramebufferCreateInfo const *ptr() const { return reinterpret_cast<VkFramebufferCreateInfo const *>(this); }
947 };
948 
949 struct safe_VkSubpassDescription {
950     VkSubpassDescriptionFlags flags;
951     VkPipelineBindPoint pipelineBindPoint;
952     uint32_t inputAttachmentCount;
953     const VkAttachmentReference* pInputAttachments;
954     uint32_t colorAttachmentCount;
955     const VkAttachmentReference* pColorAttachments;
956     const VkAttachmentReference* pResolveAttachments;
957     const VkAttachmentReference* pDepthStencilAttachment;
958     uint32_t preserveAttachmentCount;
959     const uint32_t* pPreserveAttachments;
960     safe_VkSubpassDescription(const VkSubpassDescription* in_struct);
961     safe_VkSubpassDescription(const safe_VkSubpassDescription& copy_src);
962     safe_VkSubpassDescription& operator=(const safe_VkSubpassDescription& copy_src);
963     safe_VkSubpassDescription();
964     ~safe_VkSubpassDescription();
965     void initialize(const VkSubpassDescription* in_struct);
966     void initialize(const safe_VkSubpassDescription* copy_src);
ptrsafe_VkSubpassDescription967     VkSubpassDescription *ptr() { return reinterpret_cast<VkSubpassDescription *>(this); }
ptrsafe_VkSubpassDescription968     VkSubpassDescription const *ptr() const { return reinterpret_cast<VkSubpassDescription const *>(this); }
969 };
970 
971 struct safe_VkRenderPassCreateInfo {
972     VkStructureType sType;
973     const void* pNext;
974     VkRenderPassCreateFlags flags;
975     uint32_t attachmentCount;
976     const VkAttachmentDescription* pAttachments;
977     uint32_t subpassCount;
978     safe_VkSubpassDescription* pSubpasses;
979     uint32_t dependencyCount;
980     const VkSubpassDependency* pDependencies;
981     safe_VkRenderPassCreateInfo(const VkRenderPassCreateInfo* in_struct);
982     safe_VkRenderPassCreateInfo(const safe_VkRenderPassCreateInfo& copy_src);
983     safe_VkRenderPassCreateInfo& operator=(const safe_VkRenderPassCreateInfo& copy_src);
984     safe_VkRenderPassCreateInfo();
985     ~safe_VkRenderPassCreateInfo();
986     void initialize(const VkRenderPassCreateInfo* in_struct);
987     void initialize(const safe_VkRenderPassCreateInfo* copy_src);
ptrsafe_VkRenderPassCreateInfo988     VkRenderPassCreateInfo *ptr() { return reinterpret_cast<VkRenderPassCreateInfo *>(this); }
ptrsafe_VkRenderPassCreateInfo989     VkRenderPassCreateInfo const *ptr() const { return reinterpret_cast<VkRenderPassCreateInfo const *>(this); }
990 };
991 
992 struct safe_VkCommandPoolCreateInfo {
993     VkStructureType sType;
994     const void* pNext;
995     VkCommandPoolCreateFlags flags;
996     uint32_t queueFamilyIndex;
997     safe_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo* in_struct);
998     safe_VkCommandPoolCreateInfo(const safe_VkCommandPoolCreateInfo& copy_src);
999     safe_VkCommandPoolCreateInfo& operator=(const safe_VkCommandPoolCreateInfo& copy_src);
1000     safe_VkCommandPoolCreateInfo();
1001     ~safe_VkCommandPoolCreateInfo();
1002     void initialize(const VkCommandPoolCreateInfo* in_struct);
1003     void initialize(const safe_VkCommandPoolCreateInfo* copy_src);
ptrsafe_VkCommandPoolCreateInfo1004     VkCommandPoolCreateInfo *ptr() { return reinterpret_cast<VkCommandPoolCreateInfo *>(this); }
ptrsafe_VkCommandPoolCreateInfo1005     VkCommandPoolCreateInfo const *ptr() const { return reinterpret_cast<VkCommandPoolCreateInfo const *>(this); }
1006 };
1007 
1008 struct safe_VkCommandBufferAllocateInfo {
1009     VkStructureType sType;
1010     const void* pNext;
1011     VkCommandPool commandPool;
1012     VkCommandBufferLevel level;
1013     uint32_t commandBufferCount;
1014     safe_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo* in_struct);
1015     safe_VkCommandBufferAllocateInfo(const safe_VkCommandBufferAllocateInfo& copy_src);
1016     safe_VkCommandBufferAllocateInfo& operator=(const safe_VkCommandBufferAllocateInfo& copy_src);
1017     safe_VkCommandBufferAllocateInfo();
1018     ~safe_VkCommandBufferAllocateInfo();
1019     void initialize(const VkCommandBufferAllocateInfo* in_struct);
1020     void initialize(const safe_VkCommandBufferAllocateInfo* copy_src);
ptrsafe_VkCommandBufferAllocateInfo1021     VkCommandBufferAllocateInfo *ptr() { return reinterpret_cast<VkCommandBufferAllocateInfo *>(this); }
ptrsafe_VkCommandBufferAllocateInfo1022     VkCommandBufferAllocateInfo const *ptr() const { return reinterpret_cast<VkCommandBufferAllocateInfo const *>(this); }
1023 };
1024 
1025 struct safe_VkCommandBufferInheritanceInfo {
1026     VkStructureType sType;
1027     const void* pNext;
1028     VkRenderPass renderPass;
1029     uint32_t subpass;
1030     VkFramebuffer framebuffer;
1031     VkBool32 occlusionQueryEnable;
1032     VkQueryControlFlags queryFlags;
1033     VkQueryPipelineStatisticFlags pipelineStatistics;
1034     safe_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo* in_struct);
1035     safe_VkCommandBufferInheritanceInfo(const safe_VkCommandBufferInheritanceInfo& copy_src);
1036     safe_VkCommandBufferInheritanceInfo& operator=(const safe_VkCommandBufferInheritanceInfo& copy_src);
1037     safe_VkCommandBufferInheritanceInfo();
1038     ~safe_VkCommandBufferInheritanceInfo();
1039     void initialize(const VkCommandBufferInheritanceInfo* in_struct);
1040     void initialize(const safe_VkCommandBufferInheritanceInfo* copy_src);
ptrsafe_VkCommandBufferInheritanceInfo1041     VkCommandBufferInheritanceInfo *ptr() { return reinterpret_cast<VkCommandBufferInheritanceInfo *>(this); }
ptrsafe_VkCommandBufferInheritanceInfo1042     VkCommandBufferInheritanceInfo const *ptr() const { return reinterpret_cast<VkCommandBufferInheritanceInfo const *>(this); }
1043 };
1044 
1045 struct safe_VkCommandBufferBeginInfo {
1046     VkStructureType sType;
1047     const void* pNext;
1048     VkCommandBufferUsageFlags flags;
1049     safe_VkCommandBufferInheritanceInfo* pInheritanceInfo;
1050     safe_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo* in_struct);
1051     safe_VkCommandBufferBeginInfo(const safe_VkCommandBufferBeginInfo& copy_src);
1052     safe_VkCommandBufferBeginInfo& operator=(const safe_VkCommandBufferBeginInfo& copy_src);
1053     safe_VkCommandBufferBeginInfo();
1054     ~safe_VkCommandBufferBeginInfo();
1055     void initialize(const VkCommandBufferBeginInfo* in_struct);
1056     void initialize(const safe_VkCommandBufferBeginInfo* copy_src);
ptrsafe_VkCommandBufferBeginInfo1057     VkCommandBufferBeginInfo *ptr() { return reinterpret_cast<VkCommandBufferBeginInfo *>(this); }
ptrsafe_VkCommandBufferBeginInfo1058     VkCommandBufferBeginInfo const *ptr() const { return reinterpret_cast<VkCommandBufferBeginInfo const *>(this); }
1059 };
1060 
1061 struct safe_VkRenderPassBeginInfo {
1062     VkStructureType sType;
1063     const void* pNext;
1064     VkRenderPass renderPass;
1065     VkFramebuffer framebuffer;
1066     VkRect2D renderArea;
1067     uint32_t clearValueCount;
1068     const VkClearValue* pClearValues;
1069     safe_VkRenderPassBeginInfo(const VkRenderPassBeginInfo* in_struct);
1070     safe_VkRenderPassBeginInfo(const safe_VkRenderPassBeginInfo& copy_src);
1071     safe_VkRenderPassBeginInfo& operator=(const safe_VkRenderPassBeginInfo& copy_src);
1072     safe_VkRenderPassBeginInfo();
1073     ~safe_VkRenderPassBeginInfo();
1074     void initialize(const VkRenderPassBeginInfo* in_struct);
1075     void initialize(const safe_VkRenderPassBeginInfo* copy_src);
ptrsafe_VkRenderPassBeginInfo1076     VkRenderPassBeginInfo *ptr() { return reinterpret_cast<VkRenderPassBeginInfo *>(this); }
ptrsafe_VkRenderPassBeginInfo1077     VkRenderPassBeginInfo const *ptr() const { return reinterpret_cast<VkRenderPassBeginInfo const *>(this); }
1078 };
1079 
1080 struct safe_VkPhysicalDeviceSubgroupProperties {
1081     VkStructureType sType;
1082     void* pNext;
1083     uint32_t subgroupSize;
1084     VkShaderStageFlags supportedStages;
1085     VkSubgroupFeatureFlags supportedOperations;
1086     VkBool32 quadOperationsInAllStages;
1087     safe_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties* in_struct);
1088     safe_VkPhysicalDeviceSubgroupProperties(const safe_VkPhysicalDeviceSubgroupProperties& copy_src);
1089     safe_VkPhysicalDeviceSubgroupProperties& operator=(const safe_VkPhysicalDeviceSubgroupProperties& copy_src);
1090     safe_VkPhysicalDeviceSubgroupProperties();
1091     ~safe_VkPhysicalDeviceSubgroupProperties();
1092     void initialize(const VkPhysicalDeviceSubgroupProperties* in_struct);
1093     void initialize(const safe_VkPhysicalDeviceSubgroupProperties* copy_src);
ptrsafe_VkPhysicalDeviceSubgroupProperties1094     VkPhysicalDeviceSubgroupProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceSubgroupProperties *>(this); }
ptrsafe_VkPhysicalDeviceSubgroupProperties1095     VkPhysicalDeviceSubgroupProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSubgroupProperties const *>(this); }
1096 };
1097 
1098 struct safe_VkBindBufferMemoryInfo {
1099     VkStructureType sType;
1100     const void* pNext;
1101     VkBuffer buffer;
1102     VkDeviceMemory memory;
1103     VkDeviceSize memoryOffset;
1104     safe_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo* in_struct);
1105     safe_VkBindBufferMemoryInfo(const safe_VkBindBufferMemoryInfo& copy_src);
1106     safe_VkBindBufferMemoryInfo& operator=(const safe_VkBindBufferMemoryInfo& copy_src);
1107     safe_VkBindBufferMemoryInfo();
1108     ~safe_VkBindBufferMemoryInfo();
1109     void initialize(const VkBindBufferMemoryInfo* in_struct);
1110     void initialize(const safe_VkBindBufferMemoryInfo* copy_src);
ptrsafe_VkBindBufferMemoryInfo1111     VkBindBufferMemoryInfo *ptr() { return reinterpret_cast<VkBindBufferMemoryInfo *>(this); }
ptrsafe_VkBindBufferMemoryInfo1112     VkBindBufferMemoryInfo const *ptr() const { return reinterpret_cast<VkBindBufferMemoryInfo const *>(this); }
1113 };
1114 
1115 struct safe_VkBindImageMemoryInfo {
1116     VkStructureType sType;
1117     const void* pNext;
1118     VkImage image;
1119     VkDeviceMemory memory;
1120     VkDeviceSize memoryOffset;
1121     safe_VkBindImageMemoryInfo(const VkBindImageMemoryInfo* in_struct);
1122     safe_VkBindImageMemoryInfo(const safe_VkBindImageMemoryInfo& copy_src);
1123     safe_VkBindImageMemoryInfo& operator=(const safe_VkBindImageMemoryInfo& copy_src);
1124     safe_VkBindImageMemoryInfo();
1125     ~safe_VkBindImageMemoryInfo();
1126     void initialize(const VkBindImageMemoryInfo* in_struct);
1127     void initialize(const safe_VkBindImageMemoryInfo* copy_src);
ptrsafe_VkBindImageMemoryInfo1128     VkBindImageMemoryInfo *ptr() { return reinterpret_cast<VkBindImageMemoryInfo *>(this); }
ptrsafe_VkBindImageMemoryInfo1129     VkBindImageMemoryInfo const *ptr() const { return reinterpret_cast<VkBindImageMemoryInfo const *>(this); }
1130 };
1131 
1132 struct safe_VkPhysicalDevice16BitStorageFeatures {
1133     VkStructureType sType;
1134     void* pNext;
1135     VkBool32 storageBuffer16BitAccess;
1136     VkBool32 uniformAndStorageBuffer16BitAccess;
1137     VkBool32 storagePushConstant16;
1138     VkBool32 storageInputOutput16;
1139     safe_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures* in_struct);
1140     safe_VkPhysicalDevice16BitStorageFeatures(const safe_VkPhysicalDevice16BitStorageFeatures& copy_src);
1141     safe_VkPhysicalDevice16BitStorageFeatures& operator=(const safe_VkPhysicalDevice16BitStorageFeatures& copy_src);
1142     safe_VkPhysicalDevice16BitStorageFeatures();
1143     ~safe_VkPhysicalDevice16BitStorageFeatures();
1144     void initialize(const VkPhysicalDevice16BitStorageFeatures* in_struct);
1145     void initialize(const safe_VkPhysicalDevice16BitStorageFeatures* copy_src);
ptrsafe_VkPhysicalDevice16BitStorageFeatures1146     VkPhysicalDevice16BitStorageFeatures *ptr() { return reinterpret_cast<VkPhysicalDevice16BitStorageFeatures *>(this); }
ptrsafe_VkPhysicalDevice16BitStorageFeatures1147     VkPhysicalDevice16BitStorageFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDevice16BitStorageFeatures const *>(this); }
1148 };
1149 
1150 struct safe_VkMemoryDedicatedRequirements {
1151     VkStructureType sType;
1152     void* pNext;
1153     VkBool32 prefersDedicatedAllocation;
1154     VkBool32 requiresDedicatedAllocation;
1155     safe_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements* in_struct);
1156     safe_VkMemoryDedicatedRequirements(const safe_VkMemoryDedicatedRequirements& copy_src);
1157     safe_VkMemoryDedicatedRequirements& operator=(const safe_VkMemoryDedicatedRequirements& copy_src);
1158     safe_VkMemoryDedicatedRequirements();
1159     ~safe_VkMemoryDedicatedRequirements();
1160     void initialize(const VkMemoryDedicatedRequirements* in_struct);
1161     void initialize(const safe_VkMemoryDedicatedRequirements* copy_src);
ptrsafe_VkMemoryDedicatedRequirements1162     VkMemoryDedicatedRequirements *ptr() { return reinterpret_cast<VkMemoryDedicatedRequirements *>(this); }
ptrsafe_VkMemoryDedicatedRequirements1163     VkMemoryDedicatedRequirements const *ptr() const { return reinterpret_cast<VkMemoryDedicatedRequirements const *>(this); }
1164 };
1165 
1166 struct safe_VkMemoryDedicatedAllocateInfo {
1167     VkStructureType sType;
1168     const void* pNext;
1169     VkImage image;
1170     VkBuffer buffer;
1171     safe_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo* in_struct);
1172     safe_VkMemoryDedicatedAllocateInfo(const safe_VkMemoryDedicatedAllocateInfo& copy_src);
1173     safe_VkMemoryDedicatedAllocateInfo& operator=(const safe_VkMemoryDedicatedAllocateInfo& copy_src);
1174     safe_VkMemoryDedicatedAllocateInfo();
1175     ~safe_VkMemoryDedicatedAllocateInfo();
1176     void initialize(const VkMemoryDedicatedAllocateInfo* in_struct);
1177     void initialize(const safe_VkMemoryDedicatedAllocateInfo* copy_src);
ptrsafe_VkMemoryDedicatedAllocateInfo1178     VkMemoryDedicatedAllocateInfo *ptr() { return reinterpret_cast<VkMemoryDedicatedAllocateInfo *>(this); }
ptrsafe_VkMemoryDedicatedAllocateInfo1179     VkMemoryDedicatedAllocateInfo const *ptr() const { return reinterpret_cast<VkMemoryDedicatedAllocateInfo const *>(this); }
1180 };
1181 
1182 struct safe_VkMemoryAllocateFlagsInfo {
1183     VkStructureType sType;
1184     const void* pNext;
1185     VkMemoryAllocateFlags flags;
1186     uint32_t deviceMask;
1187     safe_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo* in_struct);
1188     safe_VkMemoryAllocateFlagsInfo(const safe_VkMemoryAllocateFlagsInfo& copy_src);
1189     safe_VkMemoryAllocateFlagsInfo& operator=(const safe_VkMemoryAllocateFlagsInfo& copy_src);
1190     safe_VkMemoryAllocateFlagsInfo();
1191     ~safe_VkMemoryAllocateFlagsInfo();
1192     void initialize(const VkMemoryAllocateFlagsInfo* in_struct);
1193     void initialize(const safe_VkMemoryAllocateFlagsInfo* copy_src);
ptrsafe_VkMemoryAllocateFlagsInfo1194     VkMemoryAllocateFlagsInfo *ptr() { return reinterpret_cast<VkMemoryAllocateFlagsInfo *>(this); }
ptrsafe_VkMemoryAllocateFlagsInfo1195     VkMemoryAllocateFlagsInfo const *ptr() const { return reinterpret_cast<VkMemoryAllocateFlagsInfo const *>(this); }
1196 };
1197 
1198 struct safe_VkDeviceGroupRenderPassBeginInfo {
1199     VkStructureType sType;
1200     const void* pNext;
1201     uint32_t deviceMask;
1202     uint32_t deviceRenderAreaCount;
1203     const VkRect2D* pDeviceRenderAreas;
1204     safe_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo* in_struct);
1205     safe_VkDeviceGroupRenderPassBeginInfo(const safe_VkDeviceGroupRenderPassBeginInfo& copy_src);
1206     safe_VkDeviceGroupRenderPassBeginInfo& operator=(const safe_VkDeviceGroupRenderPassBeginInfo& copy_src);
1207     safe_VkDeviceGroupRenderPassBeginInfo();
1208     ~safe_VkDeviceGroupRenderPassBeginInfo();
1209     void initialize(const VkDeviceGroupRenderPassBeginInfo* in_struct);
1210     void initialize(const safe_VkDeviceGroupRenderPassBeginInfo* copy_src);
ptrsafe_VkDeviceGroupRenderPassBeginInfo1211     VkDeviceGroupRenderPassBeginInfo *ptr() { return reinterpret_cast<VkDeviceGroupRenderPassBeginInfo *>(this); }
ptrsafe_VkDeviceGroupRenderPassBeginInfo1212     VkDeviceGroupRenderPassBeginInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupRenderPassBeginInfo const *>(this); }
1213 };
1214 
1215 struct safe_VkDeviceGroupCommandBufferBeginInfo {
1216     VkStructureType sType;
1217     const void* pNext;
1218     uint32_t deviceMask;
1219     safe_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo* in_struct);
1220     safe_VkDeviceGroupCommandBufferBeginInfo(const safe_VkDeviceGroupCommandBufferBeginInfo& copy_src);
1221     safe_VkDeviceGroupCommandBufferBeginInfo& operator=(const safe_VkDeviceGroupCommandBufferBeginInfo& copy_src);
1222     safe_VkDeviceGroupCommandBufferBeginInfo();
1223     ~safe_VkDeviceGroupCommandBufferBeginInfo();
1224     void initialize(const VkDeviceGroupCommandBufferBeginInfo* in_struct);
1225     void initialize(const safe_VkDeviceGroupCommandBufferBeginInfo* copy_src);
ptrsafe_VkDeviceGroupCommandBufferBeginInfo1226     VkDeviceGroupCommandBufferBeginInfo *ptr() { return reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo *>(this); }
ptrsafe_VkDeviceGroupCommandBufferBeginInfo1227     VkDeviceGroupCommandBufferBeginInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo const *>(this); }
1228 };
1229 
1230 struct safe_VkDeviceGroupSubmitInfo {
1231     VkStructureType sType;
1232     const void* pNext;
1233     uint32_t waitSemaphoreCount;
1234     const uint32_t* pWaitSemaphoreDeviceIndices;
1235     uint32_t commandBufferCount;
1236     const uint32_t* pCommandBufferDeviceMasks;
1237     uint32_t signalSemaphoreCount;
1238     const uint32_t* pSignalSemaphoreDeviceIndices;
1239     safe_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo* in_struct);
1240     safe_VkDeviceGroupSubmitInfo(const safe_VkDeviceGroupSubmitInfo& copy_src);
1241     safe_VkDeviceGroupSubmitInfo& operator=(const safe_VkDeviceGroupSubmitInfo& copy_src);
1242     safe_VkDeviceGroupSubmitInfo();
1243     ~safe_VkDeviceGroupSubmitInfo();
1244     void initialize(const VkDeviceGroupSubmitInfo* in_struct);
1245     void initialize(const safe_VkDeviceGroupSubmitInfo* copy_src);
ptrsafe_VkDeviceGroupSubmitInfo1246     VkDeviceGroupSubmitInfo *ptr() { return reinterpret_cast<VkDeviceGroupSubmitInfo *>(this); }
ptrsafe_VkDeviceGroupSubmitInfo1247     VkDeviceGroupSubmitInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupSubmitInfo const *>(this); }
1248 };
1249 
1250 struct safe_VkDeviceGroupBindSparseInfo {
1251     VkStructureType sType;
1252     const void* pNext;
1253     uint32_t resourceDeviceIndex;
1254     uint32_t memoryDeviceIndex;
1255     safe_VkDeviceGroupBindSparseInfo(const VkDeviceGroupBindSparseInfo* in_struct);
1256     safe_VkDeviceGroupBindSparseInfo(const safe_VkDeviceGroupBindSparseInfo& copy_src);
1257     safe_VkDeviceGroupBindSparseInfo& operator=(const safe_VkDeviceGroupBindSparseInfo& copy_src);
1258     safe_VkDeviceGroupBindSparseInfo();
1259     ~safe_VkDeviceGroupBindSparseInfo();
1260     void initialize(const VkDeviceGroupBindSparseInfo* in_struct);
1261     void initialize(const safe_VkDeviceGroupBindSparseInfo* copy_src);
ptrsafe_VkDeviceGroupBindSparseInfo1262     VkDeviceGroupBindSparseInfo *ptr() { return reinterpret_cast<VkDeviceGroupBindSparseInfo *>(this); }
ptrsafe_VkDeviceGroupBindSparseInfo1263     VkDeviceGroupBindSparseInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupBindSparseInfo const *>(this); }
1264 };
1265 
1266 struct safe_VkBindBufferMemoryDeviceGroupInfo {
1267     VkStructureType sType;
1268     const void* pNext;
1269     uint32_t deviceIndexCount;
1270     const uint32_t* pDeviceIndices;
1271     safe_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo* in_struct);
1272     safe_VkBindBufferMemoryDeviceGroupInfo(const safe_VkBindBufferMemoryDeviceGroupInfo& copy_src);
1273     safe_VkBindBufferMemoryDeviceGroupInfo& operator=(const safe_VkBindBufferMemoryDeviceGroupInfo& copy_src);
1274     safe_VkBindBufferMemoryDeviceGroupInfo();
1275     ~safe_VkBindBufferMemoryDeviceGroupInfo();
1276     void initialize(const VkBindBufferMemoryDeviceGroupInfo* in_struct);
1277     void initialize(const safe_VkBindBufferMemoryDeviceGroupInfo* copy_src);
ptrsafe_VkBindBufferMemoryDeviceGroupInfo1278     VkBindBufferMemoryDeviceGroupInfo *ptr() { return reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo *>(this); }
ptrsafe_VkBindBufferMemoryDeviceGroupInfo1279     VkBindBufferMemoryDeviceGroupInfo const *ptr() const { return reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo const *>(this); }
1280 };
1281 
1282 struct safe_VkBindImageMemoryDeviceGroupInfo {
1283     VkStructureType sType;
1284     const void* pNext;
1285     uint32_t deviceIndexCount;
1286     const uint32_t* pDeviceIndices;
1287     uint32_t splitInstanceBindRegionCount;
1288     const VkRect2D* pSplitInstanceBindRegions;
1289     safe_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo* in_struct);
1290     safe_VkBindImageMemoryDeviceGroupInfo(const safe_VkBindImageMemoryDeviceGroupInfo& copy_src);
1291     safe_VkBindImageMemoryDeviceGroupInfo& operator=(const safe_VkBindImageMemoryDeviceGroupInfo& copy_src);
1292     safe_VkBindImageMemoryDeviceGroupInfo();
1293     ~safe_VkBindImageMemoryDeviceGroupInfo();
1294     void initialize(const VkBindImageMemoryDeviceGroupInfo* in_struct);
1295     void initialize(const safe_VkBindImageMemoryDeviceGroupInfo* copy_src);
ptrsafe_VkBindImageMemoryDeviceGroupInfo1296     VkBindImageMemoryDeviceGroupInfo *ptr() { return reinterpret_cast<VkBindImageMemoryDeviceGroupInfo *>(this); }
ptrsafe_VkBindImageMemoryDeviceGroupInfo1297     VkBindImageMemoryDeviceGroupInfo const *ptr() const { return reinterpret_cast<VkBindImageMemoryDeviceGroupInfo const *>(this); }
1298 };
1299 
1300 struct safe_VkPhysicalDeviceGroupProperties {
1301     VkStructureType sType;
1302     void* pNext;
1303     uint32_t physicalDeviceCount;
1304     VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
1305     VkBool32 subsetAllocation;
1306     safe_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties* in_struct);
1307     safe_VkPhysicalDeviceGroupProperties(const safe_VkPhysicalDeviceGroupProperties& copy_src);
1308     safe_VkPhysicalDeviceGroupProperties& operator=(const safe_VkPhysicalDeviceGroupProperties& copy_src);
1309     safe_VkPhysicalDeviceGroupProperties();
1310     ~safe_VkPhysicalDeviceGroupProperties();
1311     void initialize(const VkPhysicalDeviceGroupProperties* in_struct);
1312     void initialize(const safe_VkPhysicalDeviceGroupProperties* copy_src);
ptrsafe_VkPhysicalDeviceGroupProperties1313     VkPhysicalDeviceGroupProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceGroupProperties *>(this); }
ptrsafe_VkPhysicalDeviceGroupProperties1314     VkPhysicalDeviceGroupProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceGroupProperties const *>(this); }
1315 };
1316 
1317 struct safe_VkDeviceGroupDeviceCreateInfo {
1318     VkStructureType sType;
1319     const void* pNext;
1320     uint32_t physicalDeviceCount;
1321     VkPhysicalDevice* pPhysicalDevices;
1322     safe_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo* in_struct);
1323     safe_VkDeviceGroupDeviceCreateInfo(const safe_VkDeviceGroupDeviceCreateInfo& copy_src);
1324     safe_VkDeviceGroupDeviceCreateInfo& operator=(const safe_VkDeviceGroupDeviceCreateInfo& copy_src);
1325     safe_VkDeviceGroupDeviceCreateInfo();
1326     ~safe_VkDeviceGroupDeviceCreateInfo();
1327     void initialize(const VkDeviceGroupDeviceCreateInfo* in_struct);
1328     void initialize(const safe_VkDeviceGroupDeviceCreateInfo* copy_src);
ptrsafe_VkDeviceGroupDeviceCreateInfo1329     VkDeviceGroupDeviceCreateInfo *ptr() { return reinterpret_cast<VkDeviceGroupDeviceCreateInfo *>(this); }
ptrsafe_VkDeviceGroupDeviceCreateInfo1330     VkDeviceGroupDeviceCreateInfo const *ptr() const { return reinterpret_cast<VkDeviceGroupDeviceCreateInfo const *>(this); }
1331 };
1332 
1333 struct safe_VkBufferMemoryRequirementsInfo2 {
1334     VkStructureType sType;
1335     const void* pNext;
1336     VkBuffer buffer;
1337     safe_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2* in_struct);
1338     safe_VkBufferMemoryRequirementsInfo2(const safe_VkBufferMemoryRequirementsInfo2& copy_src);
1339     safe_VkBufferMemoryRequirementsInfo2& operator=(const safe_VkBufferMemoryRequirementsInfo2& copy_src);
1340     safe_VkBufferMemoryRequirementsInfo2();
1341     ~safe_VkBufferMemoryRequirementsInfo2();
1342     void initialize(const VkBufferMemoryRequirementsInfo2* in_struct);
1343     void initialize(const safe_VkBufferMemoryRequirementsInfo2* copy_src);
ptrsafe_VkBufferMemoryRequirementsInfo21344     VkBufferMemoryRequirementsInfo2 *ptr() { return reinterpret_cast<VkBufferMemoryRequirementsInfo2 *>(this); }
ptrsafe_VkBufferMemoryRequirementsInfo21345     VkBufferMemoryRequirementsInfo2 const *ptr() const { return reinterpret_cast<VkBufferMemoryRequirementsInfo2 const *>(this); }
1346 };
1347 
1348 struct safe_VkImageMemoryRequirementsInfo2 {
1349     VkStructureType sType;
1350     const void* pNext;
1351     VkImage image;
1352     safe_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2* in_struct);
1353     safe_VkImageMemoryRequirementsInfo2(const safe_VkImageMemoryRequirementsInfo2& copy_src);
1354     safe_VkImageMemoryRequirementsInfo2& operator=(const safe_VkImageMemoryRequirementsInfo2& copy_src);
1355     safe_VkImageMemoryRequirementsInfo2();
1356     ~safe_VkImageMemoryRequirementsInfo2();
1357     void initialize(const VkImageMemoryRequirementsInfo2* in_struct);
1358     void initialize(const safe_VkImageMemoryRequirementsInfo2* copy_src);
ptrsafe_VkImageMemoryRequirementsInfo21359     VkImageMemoryRequirementsInfo2 *ptr() { return reinterpret_cast<VkImageMemoryRequirementsInfo2 *>(this); }
ptrsafe_VkImageMemoryRequirementsInfo21360     VkImageMemoryRequirementsInfo2 const *ptr() const { return reinterpret_cast<VkImageMemoryRequirementsInfo2 const *>(this); }
1361 };
1362 
1363 struct safe_VkImageSparseMemoryRequirementsInfo2 {
1364     VkStructureType sType;
1365     const void* pNext;
1366     VkImage image;
1367     safe_VkImageSparseMemoryRequirementsInfo2(const VkImageSparseMemoryRequirementsInfo2* in_struct);
1368     safe_VkImageSparseMemoryRequirementsInfo2(const safe_VkImageSparseMemoryRequirementsInfo2& copy_src);
1369     safe_VkImageSparseMemoryRequirementsInfo2& operator=(const safe_VkImageSparseMemoryRequirementsInfo2& copy_src);
1370     safe_VkImageSparseMemoryRequirementsInfo2();
1371     ~safe_VkImageSparseMemoryRequirementsInfo2();
1372     void initialize(const VkImageSparseMemoryRequirementsInfo2* in_struct);
1373     void initialize(const safe_VkImageSparseMemoryRequirementsInfo2* copy_src);
ptrsafe_VkImageSparseMemoryRequirementsInfo21374     VkImageSparseMemoryRequirementsInfo2 *ptr() { return reinterpret_cast<VkImageSparseMemoryRequirementsInfo2 *>(this); }
ptrsafe_VkImageSparseMemoryRequirementsInfo21375     VkImageSparseMemoryRequirementsInfo2 const *ptr() const { return reinterpret_cast<VkImageSparseMemoryRequirementsInfo2 const *>(this); }
1376 };
1377 
1378 struct safe_VkMemoryRequirements2 {
1379     VkStructureType sType;
1380     void* pNext;
1381     VkMemoryRequirements memoryRequirements;
1382     safe_VkMemoryRequirements2(const VkMemoryRequirements2* in_struct);
1383     safe_VkMemoryRequirements2(const safe_VkMemoryRequirements2& copy_src);
1384     safe_VkMemoryRequirements2& operator=(const safe_VkMemoryRequirements2& copy_src);
1385     safe_VkMemoryRequirements2();
1386     ~safe_VkMemoryRequirements2();
1387     void initialize(const VkMemoryRequirements2* in_struct);
1388     void initialize(const safe_VkMemoryRequirements2* copy_src);
ptrsafe_VkMemoryRequirements21389     VkMemoryRequirements2 *ptr() { return reinterpret_cast<VkMemoryRequirements2 *>(this); }
ptrsafe_VkMemoryRequirements21390     VkMemoryRequirements2 const *ptr() const { return reinterpret_cast<VkMemoryRequirements2 const *>(this); }
1391 };
1392 
1393 struct safe_VkSparseImageMemoryRequirements2 {
1394     VkStructureType sType;
1395     void* pNext;
1396     VkSparseImageMemoryRequirements memoryRequirements;
1397     safe_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2* in_struct);
1398     safe_VkSparseImageMemoryRequirements2(const safe_VkSparseImageMemoryRequirements2& copy_src);
1399     safe_VkSparseImageMemoryRequirements2& operator=(const safe_VkSparseImageMemoryRequirements2& copy_src);
1400     safe_VkSparseImageMemoryRequirements2();
1401     ~safe_VkSparseImageMemoryRequirements2();
1402     void initialize(const VkSparseImageMemoryRequirements2* in_struct);
1403     void initialize(const safe_VkSparseImageMemoryRequirements2* copy_src);
ptrsafe_VkSparseImageMemoryRequirements21404     VkSparseImageMemoryRequirements2 *ptr() { return reinterpret_cast<VkSparseImageMemoryRequirements2 *>(this); }
ptrsafe_VkSparseImageMemoryRequirements21405     VkSparseImageMemoryRequirements2 const *ptr() const { return reinterpret_cast<VkSparseImageMemoryRequirements2 const *>(this); }
1406 };
1407 
1408 struct safe_VkPhysicalDeviceFeatures2 {
1409     VkStructureType sType;
1410     void* pNext;
1411     VkPhysicalDeviceFeatures features;
1412     safe_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2* in_struct);
1413     safe_VkPhysicalDeviceFeatures2(const safe_VkPhysicalDeviceFeatures2& copy_src);
1414     safe_VkPhysicalDeviceFeatures2& operator=(const safe_VkPhysicalDeviceFeatures2& copy_src);
1415     safe_VkPhysicalDeviceFeatures2();
1416     ~safe_VkPhysicalDeviceFeatures2();
1417     void initialize(const VkPhysicalDeviceFeatures2* in_struct);
1418     void initialize(const safe_VkPhysicalDeviceFeatures2* copy_src);
ptrsafe_VkPhysicalDeviceFeatures21419     VkPhysicalDeviceFeatures2 *ptr() { return reinterpret_cast<VkPhysicalDeviceFeatures2 *>(this); }
ptrsafe_VkPhysicalDeviceFeatures21420     VkPhysicalDeviceFeatures2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFeatures2 const *>(this); }
1421 };
1422 
1423 struct safe_VkPhysicalDeviceProperties2 {
1424     VkStructureType sType;
1425     void* pNext;
1426     VkPhysicalDeviceProperties properties;
1427     safe_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2* in_struct);
1428     safe_VkPhysicalDeviceProperties2(const safe_VkPhysicalDeviceProperties2& copy_src);
1429     safe_VkPhysicalDeviceProperties2& operator=(const safe_VkPhysicalDeviceProperties2& copy_src);
1430     safe_VkPhysicalDeviceProperties2();
1431     ~safe_VkPhysicalDeviceProperties2();
1432     void initialize(const VkPhysicalDeviceProperties2* in_struct);
1433     void initialize(const safe_VkPhysicalDeviceProperties2* copy_src);
ptrsafe_VkPhysicalDeviceProperties21434     VkPhysicalDeviceProperties2 *ptr() { return reinterpret_cast<VkPhysicalDeviceProperties2 *>(this); }
ptrsafe_VkPhysicalDeviceProperties21435     VkPhysicalDeviceProperties2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceProperties2 const *>(this); }
1436 };
1437 
1438 struct safe_VkFormatProperties2 {
1439     VkStructureType sType;
1440     void* pNext;
1441     VkFormatProperties formatProperties;
1442     safe_VkFormatProperties2(const VkFormatProperties2* in_struct);
1443     safe_VkFormatProperties2(const safe_VkFormatProperties2& copy_src);
1444     safe_VkFormatProperties2& operator=(const safe_VkFormatProperties2& copy_src);
1445     safe_VkFormatProperties2();
1446     ~safe_VkFormatProperties2();
1447     void initialize(const VkFormatProperties2* in_struct);
1448     void initialize(const safe_VkFormatProperties2* copy_src);
ptrsafe_VkFormatProperties21449     VkFormatProperties2 *ptr() { return reinterpret_cast<VkFormatProperties2 *>(this); }
ptrsafe_VkFormatProperties21450     VkFormatProperties2 const *ptr() const { return reinterpret_cast<VkFormatProperties2 const *>(this); }
1451 };
1452 
1453 struct safe_VkImageFormatProperties2 {
1454     VkStructureType sType;
1455     void* pNext;
1456     VkImageFormatProperties imageFormatProperties;
1457     safe_VkImageFormatProperties2(const VkImageFormatProperties2* in_struct);
1458     safe_VkImageFormatProperties2(const safe_VkImageFormatProperties2& copy_src);
1459     safe_VkImageFormatProperties2& operator=(const safe_VkImageFormatProperties2& copy_src);
1460     safe_VkImageFormatProperties2();
1461     ~safe_VkImageFormatProperties2();
1462     void initialize(const VkImageFormatProperties2* in_struct);
1463     void initialize(const safe_VkImageFormatProperties2* copy_src);
ptrsafe_VkImageFormatProperties21464     VkImageFormatProperties2 *ptr() { return reinterpret_cast<VkImageFormatProperties2 *>(this); }
ptrsafe_VkImageFormatProperties21465     VkImageFormatProperties2 const *ptr() const { return reinterpret_cast<VkImageFormatProperties2 const *>(this); }
1466 };
1467 
1468 struct safe_VkPhysicalDeviceImageFormatInfo2 {
1469     VkStructureType sType;
1470     const void* pNext;
1471     VkFormat format;
1472     VkImageType type;
1473     VkImageTiling tiling;
1474     VkImageUsageFlags usage;
1475     VkImageCreateFlags flags;
1476     safe_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2* in_struct);
1477     safe_VkPhysicalDeviceImageFormatInfo2(const safe_VkPhysicalDeviceImageFormatInfo2& copy_src);
1478     safe_VkPhysicalDeviceImageFormatInfo2& operator=(const safe_VkPhysicalDeviceImageFormatInfo2& copy_src);
1479     safe_VkPhysicalDeviceImageFormatInfo2();
1480     ~safe_VkPhysicalDeviceImageFormatInfo2();
1481     void initialize(const VkPhysicalDeviceImageFormatInfo2* in_struct);
1482     void initialize(const safe_VkPhysicalDeviceImageFormatInfo2* copy_src);
ptrsafe_VkPhysicalDeviceImageFormatInfo21483     VkPhysicalDeviceImageFormatInfo2 *ptr() { return reinterpret_cast<VkPhysicalDeviceImageFormatInfo2 *>(this); }
ptrsafe_VkPhysicalDeviceImageFormatInfo21484     VkPhysicalDeviceImageFormatInfo2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceImageFormatInfo2 const *>(this); }
1485 };
1486 
1487 struct safe_VkQueueFamilyProperties2 {
1488     VkStructureType sType;
1489     void* pNext;
1490     VkQueueFamilyProperties queueFamilyProperties;
1491     safe_VkQueueFamilyProperties2(const VkQueueFamilyProperties2* in_struct);
1492     safe_VkQueueFamilyProperties2(const safe_VkQueueFamilyProperties2& copy_src);
1493     safe_VkQueueFamilyProperties2& operator=(const safe_VkQueueFamilyProperties2& copy_src);
1494     safe_VkQueueFamilyProperties2();
1495     ~safe_VkQueueFamilyProperties2();
1496     void initialize(const VkQueueFamilyProperties2* in_struct);
1497     void initialize(const safe_VkQueueFamilyProperties2* copy_src);
ptrsafe_VkQueueFamilyProperties21498     VkQueueFamilyProperties2 *ptr() { return reinterpret_cast<VkQueueFamilyProperties2 *>(this); }
ptrsafe_VkQueueFamilyProperties21499     VkQueueFamilyProperties2 const *ptr() const { return reinterpret_cast<VkQueueFamilyProperties2 const *>(this); }
1500 };
1501 
1502 struct safe_VkPhysicalDeviceMemoryProperties2 {
1503     VkStructureType sType;
1504     void* pNext;
1505     VkPhysicalDeviceMemoryProperties memoryProperties;
1506     safe_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2* in_struct);
1507     safe_VkPhysicalDeviceMemoryProperties2(const safe_VkPhysicalDeviceMemoryProperties2& copy_src);
1508     safe_VkPhysicalDeviceMemoryProperties2& operator=(const safe_VkPhysicalDeviceMemoryProperties2& copy_src);
1509     safe_VkPhysicalDeviceMemoryProperties2();
1510     ~safe_VkPhysicalDeviceMemoryProperties2();
1511     void initialize(const VkPhysicalDeviceMemoryProperties2* in_struct);
1512     void initialize(const safe_VkPhysicalDeviceMemoryProperties2* copy_src);
ptrsafe_VkPhysicalDeviceMemoryProperties21513     VkPhysicalDeviceMemoryProperties2 *ptr() { return reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>(this); }
ptrsafe_VkPhysicalDeviceMemoryProperties21514     VkPhysicalDeviceMemoryProperties2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMemoryProperties2 const *>(this); }
1515 };
1516 
1517 struct safe_VkSparseImageFormatProperties2 {
1518     VkStructureType sType;
1519     void* pNext;
1520     VkSparseImageFormatProperties properties;
1521     safe_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2* in_struct);
1522     safe_VkSparseImageFormatProperties2(const safe_VkSparseImageFormatProperties2& copy_src);
1523     safe_VkSparseImageFormatProperties2& operator=(const safe_VkSparseImageFormatProperties2& copy_src);
1524     safe_VkSparseImageFormatProperties2();
1525     ~safe_VkSparseImageFormatProperties2();
1526     void initialize(const VkSparseImageFormatProperties2* in_struct);
1527     void initialize(const safe_VkSparseImageFormatProperties2* copy_src);
ptrsafe_VkSparseImageFormatProperties21528     VkSparseImageFormatProperties2 *ptr() { return reinterpret_cast<VkSparseImageFormatProperties2 *>(this); }
ptrsafe_VkSparseImageFormatProperties21529     VkSparseImageFormatProperties2 const *ptr() const { return reinterpret_cast<VkSparseImageFormatProperties2 const *>(this); }
1530 };
1531 
1532 struct safe_VkPhysicalDeviceSparseImageFormatInfo2 {
1533     VkStructureType sType;
1534     const void* pNext;
1535     VkFormat format;
1536     VkImageType type;
1537     VkSampleCountFlagBits samples;
1538     VkImageUsageFlags usage;
1539     VkImageTiling tiling;
1540     safe_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct);
1541     safe_VkPhysicalDeviceSparseImageFormatInfo2(const safe_VkPhysicalDeviceSparseImageFormatInfo2& copy_src);
1542     safe_VkPhysicalDeviceSparseImageFormatInfo2& operator=(const safe_VkPhysicalDeviceSparseImageFormatInfo2& copy_src);
1543     safe_VkPhysicalDeviceSparseImageFormatInfo2();
1544     ~safe_VkPhysicalDeviceSparseImageFormatInfo2();
1545     void initialize(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct);
1546     void initialize(const safe_VkPhysicalDeviceSparseImageFormatInfo2* copy_src);
ptrsafe_VkPhysicalDeviceSparseImageFormatInfo21547     VkPhysicalDeviceSparseImageFormatInfo2 *ptr() { return reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2 *>(this); }
ptrsafe_VkPhysicalDeviceSparseImageFormatInfo21548     VkPhysicalDeviceSparseImageFormatInfo2 const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2 const *>(this); }
1549 };
1550 
1551 struct safe_VkPhysicalDevicePointClippingProperties {
1552     VkStructureType sType;
1553     void* pNext;
1554     VkPointClippingBehavior pointClippingBehavior;
1555     safe_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties* in_struct);
1556     safe_VkPhysicalDevicePointClippingProperties(const safe_VkPhysicalDevicePointClippingProperties& copy_src);
1557     safe_VkPhysicalDevicePointClippingProperties& operator=(const safe_VkPhysicalDevicePointClippingProperties& copy_src);
1558     safe_VkPhysicalDevicePointClippingProperties();
1559     ~safe_VkPhysicalDevicePointClippingProperties();
1560     void initialize(const VkPhysicalDevicePointClippingProperties* in_struct);
1561     void initialize(const safe_VkPhysicalDevicePointClippingProperties* copy_src);
ptrsafe_VkPhysicalDevicePointClippingProperties1562     VkPhysicalDevicePointClippingProperties *ptr() { return reinterpret_cast<VkPhysicalDevicePointClippingProperties *>(this); }
ptrsafe_VkPhysicalDevicePointClippingProperties1563     VkPhysicalDevicePointClippingProperties const *ptr() const { return reinterpret_cast<VkPhysicalDevicePointClippingProperties const *>(this); }
1564 };
1565 
1566 struct safe_VkRenderPassInputAttachmentAspectCreateInfo {
1567     VkStructureType sType;
1568     const void* pNext;
1569     uint32_t aspectReferenceCount;
1570     const VkInputAttachmentAspectReference* pAspectReferences;
1571     safe_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct);
1572     safe_VkRenderPassInputAttachmentAspectCreateInfo(const safe_VkRenderPassInputAttachmentAspectCreateInfo& copy_src);
1573     safe_VkRenderPassInputAttachmentAspectCreateInfo& operator=(const safe_VkRenderPassInputAttachmentAspectCreateInfo& copy_src);
1574     safe_VkRenderPassInputAttachmentAspectCreateInfo();
1575     ~safe_VkRenderPassInputAttachmentAspectCreateInfo();
1576     void initialize(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct);
1577     void initialize(const safe_VkRenderPassInputAttachmentAspectCreateInfo* copy_src);
ptrsafe_VkRenderPassInputAttachmentAspectCreateInfo1578     VkRenderPassInputAttachmentAspectCreateInfo *ptr() { return reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo *>(this); }
ptrsafe_VkRenderPassInputAttachmentAspectCreateInfo1579     VkRenderPassInputAttachmentAspectCreateInfo const *ptr() const { return reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo const *>(this); }
1580 };
1581 
1582 struct safe_VkImageViewUsageCreateInfo {
1583     VkStructureType sType;
1584     const void* pNext;
1585     VkImageUsageFlags usage;
1586     safe_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo* in_struct);
1587     safe_VkImageViewUsageCreateInfo(const safe_VkImageViewUsageCreateInfo& copy_src);
1588     safe_VkImageViewUsageCreateInfo& operator=(const safe_VkImageViewUsageCreateInfo& copy_src);
1589     safe_VkImageViewUsageCreateInfo();
1590     ~safe_VkImageViewUsageCreateInfo();
1591     void initialize(const VkImageViewUsageCreateInfo* in_struct);
1592     void initialize(const safe_VkImageViewUsageCreateInfo* copy_src);
ptrsafe_VkImageViewUsageCreateInfo1593     VkImageViewUsageCreateInfo *ptr() { return reinterpret_cast<VkImageViewUsageCreateInfo *>(this); }
ptrsafe_VkImageViewUsageCreateInfo1594     VkImageViewUsageCreateInfo const *ptr() const { return reinterpret_cast<VkImageViewUsageCreateInfo const *>(this); }
1595 };
1596 
1597 struct safe_VkPipelineTessellationDomainOriginStateCreateInfo {
1598     VkStructureType sType;
1599     const void* pNext;
1600     VkTessellationDomainOrigin domainOrigin;
1601     safe_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct);
1602     safe_VkPipelineTessellationDomainOriginStateCreateInfo(const safe_VkPipelineTessellationDomainOriginStateCreateInfo& copy_src);
1603     safe_VkPipelineTessellationDomainOriginStateCreateInfo& operator=(const safe_VkPipelineTessellationDomainOriginStateCreateInfo& copy_src);
1604     safe_VkPipelineTessellationDomainOriginStateCreateInfo();
1605     ~safe_VkPipelineTessellationDomainOriginStateCreateInfo();
1606     void initialize(const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct);
1607     void initialize(const safe_VkPipelineTessellationDomainOriginStateCreateInfo* copy_src);
ptrsafe_VkPipelineTessellationDomainOriginStateCreateInfo1608     VkPipelineTessellationDomainOriginStateCreateInfo *ptr() { return reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo *>(this); }
ptrsafe_VkPipelineTessellationDomainOriginStateCreateInfo1609     VkPipelineTessellationDomainOriginStateCreateInfo const *ptr() const { return reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo const *>(this); }
1610 };
1611 
1612 struct safe_VkRenderPassMultiviewCreateInfo {
1613     VkStructureType sType;
1614     const void* pNext;
1615     uint32_t subpassCount;
1616     const uint32_t* pViewMasks;
1617     uint32_t dependencyCount;
1618     const int32_t* pViewOffsets;
1619     uint32_t correlationMaskCount;
1620     const uint32_t* pCorrelationMasks;
1621     safe_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo* in_struct);
1622     safe_VkRenderPassMultiviewCreateInfo(const safe_VkRenderPassMultiviewCreateInfo& copy_src);
1623     safe_VkRenderPassMultiviewCreateInfo& operator=(const safe_VkRenderPassMultiviewCreateInfo& copy_src);
1624     safe_VkRenderPassMultiviewCreateInfo();
1625     ~safe_VkRenderPassMultiviewCreateInfo();
1626     void initialize(const VkRenderPassMultiviewCreateInfo* in_struct);
1627     void initialize(const safe_VkRenderPassMultiviewCreateInfo* copy_src);
ptrsafe_VkRenderPassMultiviewCreateInfo1628     VkRenderPassMultiviewCreateInfo *ptr() { return reinterpret_cast<VkRenderPassMultiviewCreateInfo *>(this); }
ptrsafe_VkRenderPassMultiviewCreateInfo1629     VkRenderPassMultiviewCreateInfo const *ptr() const { return reinterpret_cast<VkRenderPassMultiviewCreateInfo const *>(this); }
1630 };
1631 
1632 struct safe_VkPhysicalDeviceMultiviewFeatures {
1633     VkStructureType sType;
1634     void* pNext;
1635     VkBool32 multiview;
1636     VkBool32 multiviewGeometryShader;
1637     VkBool32 multiviewTessellationShader;
1638     safe_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures* in_struct);
1639     safe_VkPhysicalDeviceMultiviewFeatures(const safe_VkPhysicalDeviceMultiviewFeatures& copy_src);
1640     safe_VkPhysicalDeviceMultiviewFeatures& operator=(const safe_VkPhysicalDeviceMultiviewFeatures& copy_src);
1641     safe_VkPhysicalDeviceMultiviewFeatures();
1642     ~safe_VkPhysicalDeviceMultiviewFeatures();
1643     void initialize(const VkPhysicalDeviceMultiviewFeatures* in_struct);
1644     void initialize(const safe_VkPhysicalDeviceMultiviewFeatures* copy_src);
ptrsafe_VkPhysicalDeviceMultiviewFeatures1645     VkPhysicalDeviceMultiviewFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceMultiviewFeatures *>(this); }
ptrsafe_VkPhysicalDeviceMultiviewFeatures1646     VkPhysicalDeviceMultiviewFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMultiviewFeatures const *>(this); }
1647 };
1648 
1649 struct safe_VkPhysicalDeviceMultiviewProperties {
1650     VkStructureType sType;
1651     void* pNext;
1652     uint32_t maxMultiviewViewCount;
1653     uint32_t maxMultiviewInstanceIndex;
1654     safe_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties* in_struct);
1655     safe_VkPhysicalDeviceMultiviewProperties(const safe_VkPhysicalDeviceMultiviewProperties& copy_src);
1656     safe_VkPhysicalDeviceMultiviewProperties& operator=(const safe_VkPhysicalDeviceMultiviewProperties& copy_src);
1657     safe_VkPhysicalDeviceMultiviewProperties();
1658     ~safe_VkPhysicalDeviceMultiviewProperties();
1659     void initialize(const VkPhysicalDeviceMultiviewProperties* in_struct);
1660     void initialize(const safe_VkPhysicalDeviceMultiviewProperties* copy_src);
ptrsafe_VkPhysicalDeviceMultiviewProperties1661     VkPhysicalDeviceMultiviewProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceMultiviewProperties *>(this); }
ptrsafe_VkPhysicalDeviceMultiviewProperties1662     VkPhysicalDeviceMultiviewProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMultiviewProperties const *>(this); }
1663 };
1664 
1665 struct safe_VkPhysicalDeviceVariablePointersFeatures {
1666     VkStructureType sType;
1667     void* pNext;
1668     VkBool32 variablePointersStorageBuffer;
1669     VkBool32 variablePointers;
1670     safe_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures* in_struct);
1671     safe_VkPhysicalDeviceVariablePointersFeatures(const safe_VkPhysicalDeviceVariablePointersFeatures& copy_src);
1672     safe_VkPhysicalDeviceVariablePointersFeatures& operator=(const safe_VkPhysicalDeviceVariablePointersFeatures& copy_src);
1673     safe_VkPhysicalDeviceVariablePointersFeatures();
1674     ~safe_VkPhysicalDeviceVariablePointersFeatures();
1675     void initialize(const VkPhysicalDeviceVariablePointersFeatures* in_struct);
1676     void initialize(const safe_VkPhysicalDeviceVariablePointersFeatures* copy_src);
ptrsafe_VkPhysicalDeviceVariablePointersFeatures1677     VkPhysicalDeviceVariablePointersFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures *>(this); }
ptrsafe_VkPhysicalDeviceVariablePointersFeatures1678     VkPhysicalDeviceVariablePointersFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures const *>(this); }
1679 };
1680 
1681 struct safe_VkPhysicalDeviceProtectedMemoryFeatures {
1682     VkStructureType sType;
1683     void* pNext;
1684     VkBool32 protectedMemory;
1685     safe_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct);
1686     safe_VkPhysicalDeviceProtectedMemoryFeatures(const safe_VkPhysicalDeviceProtectedMemoryFeatures& copy_src);
1687     safe_VkPhysicalDeviceProtectedMemoryFeatures& operator=(const safe_VkPhysicalDeviceProtectedMemoryFeatures& copy_src);
1688     safe_VkPhysicalDeviceProtectedMemoryFeatures();
1689     ~safe_VkPhysicalDeviceProtectedMemoryFeatures();
1690     void initialize(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct);
1691     void initialize(const safe_VkPhysicalDeviceProtectedMemoryFeatures* copy_src);
ptrsafe_VkPhysicalDeviceProtectedMemoryFeatures1692     VkPhysicalDeviceProtectedMemoryFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures *>(this); }
ptrsafe_VkPhysicalDeviceProtectedMemoryFeatures1693     VkPhysicalDeviceProtectedMemoryFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures const *>(this); }
1694 };
1695 
1696 struct safe_VkPhysicalDeviceProtectedMemoryProperties {
1697     VkStructureType sType;
1698     void* pNext;
1699     VkBool32 protectedNoFault;
1700     safe_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties* in_struct);
1701     safe_VkPhysicalDeviceProtectedMemoryProperties(const safe_VkPhysicalDeviceProtectedMemoryProperties& copy_src);
1702     safe_VkPhysicalDeviceProtectedMemoryProperties& operator=(const safe_VkPhysicalDeviceProtectedMemoryProperties& copy_src);
1703     safe_VkPhysicalDeviceProtectedMemoryProperties();
1704     ~safe_VkPhysicalDeviceProtectedMemoryProperties();
1705     void initialize(const VkPhysicalDeviceProtectedMemoryProperties* in_struct);
1706     void initialize(const safe_VkPhysicalDeviceProtectedMemoryProperties* copy_src);
ptrsafe_VkPhysicalDeviceProtectedMemoryProperties1707     VkPhysicalDeviceProtectedMemoryProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties *>(this); }
ptrsafe_VkPhysicalDeviceProtectedMemoryProperties1708     VkPhysicalDeviceProtectedMemoryProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties const *>(this); }
1709 };
1710 
1711 struct safe_VkDeviceQueueInfo2 {
1712     VkStructureType sType;
1713     const void* pNext;
1714     VkDeviceQueueCreateFlags flags;
1715     uint32_t queueFamilyIndex;
1716     uint32_t queueIndex;
1717     safe_VkDeviceQueueInfo2(const VkDeviceQueueInfo2* in_struct);
1718     safe_VkDeviceQueueInfo2(const safe_VkDeviceQueueInfo2& copy_src);
1719     safe_VkDeviceQueueInfo2& operator=(const safe_VkDeviceQueueInfo2& copy_src);
1720     safe_VkDeviceQueueInfo2();
1721     ~safe_VkDeviceQueueInfo2();
1722     void initialize(const VkDeviceQueueInfo2* in_struct);
1723     void initialize(const safe_VkDeviceQueueInfo2* copy_src);
ptrsafe_VkDeviceQueueInfo21724     VkDeviceQueueInfo2 *ptr() { return reinterpret_cast<VkDeviceQueueInfo2 *>(this); }
ptrsafe_VkDeviceQueueInfo21725     VkDeviceQueueInfo2 const *ptr() const { return reinterpret_cast<VkDeviceQueueInfo2 const *>(this); }
1726 };
1727 
1728 struct safe_VkProtectedSubmitInfo {
1729     VkStructureType sType;
1730     const void* pNext;
1731     VkBool32 protectedSubmit;
1732     safe_VkProtectedSubmitInfo(const VkProtectedSubmitInfo* in_struct);
1733     safe_VkProtectedSubmitInfo(const safe_VkProtectedSubmitInfo& copy_src);
1734     safe_VkProtectedSubmitInfo& operator=(const safe_VkProtectedSubmitInfo& copy_src);
1735     safe_VkProtectedSubmitInfo();
1736     ~safe_VkProtectedSubmitInfo();
1737     void initialize(const VkProtectedSubmitInfo* in_struct);
1738     void initialize(const safe_VkProtectedSubmitInfo* copy_src);
ptrsafe_VkProtectedSubmitInfo1739     VkProtectedSubmitInfo *ptr() { return reinterpret_cast<VkProtectedSubmitInfo *>(this); }
ptrsafe_VkProtectedSubmitInfo1740     VkProtectedSubmitInfo const *ptr() const { return reinterpret_cast<VkProtectedSubmitInfo const *>(this); }
1741 };
1742 
1743 struct safe_VkSamplerYcbcrConversionCreateInfo {
1744     VkStructureType sType;
1745     const void* pNext;
1746     VkFormat format;
1747     VkSamplerYcbcrModelConversion ycbcrModel;
1748     VkSamplerYcbcrRange ycbcrRange;
1749     VkComponentMapping components;
1750     VkChromaLocation xChromaOffset;
1751     VkChromaLocation yChromaOffset;
1752     VkFilter chromaFilter;
1753     VkBool32 forceExplicitReconstruction;
1754     safe_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo* in_struct);
1755     safe_VkSamplerYcbcrConversionCreateInfo(const safe_VkSamplerYcbcrConversionCreateInfo& copy_src);
1756     safe_VkSamplerYcbcrConversionCreateInfo& operator=(const safe_VkSamplerYcbcrConversionCreateInfo& copy_src);
1757     safe_VkSamplerYcbcrConversionCreateInfo();
1758     ~safe_VkSamplerYcbcrConversionCreateInfo();
1759     void initialize(const VkSamplerYcbcrConversionCreateInfo* in_struct);
1760     void initialize(const safe_VkSamplerYcbcrConversionCreateInfo* copy_src);
ptrsafe_VkSamplerYcbcrConversionCreateInfo1761     VkSamplerYcbcrConversionCreateInfo *ptr() { return reinterpret_cast<VkSamplerYcbcrConversionCreateInfo *>(this); }
ptrsafe_VkSamplerYcbcrConversionCreateInfo1762     VkSamplerYcbcrConversionCreateInfo const *ptr() const { return reinterpret_cast<VkSamplerYcbcrConversionCreateInfo const *>(this); }
1763 };
1764 
1765 struct safe_VkSamplerYcbcrConversionInfo {
1766     VkStructureType sType;
1767     const void* pNext;
1768     VkSamplerYcbcrConversion conversion;
1769     safe_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo* in_struct);
1770     safe_VkSamplerYcbcrConversionInfo(const safe_VkSamplerYcbcrConversionInfo& copy_src);
1771     safe_VkSamplerYcbcrConversionInfo& operator=(const safe_VkSamplerYcbcrConversionInfo& copy_src);
1772     safe_VkSamplerYcbcrConversionInfo();
1773     ~safe_VkSamplerYcbcrConversionInfo();
1774     void initialize(const VkSamplerYcbcrConversionInfo* in_struct);
1775     void initialize(const safe_VkSamplerYcbcrConversionInfo* copy_src);
ptrsafe_VkSamplerYcbcrConversionInfo1776     VkSamplerYcbcrConversionInfo *ptr() { return reinterpret_cast<VkSamplerYcbcrConversionInfo *>(this); }
ptrsafe_VkSamplerYcbcrConversionInfo1777     VkSamplerYcbcrConversionInfo const *ptr() const { return reinterpret_cast<VkSamplerYcbcrConversionInfo const *>(this); }
1778 };
1779 
1780 struct safe_VkBindImagePlaneMemoryInfo {
1781     VkStructureType sType;
1782     const void* pNext;
1783     VkImageAspectFlagBits planeAspect;
1784     safe_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo* in_struct);
1785     safe_VkBindImagePlaneMemoryInfo(const safe_VkBindImagePlaneMemoryInfo& copy_src);
1786     safe_VkBindImagePlaneMemoryInfo& operator=(const safe_VkBindImagePlaneMemoryInfo& copy_src);
1787     safe_VkBindImagePlaneMemoryInfo();
1788     ~safe_VkBindImagePlaneMemoryInfo();
1789     void initialize(const VkBindImagePlaneMemoryInfo* in_struct);
1790     void initialize(const safe_VkBindImagePlaneMemoryInfo* copy_src);
ptrsafe_VkBindImagePlaneMemoryInfo1791     VkBindImagePlaneMemoryInfo *ptr() { return reinterpret_cast<VkBindImagePlaneMemoryInfo *>(this); }
ptrsafe_VkBindImagePlaneMemoryInfo1792     VkBindImagePlaneMemoryInfo const *ptr() const { return reinterpret_cast<VkBindImagePlaneMemoryInfo const *>(this); }
1793 };
1794 
1795 struct safe_VkImagePlaneMemoryRequirementsInfo {
1796     VkStructureType sType;
1797     const void* pNext;
1798     VkImageAspectFlagBits planeAspect;
1799     safe_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo* in_struct);
1800     safe_VkImagePlaneMemoryRequirementsInfo(const safe_VkImagePlaneMemoryRequirementsInfo& copy_src);
1801     safe_VkImagePlaneMemoryRequirementsInfo& operator=(const safe_VkImagePlaneMemoryRequirementsInfo& copy_src);
1802     safe_VkImagePlaneMemoryRequirementsInfo();
1803     ~safe_VkImagePlaneMemoryRequirementsInfo();
1804     void initialize(const VkImagePlaneMemoryRequirementsInfo* in_struct);
1805     void initialize(const safe_VkImagePlaneMemoryRequirementsInfo* copy_src);
ptrsafe_VkImagePlaneMemoryRequirementsInfo1806     VkImagePlaneMemoryRequirementsInfo *ptr() { return reinterpret_cast<VkImagePlaneMemoryRequirementsInfo *>(this); }
ptrsafe_VkImagePlaneMemoryRequirementsInfo1807     VkImagePlaneMemoryRequirementsInfo const *ptr() const { return reinterpret_cast<VkImagePlaneMemoryRequirementsInfo const *>(this); }
1808 };
1809 
1810 struct safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures {
1811     VkStructureType sType;
1812     void* pNext;
1813     VkBool32 samplerYcbcrConversion;
1814     safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct);
1815     safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& copy_src);
1816     safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& operator=(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& copy_src);
1817     safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures();
1818     ~safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures();
1819     void initialize(const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct);
1820     void initialize(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures* copy_src);
ptrsafe_VkPhysicalDeviceSamplerYcbcrConversionFeatures1821     VkPhysicalDeviceSamplerYcbcrConversionFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(this); }
ptrsafe_VkPhysicalDeviceSamplerYcbcrConversionFeatures1822     VkPhysicalDeviceSamplerYcbcrConversionFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures const *>(this); }
1823 };
1824 
1825 struct safe_VkSamplerYcbcrConversionImageFormatProperties {
1826     VkStructureType sType;
1827     void* pNext;
1828     uint32_t combinedImageSamplerDescriptorCount;
1829     safe_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties* in_struct);
1830     safe_VkSamplerYcbcrConversionImageFormatProperties(const safe_VkSamplerYcbcrConversionImageFormatProperties& copy_src);
1831     safe_VkSamplerYcbcrConversionImageFormatProperties& operator=(const safe_VkSamplerYcbcrConversionImageFormatProperties& copy_src);
1832     safe_VkSamplerYcbcrConversionImageFormatProperties();
1833     ~safe_VkSamplerYcbcrConversionImageFormatProperties();
1834     void initialize(const VkSamplerYcbcrConversionImageFormatProperties* in_struct);
1835     void initialize(const safe_VkSamplerYcbcrConversionImageFormatProperties* copy_src);
ptrsafe_VkSamplerYcbcrConversionImageFormatProperties1836     VkSamplerYcbcrConversionImageFormatProperties *ptr() { return reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties *>(this); }
ptrsafe_VkSamplerYcbcrConversionImageFormatProperties1837     VkSamplerYcbcrConversionImageFormatProperties const *ptr() const { return reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties const *>(this); }
1838 };
1839 
1840 struct safe_VkDescriptorUpdateTemplateCreateInfo {
1841     VkStructureType sType;
1842     const void* pNext;
1843     VkDescriptorUpdateTemplateCreateFlags flags;
1844     uint32_t descriptorUpdateEntryCount;
1845     const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries;
1846     VkDescriptorUpdateTemplateType templateType;
1847     VkDescriptorSetLayout descriptorSetLayout;
1848     VkPipelineBindPoint pipelineBindPoint;
1849     VkPipelineLayout pipelineLayout;
1850     uint32_t set;
1851     safe_VkDescriptorUpdateTemplateCreateInfo(const VkDescriptorUpdateTemplateCreateInfo* in_struct);
1852     safe_VkDescriptorUpdateTemplateCreateInfo(const safe_VkDescriptorUpdateTemplateCreateInfo& copy_src);
1853     safe_VkDescriptorUpdateTemplateCreateInfo& operator=(const safe_VkDescriptorUpdateTemplateCreateInfo& copy_src);
1854     safe_VkDescriptorUpdateTemplateCreateInfo();
1855     ~safe_VkDescriptorUpdateTemplateCreateInfo();
1856     void initialize(const VkDescriptorUpdateTemplateCreateInfo* in_struct);
1857     void initialize(const safe_VkDescriptorUpdateTemplateCreateInfo* copy_src);
ptrsafe_VkDescriptorUpdateTemplateCreateInfo1858     VkDescriptorUpdateTemplateCreateInfo *ptr() { return reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo *>(this); }
ptrsafe_VkDescriptorUpdateTemplateCreateInfo1859     VkDescriptorUpdateTemplateCreateInfo const *ptr() const { return reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo const *>(this); }
1860 };
1861 
1862 struct safe_VkPhysicalDeviceExternalImageFormatInfo {
1863     VkStructureType sType;
1864     const void* pNext;
1865     VkExternalMemoryHandleTypeFlagBits handleType;
1866     safe_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo* in_struct);
1867     safe_VkPhysicalDeviceExternalImageFormatInfo(const safe_VkPhysicalDeviceExternalImageFormatInfo& copy_src);
1868     safe_VkPhysicalDeviceExternalImageFormatInfo& operator=(const safe_VkPhysicalDeviceExternalImageFormatInfo& copy_src);
1869     safe_VkPhysicalDeviceExternalImageFormatInfo();
1870     ~safe_VkPhysicalDeviceExternalImageFormatInfo();
1871     void initialize(const VkPhysicalDeviceExternalImageFormatInfo* in_struct);
1872     void initialize(const safe_VkPhysicalDeviceExternalImageFormatInfo* copy_src);
ptrsafe_VkPhysicalDeviceExternalImageFormatInfo1873     VkPhysicalDeviceExternalImageFormatInfo *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo *>(this); }
ptrsafe_VkPhysicalDeviceExternalImageFormatInfo1874     VkPhysicalDeviceExternalImageFormatInfo const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo const *>(this); }
1875 };
1876 
1877 struct safe_VkExternalImageFormatProperties {
1878     VkStructureType sType;
1879     void* pNext;
1880     VkExternalMemoryProperties externalMemoryProperties;
1881     safe_VkExternalImageFormatProperties(const VkExternalImageFormatProperties* in_struct);
1882     safe_VkExternalImageFormatProperties(const safe_VkExternalImageFormatProperties& copy_src);
1883     safe_VkExternalImageFormatProperties& operator=(const safe_VkExternalImageFormatProperties& copy_src);
1884     safe_VkExternalImageFormatProperties();
1885     ~safe_VkExternalImageFormatProperties();
1886     void initialize(const VkExternalImageFormatProperties* in_struct);
1887     void initialize(const safe_VkExternalImageFormatProperties* copy_src);
ptrsafe_VkExternalImageFormatProperties1888     VkExternalImageFormatProperties *ptr() { return reinterpret_cast<VkExternalImageFormatProperties *>(this); }
ptrsafe_VkExternalImageFormatProperties1889     VkExternalImageFormatProperties const *ptr() const { return reinterpret_cast<VkExternalImageFormatProperties const *>(this); }
1890 };
1891 
1892 struct safe_VkPhysicalDeviceExternalBufferInfo {
1893     VkStructureType sType;
1894     const void* pNext;
1895     VkBufferCreateFlags flags;
1896     VkBufferUsageFlags usage;
1897     VkExternalMemoryHandleTypeFlagBits handleType;
1898     safe_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo* in_struct);
1899     safe_VkPhysicalDeviceExternalBufferInfo(const safe_VkPhysicalDeviceExternalBufferInfo& copy_src);
1900     safe_VkPhysicalDeviceExternalBufferInfo& operator=(const safe_VkPhysicalDeviceExternalBufferInfo& copy_src);
1901     safe_VkPhysicalDeviceExternalBufferInfo();
1902     ~safe_VkPhysicalDeviceExternalBufferInfo();
1903     void initialize(const VkPhysicalDeviceExternalBufferInfo* in_struct);
1904     void initialize(const safe_VkPhysicalDeviceExternalBufferInfo* copy_src);
ptrsafe_VkPhysicalDeviceExternalBufferInfo1905     VkPhysicalDeviceExternalBufferInfo *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalBufferInfo *>(this); }
ptrsafe_VkPhysicalDeviceExternalBufferInfo1906     VkPhysicalDeviceExternalBufferInfo const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalBufferInfo const *>(this); }
1907 };
1908 
1909 struct safe_VkExternalBufferProperties {
1910     VkStructureType sType;
1911     void* pNext;
1912     VkExternalMemoryProperties externalMemoryProperties;
1913     safe_VkExternalBufferProperties(const VkExternalBufferProperties* in_struct);
1914     safe_VkExternalBufferProperties(const safe_VkExternalBufferProperties& copy_src);
1915     safe_VkExternalBufferProperties& operator=(const safe_VkExternalBufferProperties& copy_src);
1916     safe_VkExternalBufferProperties();
1917     ~safe_VkExternalBufferProperties();
1918     void initialize(const VkExternalBufferProperties* in_struct);
1919     void initialize(const safe_VkExternalBufferProperties* copy_src);
ptrsafe_VkExternalBufferProperties1920     VkExternalBufferProperties *ptr() { return reinterpret_cast<VkExternalBufferProperties *>(this); }
ptrsafe_VkExternalBufferProperties1921     VkExternalBufferProperties const *ptr() const { return reinterpret_cast<VkExternalBufferProperties const *>(this); }
1922 };
1923 
1924 struct safe_VkPhysicalDeviceIDProperties {
1925     VkStructureType sType;
1926     void* pNext;
1927     uint8_t deviceUUID[VK_UUID_SIZE];
1928     uint8_t driverUUID[VK_UUID_SIZE];
1929     uint8_t deviceLUID[VK_LUID_SIZE];
1930     uint32_t deviceNodeMask;
1931     VkBool32 deviceLUIDValid;
1932     safe_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties* in_struct);
1933     safe_VkPhysicalDeviceIDProperties(const safe_VkPhysicalDeviceIDProperties& copy_src);
1934     safe_VkPhysicalDeviceIDProperties& operator=(const safe_VkPhysicalDeviceIDProperties& copy_src);
1935     safe_VkPhysicalDeviceIDProperties();
1936     ~safe_VkPhysicalDeviceIDProperties();
1937     void initialize(const VkPhysicalDeviceIDProperties* in_struct);
1938     void initialize(const safe_VkPhysicalDeviceIDProperties* copy_src);
ptrsafe_VkPhysicalDeviceIDProperties1939     VkPhysicalDeviceIDProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceIDProperties *>(this); }
ptrsafe_VkPhysicalDeviceIDProperties1940     VkPhysicalDeviceIDProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceIDProperties const *>(this); }
1941 };
1942 
1943 struct safe_VkExternalMemoryImageCreateInfo {
1944     VkStructureType sType;
1945     const void* pNext;
1946     VkExternalMemoryHandleTypeFlags handleTypes;
1947     safe_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo* in_struct);
1948     safe_VkExternalMemoryImageCreateInfo(const safe_VkExternalMemoryImageCreateInfo& copy_src);
1949     safe_VkExternalMemoryImageCreateInfo& operator=(const safe_VkExternalMemoryImageCreateInfo& copy_src);
1950     safe_VkExternalMemoryImageCreateInfo();
1951     ~safe_VkExternalMemoryImageCreateInfo();
1952     void initialize(const VkExternalMemoryImageCreateInfo* in_struct);
1953     void initialize(const safe_VkExternalMemoryImageCreateInfo* copy_src);
ptrsafe_VkExternalMemoryImageCreateInfo1954     VkExternalMemoryImageCreateInfo *ptr() { return reinterpret_cast<VkExternalMemoryImageCreateInfo *>(this); }
ptrsafe_VkExternalMemoryImageCreateInfo1955     VkExternalMemoryImageCreateInfo const *ptr() const { return reinterpret_cast<VkExternalMemoryImageCreateInfo const *>(this); }
1956 };
1957 
1958 struct safe_VkExternalMemoryBufferCreateInfo {
1959     VkStructureType sType;
1960     const void* pNext;
1961     VkExternalMemoryHandleTypeFlags handleTypes;
1962     safe_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo* in_struct);
1963     safe_VkExternalMemoryBufferCreateInfo(const safe_VkExternalMemoryBufferCreateInfo& copy_src);
1964     safe_VkExternalMemoryBufferCreateInfo& operator=(const safe_VkExternalMemoryBufferCreateInfo& copy_src);
1965     safe_VkExternalMemoryBufferCreateInfo();
1966     ~safe_VkExternalMemoryBufferCreateInfo();
1967     void initialize(const VkExternalMemoryBufferCreateInfo* in_struct);
1968     void initialize(const safe_VkExternalMemoryBufferCreateInfo* copy_src);
ptrsafe_VkExternalMemoryBufferCreateInfo1969     VkExternalMemoryBufferCreateInfo *ptr() { return reinterpret_cast<VkExternalMemoryBufferCreateInfo *>(this); }
ptrsafe_VkExternalMemoryBufferCreateInfo1970     VkExternalMemoryBufferCreateInfo const *ptr() const { return reinterpret_cast<VkExternalMemoryBufferCreateInfo const *>(this); }
1971 };
1972 
1973 struct safe_VkExportMemoryAllocateInfo {
1974     VkStructureType sType;
1975     const void* pNext;
1976     VkExternalMemoryHandleTypeFlags handleTypes;
1977     safe_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo* in_struct);
1978     safe_VkExportMemoryAllocateInfo(const safe_VkExportMemoryAllocateInfo& copy_src);
1979     safe_VkExportMemoryAllocateInfo& operator=(const safe_VkExportMemoryAllocateInfo& copy_src);
1980     safe_VkExportMemoryAllocateInfo();
1981     ~safe_VkExportMemoryAllocateInfo();
1982     void initialize(const VkExportMemoryAllocateInfo* in_struct);
1983     void initialize(const safe_VkExportMemoryAllocateInfo* copy_src);
ptrsafe_VkExportMemoryAllocateInfo1984     VkExportMemoryAllocateInfo *ptr() { return reinterpret_cast<VkExportMemoryAllocateInfo *>(this); }
ptrsafe_VkExportMemoryAllocateInfo1985     VkExportMemoryAllocateInfo const *ptr() const { return reinterpret_cast<VkExportMemoryAllocateInfo const *>(this); }
1986 };
1987 
1988 struct safe_VkPhysicalDeviceExternalFenceInfo {
1989     VkStructureType sType;
1990     const void* pNext;
1991     VkExternalFenceHandleTypeFlagBits handleType;
1992     safe_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo* in_struct);
1993     safe_VkPhysicalDeviceExternalFenceInfo(const safe_VkPhysicalDeviceExternalFenceInfo& copy_src);
1994     safe_VkPhysicalDeviceExternalFenceInfo& operator=(const safe_VkPhysicalDeviceExternalFenceInfo& copy_src);
1995     safe_VkPhysicalDeviceExternalFenceInfo();
1996     ~safe_VkPhysicalDeviceExternalFenceInfo();
1997     void initialize(const VkPhysicalDeviceExternalFenceInfo* in_struct);
1998     void initialize(const safe_VkPhysicalDeviceExternalFenceInfo* copy_src);
ptrsafe_VkPhysicalDeviceExternalFenceInfo1999     VkPhysicalDeviceExternalFenceInfo *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalFenceInfo *>(this); }
ptrsafe_VkPhysicalDeviceExternalFenceInfo2000     VkPhysicalDeviceExternalFenceInfo const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalFenceInfo const *>(this); }
2001 };
2002 
2003 struct safe_VkExternalFenceProperties {
2004     VkStructureType sType;
2005     void* pNext;
2006     VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
2007     VkExternalFenceHandleTypeFlags compatibleHandleTypes;
2008     VkExternalFenceFeatureFlags externalFenceFeatures;
2009     safe_VkExternalFenceProperties(const VkExternalFenceProperties* in_struct);
2010     safe_VkExternalFenceProperties(const safe_VkExternalFenceProperties& copy_src);
2011     safe_VkExternalFenceProperties& operator=(const safe_VkExternalFenceProperties& copy_src);
2012     safe_VkExternalFenceProperties();
2013     ~safe_VkExternalFenceProperties();
2014     void initialize(const VkExternalFenceProperties* in_struct);
2015     void initialize(const safe_VkExternalFenceProperties* copy_src);
ptrsafe_VkExternalFenceProperties2016     VkExternalFenceProperties *ptr() { return reinterpret_cast<VkExternalFenceProperties *>(this); }
ptrsafe_VkExternalFenceProperties2017     VkExternalFenceProperties const *ptr() const { return reinterpret_cast<VkExternalFenceProperties const *>(this); }
2018 };
2019 
2020 struct safe_VkExportFenceCreateInfo {
2021     VkStructureType sType;
2022     const void* pNext;
2023     VkExternalFenceHandleTypeFlags handleTypes;
2024     safe_VkExportFenceCreateInfo(const VkExportFenceCreateInfo* in_struct);
2025     safe_VkExportFenceCreateInfo(const safe_VkExportFenceCreateInfo& copy_src);
2026     safe_VkExportFenceCreateInfo& operator=(const safe_VkExportFenceCreateInfo& copy_src);
2027     safe_VkExportFenceCreateInfo();
2028     ~safe_VkExportFenceCreateInfo();
2029     void initialize(const VkExportFenceCreateInfo* in_struct);
2030     void initialize(const safe_VkExportFenceCreateInfo* copy_src);
ptrsafe_VkExportFenceCreateInfo2031     VkExportFenceCreateInfo *ptr() { return reinterpret_cast<VkExportFenceCreateInfo *>(this); }
ptrsafe_VkExportFenceCreateInfo2032     VkExportFenceCreateInfo const *ptr() const { return reinterpret_cast<VkExportFenceCreateInfo const *>(this); }
2033 };
2034 
2035 struct safe_VkExportSemaphoreCreateInfo {
2036     VkStructureType sType;
2037     const void* pNext;
2038     VkExternalSemaphoreHandleTypeFlags handleTypes;
2039     safe_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo* in_struct);
2040     safe_VkExportSemaphoreCreateInfo(const safe_VkExportSemaphoreCreateInfo& copy_src);
2041     safe_VkExportSemaphoreCreateInfo& operator=(const safe_VkExportSemaphoreCreateInfo& copy_src);
2042     safe_VkExportSemaphoreCreateInfo();
2043     ~safe_VkExportSemaphoreCreateInfo();
2044     void initialize(const VkExportSemaphoreCreateInfo* in_struct);
2045     void initialize(const safe_VkExportSemaphoreCreateInfo* copy_src);
ptrsafe_VkExportSemaphoreCreateInfo2046     VkExportSemaphoreCreateInfo *ptr() { return reinterpret_cast<VkExportSemaphoreCreateInfo *>(this); }
ptrsafe_VkExportSemaphoreCreateInfo2047     VkExportSemaphoreCreateInfo const *ptr() const { return reinterpret_cast<VkExportSemaphoreCreateInfo const *>(this); }
2048 };
2049 
2050 struct safe_VkPhysicalDeviceExternalSemaphoreInfo {
2051     VkStructureType sType;
2052     const void* pNext;
2053     VkExternalSemaphoreHandleTypeFlagBits handleType;
2054     safe_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct);
2055     safe_VkPhysicalDeviceExternalSemaphoreInfo(const safe_VkPhysicalDeviceExternalSemaphoreInfo& copy_src);
2056     safe_VkPhysicalDeviceExternalSemaphoreInfo& operator=(const safe_VkPhysicalDeviceExternalSemaphoreInfo& copy_src);
2057     safe_VkPhysicalDeviceExternalSemaphoreInfo();
2058     ~safe_VkPhysicalDeviceExternalSemaphoreInfo();
2059     void initialize(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct);
2060     void initialize(const safe_VkPhysicalDeviceExternalSemaphoreInfo* copy_src);
ptrsafe_VkPhysicalDeviceExternalSemaphoreInfo2061     VkPhysicalDeviceExternalSemaphoreInfo *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo *>(this); }
ptrsafe_VkPhysicalDeviceExternalSemaphoreInfo2062     VkPhysicalDeviceExternalSemaphoreInfo const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo const *>(this); }
2063 };
2064 
2065 struct safe_VkExternalSemaphoreProperties {
2066     VkStructureType sType;
2067     void* pNext;
2068     VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
2069     VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
2070     VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
2071     safe_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties* in_struct);
2072     safe_VkExternalSemaphoreProperties(const safe_VkExternalSemaphoreProperties& copy_src);
2073     safe_VkExternalSemaphoreProperties& operator=(const safe_VkExternalSemaphoreProperties& copy_src);
2074     safe_VkExternalSemaphoreProperties();
2075     ~safe_VkExternalSemaphoreProperties();
2076     void initialize(const VkExternalSemaphoreProperties* in_struct);
2077     void initialize(const safe_VkExternalSemaphoreProperties* copy_src);
ptrsafe_VkExternalSemaphoreProperties2078     VkExternalSemaphoreProperties *ptr() { return reinterpret_cast<VkExternalSemaphoreProperties *>(this); }
ptrsafe_VkExternalSemaphoreProperties2079     VkExternalSemaphoreProperties const *ptr() const { return reinterpret_cast<VkExternalSemaphoreProperties const *>(this); }
2080 };
2081 
2082 struct safe_VkPhysicalDeviceMaintenance3Properties {
2083     VkStructureType sType;
2084     void* pNext;
2085     uint32_t maxPerSetDescriptors;
2086     VkDeviceSize maxMemoryAllocationSize;
2087     safe_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties* in_struct);
2088     safe_VkPhysicalDeviceMaintenance3Properties(const safe_VkPhysicalDeviceMaintenance3Properties& copy_src);
2089     safe_VkPhysicalDeviceMaintenance3Properties& operator=(const safe_VkPhysicalDeviceMaintenance3Properties& copy_src);
2090     safe_VkPhysicalDeviceMaintenance3Properties();
2091     ~safe_VkPhysicalDeviceMaintenance3Properties();
2092     void initialize(const VkPhysicalDeviceMaintenance3Properties* in_struct);
2093     void initialize(const safe_VkPhysicalDeviceMaintenance3Properties* copy_src);
ptrsafe_VkPhysicalDeviceMaintenance3Properties2094     VkPhysicalDeviceMaintenance3Properties *ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance3Properties *>(this); }
ptrsafe_VkPhysicalDeviceMaintenance3Properties2095     VkPhysicalDeviceMaintenance3Properties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMaintenance3Properties const *>(this); }
2096 };
2097 
2098 struct safe_VkDescriptorSetLayoutSupport {
2099     VkStructureType sType;
2100     void* pNext;
2101     VkBool32 supported;
2102     safe_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport* in_struct);
2103     safe_VkDescriptorSetLayoutSupport(const safe_VkDescriptorSetLayoutSupport& copy_src);
2104     safe_VkDescriptorSetLayoutSupport& operator=(const safe_VkDescriptorSetLayoutSupport& copy_src);
2105     safe_VkDescriptorSetLayoutSupport();
2106     ~safe_VkDescriptorSetLayoutSupport();
2107     void initialize(const VkDescriptorSetLayoutSupport* in_struct);
2108     void initialize(const safe_VkDescriptorSetLayoutSupport* copy_src);
ptrsafe_VkDescriptorSetLayoutSupport2109     VkDescriptorSetLayoutSupport *ptr() { return reinterpret_cast<VkDescriptorSetLayoutSupport *>(this); }
ptrsafe_VkDescriptorSetLayoutSupport2110     VkDescriptorSetLayoutSupport const *ptr() const { return reinterpret_cast<VkDescriptorSetLayoutSupport const *>(this); }
2111 };
2112 
2113 struct safe_VkPhysicalDeviceShaderDrawParametersFeatures {
2114     VkStructureType sType;
2115     void* pNext;
2116     VkBool32 shaderDrawParameters;
2117     safe_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct);
2118     safe_VkPhysicalDeviceShaderDrawParametersFeatures(const safe_VkPhysicalDeviceShaderDrawParametersFeatures& copy_src);
2119     safe_VkPhysicalDeviceShaderDrawParametersFeatures& operator=(const safe_VkPhysicalDeviceShaderDrawParametersFeatures& copy_src);
2120     safe_VkPhysicalDeviceShaderDrawParametersFeatures();
2121     ~safe_VkPhysicalDeviceShaderDrawParametersFeatures();
2122     void initialize(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct);
2123     void initialize(const safe_VkPhysicalDeviceShaderDrawParametersFeatures* copy_src);
ptrsafe_VkPhysicalDeviceShaderDrawParametersFeatures2124     VkPhysicalDeviceShaderDrawParametersFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures *>(this); }
ptrsafe_VkPhysicalDeviceShaderDrawParametersFeatures2125     VkPhysicalDeviceShaderDrawParametersFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures const *>(this); }
2126 };
2127 
2128 struct safe_VkPhysicalDeviceVulkan11Features {
2129     VkStructureType sType;
2130     void* pNext;
2131     VkBool32 storageBuffer16BitAccess;
2132     VkBool32 uniformAndStorageBuffer16BitAccess;
2133     VkBool32 storagePushConstant16;
2134     VkBool32 storageInputOutput16;
2135     VkBool32 multiview;
2136     VkBool32 multiviewGeometryShader;
2137     VkBool32 multiviewTessellationShader;
2138     VkBool32 variablePointersStorageBuffer;
2139     VkBool32 variablePointers;
2140     VkBool32 protectedMemory;
2141     VkBool32 samplerYcbcrConversion;
2142     VkBool32 shaderDrawParameters;
2143     safe_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features* in_struct);
2144     safe_VkPhysicalDeviceVulkan11Features(const safe_VkPhysicalDeviceVulkan11Features& copy_src);
2145     safe_VkPhysicalDeviceVulkan11Features& operator=(const safe_VkPhysicalDeviceVulkan11Features& copy_src);
2146     safe_VkPhysicalDeviceVulkan11Features();
2147     ~safe_VkPhysicalDeviceVulkan11Features();
2148     void initialize(const VkPhysicalDeviceVulkan11Features* in_struct);
2149     void initialize(const safe_VkPhysicalDeviceVulkan11Features* copy_src);
ptrsafe_VkPhysicalDeviceVulkan11Features2150     VkPhysicalDeviceVulkan11Features *ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan11Features *>(this); }
ptrsafe_VkPhysicalDeviceVulkan11Features2151     VkPhysicalDeviceVulkan11Features const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVulkan11Features const *>(this); }
2152 };
2153 
2154 struct safe_VkPhysicalDeviceVulkan11Properties {
2155     VkStructureType sType;
2156     void* pNext;
2157     uint8_t deviceUUID[VK_UUID_SIZE];
2158     uint8_t driverUUID[VK_UUID_SIZE];
2159     uint8_t deviceLUID[VK_LUID_SIZE];
2160     uint32_t deviceNodeMask;
2161     VkBool32 deviceLUIDValid;
2162     uint32_t subgroupSize;
2163     VkShaderStageFlags subgroupSupportedStages;
2164     VkSubgroupFeatureFlags subgroupSupportedOperations;
2165     VkBool32 subgroupQuadOperationsInAllStages;
2166     VkPointClippingBehavior pointClippingBehavior;
2167     uint32_t maxMultiviewViewCount;
2168     uint32_t maxMultiviewInstanceIndex;
2169     VkBool32 protectedNoFault;
2170     uint32_t maxPerSetDescriptors;
2171     VkDeviceSize maxMemoryAllocationSize;
2172     safe_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties* in_struct);
2173     safe_VkPhysicalDeviceVulkan11Properties(const safe_VkPhysicalDeviceVulkan11Properties& copy_src);
2174     safe_VkPhysicalDeviceVulkan11Properties& operator=(const safe_VkPhysicalDeviceVulkan11Properties& copy_src);
2175     safe_VkPhysicalDeviceVulkan11Properties();
2176     ~safe_VkPhysicalDeviceVulkan11Properties();
2177     void initialize(const VkPhysicalDeviceVulkan11Properties* in_struct);
2178     void initialize(const safe_VkPhysicalDeviceVulkan11Properties* copy_src);
ptrsafe_VkPhysicalDeviceVulkan11Properties2179     VkPhysicalDeviceVulkan11Properties *ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan11Properties *>(this); }
ptrsafe_VkPhysicalDeviceVulkan11Properties2180     VkPhysicalDeviceVulkan11Properties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVulkan11Properties const *>(this); }
2181 };
2182 
2183 struct safe_VkPhysicalDeviceVulkan12Features {
2184     VkStructureType sType;
2185     void* pNext;
2186     VkBool32 samplerMirrorClampToEdge;
2187     VkBool32 drawIndirectCount;
2188     VkBool32 storageBuffer8BitAccess;
2189     VkBool32 uniformAndStorageBuffer8BitAccess;
2190     VkBool32 storagePushConstant8;
2191     VkBool32 shaderBufferInt64Atomics;
2192     VkBool32 shaderSharedInt64Atomics;
2193     VkBool32 shaderFloat16;
2194     VkBool32 shaderInt8;
2195     VkBool32 descriptorIndexing;
2196     VkBool32 shaderInputAttachmentArrayDynamicIndexing;
2197     VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;
2198     VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;
2199     VkBool32 shaderUniformBufferArrayNonUniformIndexing;
2200     VkBool32 shaderSampledImageArrayNonUniformIndexing;
2201     VkBool32 shaderStorageBufferArrayNonUniformIndexing;
2202     VkBool32 shaderStorageImageArrayNonUniformIndexing;
2203     VkBool32 shaderInputAttachmentArrayNonUniformIndexing;
2204     VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;
2205     VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;
2206     VkBool32 descriptorBindingUniformBufferUpdateAfterBind;
2207     VkBool32 descriptorBindingSampledImageUpdateAfterBind;
2208     VkBool32 descriptorBindingStorageImageUpdateAfterBind;
2209     VkBool32 descriptorBindingStorageBufferUpdateAfterBind;
2210     VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
2211     VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
2212     VkBool32 descriptorBindingUpdateUnusedWhilePending;
2213     VkBool32 descriptorBindingPartiallyBound;
2214     VkBool32 descriptorBindingVariableDescriptorCount;
2215     VkBool32 runtimeDescriptorArray;
2216     VkBool32 samplerFilterMinmax;
2217     VkBool32 scalarBlockLayout;
2218     VkBool32 imagelessFramebuffer;
2219     VkBool32 uniformBufferStandardLayout;
2220     VkBool32 shaderSubgroupExtendedTypes;
2221     VkBool32 separateDepthStencilLayouts;
2222     VkBool32 hostQueryReset;
2223     VkBool32 timelineSemaphore;
2224     VkBool32 bufferDeviceAddress;
2225     VkBool32 bufferDeviceAddressCaptureReplay;
2226     VkBool32 bufferDeviceAddressMultiDevice;
2227     VkBool32 vulkanMemoryModel;
2228     VkBool32 vulkanMemoryModelDeviceScope;
2229     VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
2230     VkBool32 shaderOutputViewportIndex;
2231     VkBool32 shaderOutputLayer;
2232     VkBool32 subgroupBroadcastDynamicId;
2233     safe_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features* in_struct);
2234     safe_VkPhysicalDeviceVulkan12Features(const safe_VkPhysicalDeviceVulkan12Features& copy_src);
2235     safe_VkPhysicalDeviceVulkan12Features& operator=(const safe_VkPhysicalDeviceVulkan12Features& copy_src);
2236     safe_VkPhysicalDeviceVulkan12Features();
2237     ~safe_VkPhysicalDeviceVulkan12Features();
2238     void initialize(const VkPhysicalDeviceVulkan12Features* in_struct);
2239     void initialize(const safe_VkPhysicalDeviceVulkan12Features* copy_src);
ptrsafe_VkPhysicalDeviceVulkan12Features2240     VkPhysicalDeviceVulkan12Features *ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan12Features *>(this); }
ptrsafe_VkPhysicalDeviceVulkan12Features2241     VkPhysicalDeviceVulkan12Features const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVulkan12Features const *>(this); }
2242 };
2243 
2244 struct safe_VkPhysicalDeviceVulkan12Properties {
2245     VkStructureType sType;
2246     void* pNext;
2247     VkDriverId driverID;
2248     char driverName[VK_MAX_DRIVER_NAME_SIZE];
2249     char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
2250     VkConformanceVersion conformanceVersion;
2251     VkShaderFloatControlsIndependence denormBehaviorIndependence;
2252     VkShaderFloatControlsIndependence roundingModeIndependence;
2253     VkBool32 shaderSignedZeroInfNanPreserveFloat16;
2254     VkBool32 shaderSignedZeroInfNanPreserveFloat32;
2255     VkBool32 shaderSignedZeroInfNanPreserveFloat64;
2256     VkBool32 shaderDenormPreserveFloat16;
2257     VkBool32 shaderDenormPreserveFloat32;
2258     VkBool32 shaderDenormPreserveFloat64;
2259     VkBool32 shaderDenormFlushToZeroFloat16;
2260     VkBool32 shaderDenormFlushToZeroFloat32;
2261     VkBool32 shaderDenormFlushToZeroFloat64;
2262     VkBool32 shaderRoundingModeRTEFloat16;
2263     VkBool32 shaderRoundingModeRTEFloat32;
2264     VkBool32 shaderRoundingModeRTEFloat64;
2265     VkBool32 shaderRoundingModeRTZFloat16;
2266     VkBool32 shaderRoundingModeRTZFloat32;
2267     VkBool32 shaderRoundingModeRTZFloat64;
2268     uint32_t maxUpdateAfterBindDescriptorsInAllPools;
2269     VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
2270     VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
2271     VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
2272     VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
2273     VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
2274     VkBool32 robustBufferAccessUpdateAfterBind;
2275     VkBool32 quadDivergentImplicitLod;
2276     uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
2277     uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
2278     uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
2279     uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
2280     uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
2281     uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
2282     uint32_t maxPerStageUpdateAfterBindResources;
2283     uint32_t maxDescriptorSetUpdateAfterBindSamplers;
2284     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
2285     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
2286     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
2287     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
2288     uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
2289     uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
2290     uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
2291     VkResolveModeFlags supportedDepthResolveModes;
2292     VkResolveModeFlags supportedStencilResolveModes;
2293     VkBool32 independentResolveNone;
2294     VkBool32 independentResolve;
2295     VkBool32 filterMinmaxSingleComponentFormats;
2296     VkBool32 filterMinmaxImageComponentMapping;
2297     uint64_t maxTimelineSemaphoreValueDifference;
2298     VkSampleCountFlags framebufferIntegerColorSampleCounts;
2299     safe_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties* in_struct);
2300     safe_VkPhysicalDeviceVulkan12Properties(const safe_VkPhysicalDeviceVulkan12Properties& copy_src);
2301     safe_VkPhysicalDeviceVulkan12Properties& operator=(const safe_VkPhysicalDeviceVulkan12Properties& copy_src);
2302     safe_VkPhysicalDeviceVulkan12Properties();
2303     ~safe_VkPhysicalDeviceVulkan12Properties();
2304     void initialize(const VkPhysicalDeviceVulkan12Properties* in_struct);
2305     void initialize(const safe_VkPhysicalDeviceVulkan12Properties* copy_src);
ptrsafe_VkPhysicalDeviceVulkan12Properties2306     VkPhysicalDeviceVulkan12Properties *ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan12Properties *>(this); }
ptrsafe_VkPhysicalDeviceVulkan12Properties2307     VkPhysicalDeviceVulkan12Properties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVulkan12Properties const *>(this); }
2308 };
2309 
2310 struct safe_VkImageFormatListCreateInfo {
2311     VkStructureType sType;
2312     const void* pNext;
2313     uint32_t viewFormatCount;
2314     const VkFormat* pViewFormats;
2315     safe_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo* in_struct);
2316     safe_VkImageFormatListCreateInfo(const safe_VkImageFormatListCreateInfo& copy_src);
2317     safe_VkImageFormatListCreateInfo& operator=(const safe_VkImageFormatListCreateInfo& copy_src);
2318     safe_VkImageFormatListCreateInfo();
2319     ~safe_VkImageFormatListCreateInfo();
2320     void initialize(const VkImageFormatListCreateInfo* in_struct);
2321     void initialize(const safe_VkImageFormatListCreateInfo* copy_src);
ptrsafe_VkImageFormatListCreateInfo2322     VkImageFormatListCreateInfo *ptr() { return reinterpret_cast<VkImageFormatListCreateInfo *>(this); }
ptrsafe_VkImageFormatListCreateInfo2323     VkImageFormatListCreateInfo const *ptr() const { return reinterpret_cast<VkImageFormatListCreateInfo const *>(this); }
2324 };
2325 
2326 struct safe_VkAttachmentDescription2 {
2327     VkStructureType sType;
2328     const void* pNext;
2329     VkAttachmentDescriptionFlags flags;
2330     VkFormat format;
2331     VkSampleCountFlagBits samples;
2332     VkAttachmentLoadOp loadOp;
2333     VkAttachmentStoreOp storeOp;
2334     VkAttachmentLoadOp stencilLoadOp;
2335     VkAttachmentStoreOp stencilStoreOp;
2336     VkImageLayout initialLayout;
2337     VkImageLayout finalLayout;
2338     safe_VkAttachmentDescription2(const VkAttachmentDescription2* in_struct);
2339     safe_VkAttachmentDescription2(const safe_VkAttachmentDescription2& copy_src);
2340     safe_VkAttachmentDescription2& operator=(const safe_VkAttachmentDescription2& copy_src);
2341     safe_VkAttachmentDescription2();
2342     ~safe_VkAttachmentDescription2();
2343     void initialize(const VkAttachmentDescription2* in_struct);
2344     void initialize(const safe_VkAttachmentDescription2* copy_src);
ptrsafe_VkAttachmentDescription22345     VkAttachmentDescription2 *ptr() { return reinterpret_cast<VkAttachmentDescription2 *>(this); }
ptrsafe_VkAttachmentDescription22346     VkAttachmentDescription2 const *ptr() const { return reinterpret_cast<VkAttachmentDescription2 const *>(this); }
2347 };
2348 
2349 struct safe_VkAttachmentReference2 {
2350     VkStructureType sType;
2351     const void* pNext;
2352     uint32_t attachment;
2353     VkImageLayout layout;
2354     VkImageAspectFlags aspectMask;
2355     safe_VkAttachmentReference2(const VkAttachmentReference2* in_struct);
2356     safe_VkAttachmentReference2(const safe_VkAttachmentReference2& copy_src);
2357     safe_VkAttachmentReference2& operator=(const safe_VkAttachmentReference2& copy_src);
2358     safe_VkAttachmentReference2();
2359     ~safe_VkAttachmentReference2();
2360     void initialize(const VkAttachmentReference2* in_struct);
2361     void initialize(const safe_VkAttachmentReference2* copy_src);
ptrsafe_VkAttachmentReference22362     VkAttachmentReference2 *ptr() { return reinterpret_cast<VkAttachmentReference2 *>(this); }
ptrsafe_VkAttachmentReference22363     VkAttachmentReference2 const *ptr() const { return reinterpret_cast<VkAttachmentReference2 const *>(this); }
2364 };
2365 
2366 struct safe_VkSubpassDescription2 {
2367     VkStructureType sType;
2368     const void* pNext;
2369     VkSubpassDescriptionFlags flags;
2370     VkPipelineBindPoint pipelineBindPoint;
2371     uint32_t viewMask;
2372     uint32_t inputAttachmentCount;
2373     safe_VkAttachmentReference2* pInputAttachments;
2374     uint32_t colorAttachmentCount;
2375     safe_VkAttachmentReference2* pColorAttachments;
2376     safe_VkAttachmentReference2* pResolveAttachments;
2377     safe_VkAttachmentReference2* pDepthStencilAttachment;
2378     uint32_t preserveAttachmentCount;
2379     const uint32_t* pPreserveAttachments;
2380     safe_VkSubpassDescription2(const VkSubpassDescription2* in_struct);
2381     safe_VkSubpassDescription2(const safe_VkSubpassDescription2& copy_src);
2382     safe_VkSubpassDescription2& operator=(const safe_VkSubpassDescription2& copy_src);
2383     safe_VkSubpassDescription2();
2384     ~safe_VkSubpassDescription2();
2385     void initialize(const VkSubpassDescription2* in_struct);
2386     void initialize(const safe_VkSubpassDescription2* copy_src);
ptrsafe_VkSubpassDescription22387     VkSubpassDescription2 *ptr() { return reinterpret_cast<VkSubpassDescription2 *>(this); }
ptrsafe_VkSubpassDescription22388     VkSubpassDescription2 const *ptr() const { return reinterpret_cast<VkSubpassDescription2 const *>(this); }
2389 };
2390 
2391 struct safe_VkSubpassDependency2 {
2392     VkStructureType sType;
2393     const void* pNext;
2394     uint32_t srcSubpass;
2395     uint32_t dstSubpass;
2396     VkPipelineStageFlags srcStageMask;
2397     VkPipelineStageFlags dstStageMask;
2398     VkAccessFlags srcAccessMask;
2399     VkAccessFlags dstAccessMask;
2400     VkDependencyFlags dependencyFlags;
2401     int32_t viewOffset;
2402     safe_VkSubpassDependency2(const VkSubpassDependency2* in_struct);
2403     safe_VkSubpassDependency2(const safe_VkSubpassDependency2& copy_src);
2404     safe_VkSubpassDependency2& operator=(const safe_VkSubpassDependency2& copy_src);
2405     safe_VkSubpassDependency2();
2406     ~safe_VkSubpassDependency2();
2407     void initialize(const VkSubpassDependency2* in_struct);
2408     void initialize(const safe_VkSubpassDependency2* copy_src);
ptrsafe_VkSubpassDependency22409     VkSubpassDependency2 *ptr() { return reinterpret_cast<VkSubpassDependency2 *>(this); }
ptrsafe_VkSubpassDependency22410     VkSubpassDependency2 const *ptr() const { return reinterpret_cast<VkSubpassDependency2 const *>(this); }
2411 };
2412 
2413 struct safe_VkRenderPassCreateInfo2 {
2414     VkStructureType sType;
2415     const void* pNext;
2416     VkRenderPassCreateFlags flags;
2417     uint32_t attachmentCount;
2418     safe_VkAttachmentDescription2* pAttachments;
2419     uint32_t subpassCount;
2420     safe_VkSubpassDescription2* pSubpasses;
2421     uint32_t dependencyCount;
2422     safe_VkSubpassDependency2* pDependencies;
2423     uint32_t correlatedViewMaskCount;
2424     const uint32_t* pCorrelatedViewMasks;
2425     safe_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2* in_struct);
2426     safe_VkRenderPassCreateInfo2(const safe_VkRenderPassCreateInfo2& copy_src);
2427     safe_VkRenderPassCreateInfo2& operator=(const safe_VkRenderPassCreateInfo2& copy_src);
2428     safe_VkRenderPassCreateInfo2();
2429     ~safe_VkRenderPassCreateInfo2();
2430     void initialize(const VkRenderPassCreateInfo2* in_struct);
2431     void initialize(const safe_VkRenderPassCreateInfo2* copy_src);
ptrsafe_VkRenderPassCreateInfo22432     VkRenderPassCreateInfo2 *ptr() { return reinterpret_cast<VkRenderPassCreateInfo2 *>(this); }
ptrsafe_VkRenderPassCreateInfo22433     VkRenderPassCreateInfo2 const *ptr() const { return reinterpret_cast<VkRenderPassCreateInfo2 const *>(this); }
2434 };
2435 
2436 struct safe_VkSubpassBeginInfo {
2437     VkStructureType sType;
2438     const void* pNext;
2439     VkSubpassContents contents;
2440     safe_VkSubpassBeginInfo(const VkSubpassBeginInfo* in_struct);
2441     safe_VkSubpassBeginInfo(const safe_VkSubpassBeginInfo& copy_src);
2442     safe_VkSubpassBeginInfo& operator=(const safe_VkSubpassBeginInfo& copy_src);
2443     safe_VkSubpassBeginInfo();
2444     ~safe_VkSubpassBeginInfo();
2445     void initialize(const VkSubpassBeginInfo* in_struct);
2446     void initialize(const safe_VkSubpassBeginInfo* copy_src);
ptrsafe_VkSubpassBeginInfo2447     VkSubpassBeginInfo *ptr() { return reinterpret_cast<VkSubpassBeginInfo *>(this); }
ptrsafe_VkSubpassBeginInfo2448     VkSubpassBeginInfo const *ptr() const { return reinterpret_cast<VkSubpassBeginInfo const *>(this); }
2449 };
2450 
2451 struct safe_VkSubpassEndInfo {
2452     VkStructureType sType;
2453     const void* pNext;
2454     safe_VkSubpassEndInfo(const VkSubpassEndInfo* in_struct);
2455     safe_VkSubpassEndInfo(const safe_VkSubpassEndInfo& copy_src);
2456     safe_VkSubpassEndInfo& operator=(const safe_VkSubpassEndInfo& copy_src);
2457     safe_VkSubpassEndInfo();
2458     ~safe_VkSubpassEndInfo();
2459     void initialize(const VkSubpassEndInfo* in_struct);
2460     void initialize(const safe_VkSubpassEndInfo* copy_src);
ptrsafe_VkSubpassEndInfo2461     VkSubpassEndInfo *ptr() { return reinterpret_cast<VkSubpassEndInfo *>(this); }
ptrsafe_VkSubpassEndInfo2462     VkSubpassEndInfo const *ptr() const { return reinterpret_cast<VkSubpassEndInfo const *>(this); }
2463 };
2464 
2465 struct safe_VkPhysicalDevice8BitStorageFeatures {
2466     VkStructureType sType;
2467     void* pNext;
2468     VkBool32 storageBuffer8BitAccess;
2469     VkBool32 uniformAndStorageBuffer8BitAccess;
2470     VkBool32 storagePushConstant8;
2471     safe_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures* in_struct);
2472     safe_VkPhysicalDevice8BitStorageFeatures(const safe_VkPhysicalDevice8BitStorageFeatures& copy_src);
2473     safe_VkPhysicalDevice8BitStorageFeatures& operator=(const safe_VkPhysicalDevice8BitStorageFeatures& copy_src);
2474     safe_VkPhysicalDevice8BitStorageFeatures();
2475     ~safe_VkPhysicalDevice8BitStorageFeatures();
2476     void initialize(const VkPhysicalDevice8BitStorageFeatures* in_struct);
2477     void initialize(const safe_VkPhysicalDevice8BitStorageFeatures* copy_src);
ptrsafe_VkPhysicalDevice8BitStorageFeatures2478     VkPhysicalDevice8BitStorageFeatures *ptr() { return reinterpret_cast<VkPhysicalDevice8BitStorageFeatures *>(this); }
ptrsafe_VkPhysicalDevice8BitStorageFeatures2479     VkPhysicalDevice8BitStorageFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDevice8BitStorageFeatures const *>(this); }
2480 };
2481 
2482 struct safe_VkPhysicalDeviceDriverProperties {
2483     VkStructureType sType;
2484     void* pNext;
2485     VkDriverId driverID;
2486     char driverName[VK_MAX_DRIVER_NAME_SIZE];
2487     char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
2488     VkConformanceVersion conformanceVersion;
2489     safe_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties* in_struct);
2490     safe_VkPhysicalDeviceDriverProperties(const safe_VkPhysicalDeviceDriverProperties& copy_src);
2491     safe_VkPhysicalDeviceDriverProperties& operator=(const safe_VkPhysicalDeviceDriverProperties& copy_src);
2492     safe_VkPhysicalDeviceDriverProperties();
2493     ~safe_VkPhysicalDeviceDriverProperties();
2494     void initialize(const VkPhysicalDeviceDriverProperties* in_struct);
2495     void initialize(const safe_VkPhysicalDeviceDriverProperties* copy_src);
ptrsafe_VkPhysicalDeviceDriverProperties2496     VkPhysicalDeviceDriverProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceDriverProperties *>(this); }
ptrsafe_VkPhysicalDeviceDriverProperties2497     VkPhysicalDeviceDriverProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDriverProperties const *>(this); }
2498 };
2499 
2500 struct safe_VkPhysicalDeviceShaderAtomicInt64Features {
2501     VkStructureType sType;
2502     void* pNext;
2503     VkBool32 shaderBufferInt64Atomics;
2504     VkBool32 shaderSharedInt64Atomics;
2505     safe_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features* in_struct);
2506     safe_VkPhysicalDeviceShaderAtomicInt64Features(const safe_VkPhysicalDeviceShaderAtomicInt64Features& copy_src);
2507     safe_VkPhysicalDeviceShaderAtomicInt64Features& operator=(const safe_VkPhysicalDeviceShaderAtomicInt64Features& copy_src);
2508     safe_VkPhysicalDeviceShaderAtomicInt64Features();
2509     ~safe_VkPhysicalDeviceShaderAtomicInt64Features();
2510     void initialize(const VkPhysicalDeviceShaderAtomicInt64Features* in_struct);
2511     void initialize(const safe_VkPhysicalDeviceShaderAtomicInt64Features* copy_src);
ptrsafe_VkPhysicalDeviceShaderAtomicInt64Features2512     VkPhysicalDeviceShaderAtomicInt64Features *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features *>(this); }
ptrsafe_VkPhysicalDeviceShaderAtomicInt64Features2513     VkPhysicalDeviceShaderAtomicInt64Features const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features const *>(this); }
2514 };
2515 
2516 struct safe_VkPhysicalDeviceShaderFloat16Int8Features {
2517     VkStructureType sType;
2518     void* pNext;
2519     VkBool32 shaderFloat16;
2520     VkBool32 shaderInt8;
2521     safe_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features* in_struct);
2522     safe_VkPhysicalDeviceShaderFloat16Int8Features(const safe_VkPhysicalDeviceShaderFloat16Int8Features& copy_src);
2523     safe_VkPhysicalDeviceShaderFloat16Int8Features& operator=(const safe_VkPhysicalDeviceShaderFloat16Int8Features& copy_src);
2524     safe_VkPhysicalDeviceShaderFloat16Int8Features();
2525     ~safe_VkPhysicalDeviceShaderFloat16Int8Features();
2526     void initialize(const VkPhysicalDeviceShaderFloat16Int8Features* in_struct);
2527     void initialize(const safe_VkPhysicalDeviceShaderFloat16Int8Features* copy_src);
ptrsafe_VkPhysicalDeviceShaderFloat16Int8Features2528     VkPhysicalDeviceShaderFloat16Int8Features *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features *>(this); }
ptrsafe_VkPhysicalDeviceShaderFloat16Int8Features2529     VkPhysicalDeviceShaderFloat16Int8Features const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features const *>(this); }
2530 };
2531 
2532 struct safe_VkPhysicalDeviceFloatControlsProperties {
2533     VkStructureType sType;
2534     void* pNext;
2535     VkShaderFloatControlsIndependence denormBehaviorIndependence;
2536     VkShaderFloatControlsIndependence roundingModeIndependence;
2537     VkBool32 shaderSignedZeroInfNanPreserveFloat16;
2538     VkBool32 shaderSignedZeroInfNanPreserveFloat32;
2539     VkBool32 shaderSignedZeroInfNanPreserveFloat64;
2540     VkBool32 shaderDenormPreserveFloat16;
2541     VkBool32 shaderDenormPreserveFloat32;
2542     VkBool32 shaderDenormPreserveFloat64;
2543     VkBool32 shaderDenormFlushToZeroFloat16;
2544     VkBool32 shaderDenormFlushToZeroFloat32;
2545     VkBool32 shaderDenormFlushToZeroFloat64;
2546     VkBool32 shaderRoundingModeRTEFloat16;
2547     VkBool32 shaderRoundingModeRTEFloat32;
2548     VkBool32 shaderRoundingModeRTEFloat64;
2549     VkBool32 shaderRoundingModeRTZFloat16;
2550     VkBool32 shaderRoundingModeRTZFloat32;
2551     VkBool32 shaderRoundingModeRTZFloat64;
2552     safe_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties* in_struct);
2553     safe_VkPhysicalDeviceFloatControlsProperties(const safe_VkPhysicalDeviceFloatControlsProperties& copy_src);
2554     safe_VkPhysicalDeviceFloatControlsProperties& operator=(const safe_VkPhysicalDeviceFloatControlsProperties& copy_src);
2555     safe_VkPhysicalDeviceFloatControlsProperties();
2556     ~safe_VkPhysicalDeviceFloatControlsProperties();
2557     void initialize(const VkPhysicalDeviceFloatControlsProperties* in_struct);
2558     void initialize(const safe_VkPhysicalDeviceFloatControlsProperties* copy_src);
ptrsafe_VkPhysicalDeviceFloatControlsProperties2559     VkPhysicalDeviceFloatControlsProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceFloatControlsProperties *>(this); }
ptrsafe_VkPhysicalDeviceFloatControlsProperties2560     VkPhysicalDeviceFloatControlsProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFloatControlsProperties const *>(this); }
2561 };
2562 
2563 struct safe_VkDescriptorSetLayoutBindingFlagsCreateInfo {
2564     VkStructureType sType;
2565     const void* pNext;
2566     uint32_t bindingCount;
2567     const VkDescriptorBindingFlags* pBindingFlags;
2568     safe_VkDescriptorSetLayoutBindingFlagsCreateInfo(const VkDescriptorSetLayoutBindingFlagsCreateInfo* in_struct);
2569     safe_VkDescriptorSetLayoutBindingFlagsCreateInfo(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& copy_src);
2570     safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& operator=(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& copy_src);
2571     safe_VkDescriptorSetLayoutBindingFlagsCreateInfo();
2572     ~safe_VkDescriptorSetLayoutBindingFlagsCreateInfo();
2573     void initialize(const VkDescriptorSetLayoutBindingFlagsCreateInfo* in_struct);
2574     void initialize(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo* copy_src);
ptrsafe_VkDescriptorSetLayoutBindingFlagsCreateInfo2575     VkDescriptorSetLayoutBindingFlagsCreateInfo *ptr() { return reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo *>(this); }
ptrsafe_VkDescriptorSetLayoutBindingFlagsCreateInfo2576     VkDescriptorSetLayoutBindingFlagsCreateInfo const *ptr() const { return reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo const *>(this); }
2577 };
2578 
2579 struct safe_VkPhysicalDeviceDescriptorIndexingFeatures {
2580     VkStructureType sType;
2581     void* pNext;
2582     VkBool32 shaderInputAttachmentArrayDynamicIndexing;
2583     VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;
2584     VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;
2585     VkBool32 shaderUniformBufferArrayNonUniformIndexing;
2586     VkBool32 shaderSampledImageArrayNonUniformIndexing;
2587     VkBool32 shaderStorageBufferArrayNonUniformIndexing;
2588     VkBool32 shaderStorageImageArrayNonUniformIndexing;
2589     VkBool32 shaderInputAttachmentArrayNonUniformIndexing;
2590     VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;
2591     VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;
2592     VkBool32 descriptorBindingUniformBufferUpdateAfterBind;
2593     VkBool32 descriptorBindingSampledImageUpdateAfterBind;
2594     VkBool32 descriptorBindingStorageImageUpdateAfterBind;
2595     VkBool32 descriptorBindingStorageBufferUpdateAfterBind;
2596     VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
2597     VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
2598     VkBool32 descriptorBindingUpdateUnusedWhilePending;
2599     VkBool32 descriptorBindingPartiallyBound;
2600     VkBool32 descriptorBindingVariableDescriptorCount;
2601     VkBool32 runtimeDescriptorArray;
2602     safe_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures* in_struct);
2603     safe_VkPhysicalDeviceDescriptorIndexingFeatures(const safe_VkPhysicalDeviceDescriptorIndexingFeatures& copy_src);
2604     safe_VkPhysicalDeviceDescriptorIndexingFeatures& operator=(const safe_VkPhysicalDeviceDescriptorIndexingFeatures& copy_src);
2605     safe_VkPhysicalDeviceDescriptorIndexingFeatures();
2606     ~safe_VkPhysicalDeviceDescriptorIndexingFeatures();
2607     void initialize(const VkPhysicalDeviceDescriptorIndexingFeatures* in_struct);
2608     void initialize(const safe_VkPhysicalDeviceDescriptorIndexingFeatures* copy_src);
ptrsafe_VkPhysicalDeviceDescriptorIndexingFeatures2609     VkPhysicalDeviceDescriptorIndexingFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(this); }
ptrsafe_VkPhysicalDeviceDescriptorIndexingFeatures2610     VkPhysicalDeviceDescriptorIndexingFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures const *>(this); }
2611 };
2612 
2613 struct safe_VkPhysicalDeviceDescriptorIndexingProperties {
2614     VkStructureType sType;
2615     void* pNext;
2616     uint32_t maxUpdateAfterBindDescriptorsInAllPools;
2617     VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
2618     VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
2619     VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
2620     VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
2621     VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
2622     VkBool32 robustBufferAccessUpdateAfterBind;
2623     VkBool32 quadDivergentImplicitLod;
2624     uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
2625     uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
2626     uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
2627     uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
2628     uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
2629     uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
2630     uint32_t maxPerStageUpdateAfterBindResources;
2631     uint32_t maxDescriptorSetUpdateAfterBindSamplers;
2632     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
2633     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
2634     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
2635     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
2636     uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
2637     uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
2638     uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
2639     safe_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties* in_struct);
2640     safe_VkPhysicalDeviceDescriptorIndexingProperties(const safe_VkPhysicalDeviceDescriptorIndexingProperties& copy_src);
2641     safe_VkPhysicalDeviceDescriptorIndexingProperties& operator=(const safe_VkPhysicalDeviceDescriptorIndexingProperties& copy_src);
2642     safe_VkPhysicalDeviceDescriptorIndexingProperties();
2643     ~safe_VkPhysicalDeviceDescriptorIndexingProperties();
2644     void initialize(const VkPhysicalDeviceDescriptorIndexingProperties* in_struct);
2645     void initialize(const safe_VkPhysicalDeviceDescriptorIndexingProperties* copy_src);
ptrsafe_VkPhysicalDeviceDescriptorIndexingProperties2646     VkPhysicalDeviceDescriptorIndexingProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties *>(this); }
ptrsafe_VkPhysicalDeviceDescriptorIndexingProperties2647     VkPhysicalDeviceDescriptorIndexingProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties const *>(this); }
2648 };
2649 
2650 struct safe_VkDescriptorSetVariableDescriptorCountAllocateInfo {
2651     VkStructureType sType;
2652     const void* pNext;
2653     uint32_t descriptorSetCount;
2654     const uint32_t* pDescriptorCounts;
2655     safe_VkDescriptorSetVariableDescriptorCountAllocateInfo(const VkDescriptorSetVariableDescriptorCountAllocateInfo* in_struct);
2656     safe_VkDescriptorSetVariableDescriptorCountAllocateInfo(const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& copy_src);
2657     safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& operator=(const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& copy_src);
2658     safe_VkDescriptorSetVariableDescriptorCountAllocateInfo();
2659     ~safe_VkDescriptorSetVariableDescriptorCountAllocateInfo();
2660     void initialize(const VkDescriptorSetVariableDescriptorCountAllocateInfo* in_struct);
2661     void initialize(const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo* copy_src);
ptrsafe_VkDescriptorSetVariableDescriptorCountAllocateInfo2662     VkDescriptorSetVariableDescriptorCountAllocateInfo *ptr() { return reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo *>(this); }
ptrsafe_VkDescriptorSetVariableDescriptorCountAllocateInfo2663     VkDescriptorSetVariableDescriptorCountAllocateInfo const *ptr() const { return reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo const *>(this); }
2664 };
2665 
2666 struct safe_VkDescriptorSetVariableDescriptorCountLayoutSupport {
2667     VkStructureType sType;
2668     void* pNext;
2669     uint32_t maxVariableDescriptorCount;
2670     safe_VkDescriptorSetVariableDescriptorCountLayoutSupport(const VkDescriptorSetVariableDescriptorCountLayoutSupport* in_struct);
2671     safe_VkDescriptorSetVariableDescriptorCountLayoutSupport(const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& copy_src);
2672     safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& operator=(const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& copy_src);
2673     safe_VkDescriptorSetVariableDescriptorCountLayoutSupport();
2674     ~safe_VkDescriptorSetVariableDescriptorCountLayoutSupport();
2675     void initialize(const VkDescriptorSetVariableDescriptorCountLayoutSupport* in_struct);
2676     void initialize(const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport* copy_src);
ptrsafe_VkDescriptorSetVariableDescriptorCountLayoutSupport2677     VkDescriptorSetVariableDescriptorCountLayoutSupport *ptr() { return reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport *>(this); }
ptrsafe_VkDescriptorSetVariableDescriptorCountLayoutSupport2678     VkDescriptorSetVariableDescriptorCountLayoutSupport const *ptr() const { return reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport const *>(this); }
2679 };
2680 
2681 struct safe_VkSubpassDescriptionDepthStencilResolve {
2682     VkStructureType sType;
2683     const void* pNext;
2684     VkResolveModeFlagBits depthResolveMode;
2685     VkResolveModeFlagBits stencilResolveMode;
2686     safe_VkAttachmentReference2* pDepthStencilResolveAttachment;
2687     safe_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve* in_struct);
2688     safe_VkSubpassDescriptionDepthStencilResolve(const safe_VkSubpassDescriptionDepthStencilResolve& copy_src);
2689     safe_VkSubpassDescriptionDepthStencilResolve& operator=(const safe_VkSubpassDescriptionDepthStencilResolve& copy_src);
2690     safe_VkSubpassDescriptionDepthStencilResolve();
2691     ~safe_VkSubpassDescriptionDepthStencilResolve();
2692     void initialize(const VkSubpassDescriptionDepthStencilResolve* in_struct);
2693     void initialize(const safe_VkSubpassDescriptionDepthStencilResolve* copy_src);
ptrsafe_VkSubpassDescriptionDepthStencilResolve2694     VkSubpassDescriptionDepthStencilResolve *ptr() { return reinterpret_cast<VkSubpassDescriptionDepthStencilResolve *>(this); }
ptrsafe_VkSubpassDescriptionDepthStencilResolve2695     VkSubpassDescriptionDepthStencilResolve const *ptr() const { return reinterpret_cast<VkSubpassDescriptionDepthStencilResolve const *>(this); }
2696 };
2697 
2698 struct safe_VkPhysicalDeviceDepthStencilResolveProperties {
2699     VkStructureType sType;
2700     void* pNext;
2701     VkResolveModeFlags supportedDepthResolveModes;
2702     VkResolveModeFlags supportedStencilResolveModes;
2703     VkBool32 independentResolveNone;
2704     VkBool32 independentResolve;
2705     safe_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties* in_struct);
2706     safe_VkPhysicalDeviceDepthStencilResolveProperties(const safe_VkPhysicalDeviceDepthStencilResolveProperties& copy_src);
2707     safe_VkPhysicalDeviceDepthStencilResolveProperties& operator=(const safe_VkPhysicalDeviceDepthStencilResolveProperties& copy_src);
2708     safe_VkPhysicalDeviceDepthStencilResolveProperties();
2709     ~safe_VkPhysicalDeviceDepthStencilResolveProperties();
2710     void initialize(const VkPhysicalDeviceDepthStencilResolveProperties* in_struct);
2711     void initialize(const safe_VkPhysicalDeviceDepthStencilResolveProperties* copy_src);
ptrsafe_VkPhysicalDeviceDepthStencilResolveProperties2712     VkPhysicalDeviceDepthStencilResolveProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties *>(this); }
ptrsafe_VkPhysicalDeviceDepthStencilResolveProperties2713     VkPhysicalDeviceDepthStencilResolveProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties const *>(this); }
2714 };
2715 
2716 struct safe_VkPhysicalDeviceScalarBlockLayoutFeatures {
2717     VkStructureType sType;
2718     void* pNext;
2719     VkBool32 scalarBlockLayout;
2720     safe_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures* in_struct);
2721     safe_VkPhysicalDeviceScalarBlockLayoutFeatures(const safe_VkPhysicalDeviceScalarBlockLayoutFeatures& copy_src);
2722     safe_VkPhysicalDeviceScalarBlockLayoutFeatures& operator=(const safe_VkPhysicalDeviceScalarBlockLayoutFeatures& copy_src);
2723     safe_VkPhysicalDeviceScalarBlockLayoutFeatures();
2724     ~safe_VkPhysicalDeviceScalarBlockLayoutFeatures();
2725     void initialize(const VkPhysicalDeviceScalarBlockLayoutFeatures* in_struct);
2726     void initialize(const safe_VkPhysicalDeviceScalarBlockLayoutFeatures* copy_src);
ptrsafe_VkPhysicalDeviceScalarBlockLayoutFeatures2727     VkPhysicalDeviceScalarBlockLayoutFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures *>(this); }
ptrsafe_VkPhysicalDeviceScalarBlockLayoutFeatures2728     VkPhysicalDeviceScalarBlockLayoutFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures const *>(this); }
2729 };
2730 
2731 struct safe_VkImageStencilUsageCreateInfo {
2732     VkStructureType sType;
2733     const void* pNext;
2734     VkImageUsageFlags stencilUsage;
2735     safe_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo* in_struct);
2736     safe_VkImageStencilUsageCreateInfo(const safe_VkImageStencilUsageCreateInfo& copy_src);
2737     safe_VkImageStencilUsageCreateInfo& operator=(const safe_VkImageStencilUsageCreateInfo& copy_src);
2738     safe_VkImageStencilUsageCreateInfo();
2739     ~safe_VkImageStencilUsageCreateInfo();
2740     void initialize(const VkImageStencilUsageCreateInfo* in_struct);
2741     void initialize(const safe_VkImageStencilUsageCreateInfo* copy_src);
ptrsafe_VkImageStencilUsageCreateInfo2742     VkImageStencilUsageCreateInfo *ptr() { return reinterpret_cast<VkImageStencilUsageCreateInfo *>(this); }
ptrsafe_VkImageStencilUsageCreateInfo2743     VkImageStencilUsageCreateInfo const *ptr() const { return reinterpret_cast<VkImageStencilUsageCreateInfo const *>(this); }
2744 };
2745 
2746 struct safe_VkSamplerReductionModeCreateInfo {
2747     VkStructureType sType;
2748     const void* pNext;
2749     VkSamplerReductionMode reductionMode;
2750     safe_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo* in_struct);
2751     safe_VkSamplerReductionModeCreateInfo(const safe_VkSamplerReductionModeCreateInfo& copy_src);
2752     safe_VkSamplerReductionModeCreateInfo& operator=(const safe_VkSamplerReductionModeCreateInfo& copy_src);
2753     safe_VkSamplerReductionModeCreateInfo();
2754     ~safe_VkSamplerReductionModeCreateInfo();
2755     void initialize(const VkSamplerReductionModeCreateInfo* in_struct);
2756     void initialize(const safe_VkSamplerReductionModeCreateInfo* copy_src);
ptrsafe_VkSamplerReductionModeCreateInfo2757     VkSamplerReductionModeCreateInfo *ptr() { return reinterpret_cast<VkSamplerReductionModeCreateInfo *>(this); }
ptrsafe_VkSamplerReductionModeCreateInfo2758     VkSamplerReductionModeCreateInfo const *ptr() const { return reinterpret_cast<VkSamplerReductionModeCreateInfo const *>(this); }
2759 };
2760 
2761 struct safe_VkPhysicalDeviceSamplerFilterMinmaxProperties {
2762     VkStructureType sType;
2763     void* pNext;
2764     VkBool32 filterMinmaxSingleComponentFormats;
2765     VkBool32 filterMinmaxImageComponentMapping;
2766     safe_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties* in_struct);
2767     safe_VkPhysicalDeviceSamplerFilterMinmaxProperties(const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& copy_src);
2768     safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& operator=(const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& copy_src);
2769     safe_VkPhysicalDeviceSamplerFilterMinmaxProperties();
2770     ~safe_VkPhysicalDeviceSamplerFilterMinmaxProperties();
2771     void initialize(const VkPhysicalDeviceSamplerFilterMinmaxProperties* in_struct);
2772     void initialize(const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties* copy_src);
ptrsafe_VkPhysicalDeviceSamplerFilterMinmaxProperties2773     VkPhysicalDeviceSamplerFilterMinmaxProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties *>(this); }
ptrsafe_VkPhysicalDeviceSamplerFilterMinmaxProperties2774     VkPhysicalDeviceSamplerFilterMinmaxProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties const *>(this); }
2775 };
2776 
2777 struct safe_VkPhysicalDeviceVulkanMemoryModelFeatures {
2778     VkStructureType sType;
2779     void* pNext;
2780     VkBool32 vulkanMemoryModel;
2781     VkBool32 vulkanMemoryModelDeviceScope;
2782     VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
2783     safe_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures* in_struct);
2784     safe_VkPhysicalDeviceVulkanMemoryModelFeatures(const safe_VkPhysicalDeviceVulkanMemoryModelFeatures& copy_src);
2785     safe_VkPhysicalDeviceVulkanMemoryModelFeatures& operator=(const safe_VkPhysicalDeviceVulkanMemoryModelFeatures& copy_src);
2786     safe_VkPhysicalDeviceVulkanMemoryModelFeatures();
2787     ~safe_VkPhysicalDeviceVulkanMemoryModelFeatures();
2788     void initialize(const VkPhysicalDeviceVulkanMemoryModelFeatures* in_struct);
2789     void initialize(const safe_VkPhysicalDeviceVulkanMemoryModelFeatures* copy_src);
ptrsafe_VkPhysicalDeviceVulkanMemoryModelFeatures2790     VkPhysicalDeviceVulkanMemoryModelFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures *>(this); }
ptrsafe_VkPhysicalDeviceVulkanMemoryModelFeatures2791     VkPhysicalDeviceVulkanMemoryModelFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures const *>(this); }
2792 };
2793 
2794 struct safe_VkPhysicalDeviceImagelessFramebufferFeatures {
2795     VkStructureType sType;
2796     void* pNext;
2797     VkBool32 imagelessFramebuffer;
2798     safe_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures* in_struct);
2799     safe_VkPhysicalDeviceImagelessFramebufferFeatures(const safe_VkPhysicalDeviceImagelessFramebufferFeatures& copy_src);
2800     safe_VkPhysicalDeviceImagelessFramebufferFeatures& operator=(const safe_VkPhysicalDeviceImagelessFramebufferFeatures& copy_src);
2801     safe_VkPhysicalDeviceImagelessFramebufferFeatures();
2802     ~safe_VkPhysicalDeviceImagelessFramebufferFeatures();
2803     void initialize(const VkPhysicalDeviceImagelessFramebufferFeatures* in_struct);
2804     void initialize(const safe_VkPhysicalDeviceImagelessFramebufferFeatures* copy_src);
ptrsafe_VkPhysicalDeviceImagelessFramebufferFeatures2805     VkPhysicalDeviceImagelessFramebufferFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures *>(this); }
ptrsafe_VkPhysicalDeviceImagelessFramebufferFeatures2806     VkPhysicalDeviceImagelessFramebufferFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures const *>(this); }
2807 };
2808 
2809 struct safe_VkFramebufferAttachmentImageInfo {
2810     VkStructureType sType;
2811     const void* pNext;
2812     VkImageCreateFlags flags;
2813     VkImageUsageFlags usage;
2814     uint32_t width;
2815     uint32_t height;
2816     uint32_t layerCount;
2817     uint32_t viewFormatCount;
2818     const VkFormat* pViewFormats;
2819     safe_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo* in_struct);
2820     safe_VkFramebufferAttachmentImageInfo(const safe_VkFramebufferAttachmentImageInfo& copy_src);
2821     safe_VkFramebufferAttachmentImageInfo& operator=(const safe_VkFramebufferAttachmentImageInfo& copy_src);
2822     safe_VkFramebufferAttachmentImageInfo();
2823     ~safe_VkFramebufferAttachmentImageInfo();
2824     void initialize(const VkFramebufferAttachmentImageInfo* in_struct);
2825     void initialize(const safe_VkFramebufferAttachmentImageInfo* copy_src);
ptrsafe_VkFramebufferAttachmentImageInfo2826     VkFramebufferAttachmentImageInfo *ptr() { return reinterpret_cast<VkFramebufferAttachmentImageInfo *>(this); }
ptrsafe_VkFramebufferAttachmentImageInfo2827     VkFramebufferAttachmentImageInfo const *ptr() const { return reinterpret_cast<VkFramebufferAttachmentImageInfo const *>(this); }
2828 };
2829 
2830 struct safe_VkFramebufferAttachmentsCreateInfo {
2831     VkStructureType sType;
2832     const void* pNext;
2833     uint32_t attachmentImageInfoCount;
2834     safe_VkFramebufferAttachmentImageInfo* pAttachmentImageInfos;
2835     safe_VkFramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo* in_struct);
2836     safe_VkFramebufferAttachmentsCreateInfo(const safe_VkFramebufferAttachmentsCreateInfo& copy_src);
2837     safe_VkFramebufferAttachmentsCreateInfo& operator=(const safe_VkFramebufferAttachmentsCreateInfo& copy_src);
2838     safe_VkFramebufferAttachmentsCreateInfo();
2839     ~safe_VkFramebufferAttachmentsCreateInfo();
2840     void initialize(const VkFramebufferAttachmentsCreateInfo* in_struct);
2841     void initialize(const safe_VkFramebufferAttachmentsCreateInfo* copy_src);
ptrsafe_VkFramebufferAttachmentsCreateInfo2842     VkFramebufferAttachmentsCreateInfo *ptr() { return reinterpret_cast<VkFramebufferAttachmentsCreateInfo *>(this); }
ptrsafe_VkFramebufferAttachmentsCreateInfo2843     VkFramebufferAttachmentsCreateInfo const *ptr() const { return reinterpret_cast<VkFramebufferAttachmentsCreateInfo const *>(this); }
2844 };
2845 
2846 struct safe_VkRenderPassAttachmentBeginInfo {
2847     VkStructureType sType;
2848     const void* pNext;
2849     uint32_t attachmentCount;
2850     VkImageView* pAttachments;
2851     safe_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo* in_struct);
2852     safe_VkRenderPassAttachmentBeginInfo(const safe_VkRenderPassAttachmentBeginInfo& copy_src);
2853     safe_VkRenderPassAttachmentBeginInfo& operator=(const safe_VkRenderPassAttachmentBeginInfo& copy_src);
2854     safe_VkRenderPassAttachmentBeginInfo();
2855     ~safe_VkRenderPassAttachmentBeginInfo();
2856     void initialize(const VkRenderPassAttachmentBeginInfo* in_struct);
2857     void initialize(const safe_VkRenderPassAttachmentBeginInfo* copy_src);
ptrsafe_VkRenderPassAttachmentBeginInfo2858     VkRenderPassAttachmentBeginInfo *ptr() { return reinterpret_cast<VkRenderPassAttachmentBeginInfo *>(this); }
ptrsafe_VkRenderPassAttachmentBeginInfo2859     VkRenderPassAttachmentBeginInfo const *ptr() const { return reinterpret_cast<VkRenderPassAttachmentBeginInfo const *>(this); }
2860 };
2861 
2862 struct safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures {
2863     VkStructureType sType;
2864     void* pNext;
2865     VkBool32 uniformBufferStandardLayout;
2866     safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* in_struct);
2867     safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& copy_src);
2868     safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& operator=(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& copy_src);
2869     safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures();
2870     ~safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures();
2871     void initialize(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* in_struct);
2872     void initialize(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures* copy_src);
ptrsafe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures2873     VkPhysicalDeviceUniformBufferStandardLayoutFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>(this); }
ptrsafe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures2874     VkPhysicalDeviceUniformBufferStandardLayoutFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures const *>(this); }
2875 };
2876 
2877 struct safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures {
2878     VkStructureType sType;
2879     void* pNext;
2880     VkBool32 shaderSubgroupExtendedTypes;
2881     safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* in_struct);
2882     safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& copy_src);
2883     safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& operator=(const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& copy_src);
2884     safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures();
2885     ~safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures();
2886     void initialize(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* in_struct);
2887     void initialize(const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* copy_src);
ptrsafe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures2888     VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>(this); }
ptrsafe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures2889     VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const *>(this); }
2890 };
2891 
2892 struct safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures {
2893     VkStructureType sType;
2894     void* pNext;
2895     VkBool32 separateDepthStencilLayouts;
2896     safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* in_struct);
2897     safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& copy_src);
2898     safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& operator=(const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& copy_src);
2899     safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures();
2900     ~safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures();
2901     void initialize(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* in_struct);
2902     void initialize(const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* copy_src);
ptrsafe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures2903     VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>(this); }
ptrsafe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures2904     VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const *>(this); }
2905 };
2906 
2907 struct safe_VkAttachmentReferenceStencilLayout {
2908     VkStructureType sType;
2909     void* pNext;
2910     VkImageLayout stencilLayout;
2911     safe_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout* in_struct);
2912     safe_VkAttachmentReferenceStencilLayout(const safe_VkAttachmentReferenceStencilLayout& copy_src);
2913     safe_VkAttachmentReferenceStencilLayout& operator=(const safe_VkAttachmentReferenceStencilLayout& copy_src);
2914     safe_VkAttachmentReferenceStencilLayout();
2915     ~safe_VkAttachmentReferenceStencilLayout();
2916     void initialize(const VkAttachmentReferenceStencilLayout* in_struct);
2917     void initialize(const safe_VkAttachmentReferenceStencilLayout* copy_src);
ptrsafe_VkAttachmentReferenceStencilLayout2918     VkAttachmentReferenceStencilLayout *ptr() { return reinterpret_cast<VkAttachmentReferenceStencilLayout *>(this); }
ptrsafe_VkAttachmentReferenceStencilLayout2919     VkAttachmentReferenceStencilLayout const *ptr() const { return reinterpret_cast<VkAttachmentReferenceStencilLayout const *>(this); }
2920 };
2921 
2922 struct safe_VkAttachmentDescriptionStencilLayout {
2923     VkStructureType sType;
2924     void* pNext;
2925     VkImageLayout stencilInitialLayout;
2926     VkImageLayout stencilFinalLayout;
2927     safe_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout* in_struct);
2928     safe_VkAttachmentDescriptionStencilLayout(const safe_VkAttachmentDescriptionStencilLayout& copy_src);
2929     safe_VkAttachmentDescriptionStencilLayout& operator=(const safe_VkAttachmentDescriptionStencilLayout& copy_src);
2930     safe_VkAttachmentDescriptionStencilLayout();
2931     ~safe_VkAttachmentDescriptionStencilLayout();
2932     void initialize(const VkAttachmentDescriptionStencilLayout* in_struct);
2933     void initialize(const safe_VkAttachmentDescriptionStencilLayout* copy_src);
ptrsafe_VkAttachmentDescriptionStencilLayout2934     VkAttachmentDescriptionStencilLayout *ptr() { return reinterpret_cast<VkAttachmentDescriptionStencilLayout *>(this); }
ptrsafe_VkAttachmentDescriptionStencilLayout2935     VkAttachmentDescriptionStencilLayout const *ptr() const { return reinterpret_cast<VkAttachmentDescriptionStencilLayout const *>(this); }
2936 };
2937 
2938 struct safe_VkPhysicalDeviceHostQueryResetFeatures {
2939     VkStructureType sType;
2940     void* pNext;
2941     VkBool32 hostQueryReset;
2942     safe_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures* in_struct);
2943     safe_VkPhysicalDeviceHostQueryResetFeatures(const safe_VkPhysicalDeviceHostQueryResetFeatures& copy_src);
2944     safe_VkPhysicalDeviceHostQueryResetFeatures& operator=(const safe_VkPhysicalDeviceHostQueryResetFeatures& copy_src);
2945     safe_VkPhysicalDeviceHostQueryResetFeatures();
2946     ~safe_VkPhysicalDeviceHostQueryResetFeatures();
2947     void initialize(const VkPhysicalDeviceHostQueryResetFeatures* in_struct);
2948     void initialize(const safe_VkPhysicalDeviceHostQueryResetFeatures* copy_src);
ptrsafe_VkPhysicalDeviceHostQueryResetFeatures2949     VkPhysicalDeviceHostQueryResetFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures *>(this); }
ptrsafe_VkPhysicalDeviceHostQueryResetFeatures2950     VkPhysicalDeviceHostQueryResetFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures const *>(this); }
2951 };
2952 
2953 struct safe_VkPhysicalDeviceTimelineSemaphoreFeatures {
2954     VkStructureType sType;
2955     void* pNext;
2956     VkBool32 timelineSemaphore;
2957     safe_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures* in_struct);
2958     safe_VkPhysicalDeviceTimelineSemaphoreFeatures(const safe_VkPhysicalDeviceTimelineSemaphoreFeatures& copy_src);
2959     safe_VkPhysicalDeviceTimelineSemaphoreFeatures& operator=(const safe_VkPhysicalDeviceTimelineSemaphoreFeatures& copy_src);
2960     safe_VkPhysicalDeviceTimelineSemaphoreFeatures();
2961     ~safe_VkPhysicalDeviceTimelineSemaphoreFeatures();
2962     void initialize(const VkPhysicalDeviceTimelineSemaphoreFeatures* in_struct);
2963     void initialize(const safe_VkPhysicalDeviceTimelineSemaphoreFeatures* copy_src);
ptrsafe_VkPhysicalDeviceTimelineSemaphoreFeatures2964     VkPhysicalDeviceTimelineSemaphoreFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures *>(this); }
ptrsafe_VkPhysicalDeviceTimelineSemaphoreFeatures2965     VkPhysicalDeviceTimelineSemaphoreFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures const *>(this); }
2966 };
2967 
2968 struct safe_VkPhysicalDeviceTimelineSemaphoreProperties {
2969     VkStructureType sType;
2970     void* pNext;
2971     uint64_t maxTimelineSemaphoreValueDifference;
2972     safe_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties* in_struct);
2973     safe_VkPhysicalDeviceTimelineSemaphoreProperties(const safe_VkPhysicalDeviceTimelineSemaphoreProperties& copy_src);
2974     safe_VkPhysicalDeviceTimelineSemaphoreProperties& operator=(const safe_VkPhysicalDeviceTimelineSemaphoreProperties& copy_src);
2975     safe_VkPhysicalDeviceTimelineSemaphoreProperties();
2976     ~safe_VkPhysicalDeviceTimelineSemaphoreProperties();
2977     void initialize(const VkPhysicalDeviceTimelineSemaphoreProperties* in_struct);
2978     void initialize(const safe_VkPhysicalDeviceTimelineSemaphoreProperties* copy_src);
ptrsafe_VkPhysicalDeviceTimelineSemaphoreProperties2979     VkPhysicalDeviceTimelineSemaphoreProperties *ptr() { return reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties *>(this); }
ptrsafe_VkPhysicalDeviceTimelineSemaphoreProperties2980     VkPhysicalDeviceTimelineSemaphoreProperties const *ptr() const { return reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties const *>(this); }
2981 };
2982 
2983 struct safe_VkSemaphoreTypeCreateInfo {
2984     VkStructureType sType;
2985     const void* pNext;
2986     VkSemaphoreType semaphoreType;
2987     uint64_t initialValue;
2988     safe_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo* in_struct);
2989     safe_VkSemaphoreTypeCreateInfo(const safe_VkSemaphoreTypeCreateInfo& copy_src);
2990     safe_VkSemaphoreTypeCreateInfo& operator=(const safe_VkSemaphoreTypeCreateInfo& copy_src);
2991     safe_VkSemaphoreTypeCreateInfo();
2992     ~safe_VkSemaphoreTypeCreateInfo();
2993     void initialize(const VkSemaphoreTypeCreateInfo* in_struct);
2994     void initialize(const safe_VkSemaphoreTypeCreateInfo* copy_src);
ptrsafe_VkSemaphoreTypeCreateInfo2995     VkSemaphoreTypeCreateInfo *ptr() { return reinterpret_cast<VkSemaphoreTypeCreateInfo *>(this); }
ptrsafe_VkSemaphoreTypeCreateInfo2996     VkSemaphoreTypeCreateInfo const *ptr() const { return reinterpret_cast<VkSemaphoreTypeCreateInfo const *>(this); }
2997 };
2998 
2999 struct safe_VkTimelineSemaphoreSubmitInfo {
3000     VkStructureType sType;
3001     const void* pNext;
3002     uint32_t waitSemaphoreValueCount;
3003     const uint64_t* pWaitSemaphoreValues;
3004     uint32_t signalSemaphoreValueCount;
3005     const uint64_t* pSignalSemaphoreValues;
3006     safe_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo* in_struct);
3007     safe_VkTimelineSemaphoreSubmitInfo(const safe_VkTimelineSemaphoreSubmitInfo& copy_src);
3008     safe_VkTimelineSemaphoreSubmitInfo& operator=(const safe_VkTimelineSemaphoreSubmitInfo& copy_src);
3009     safe_VkTimelineSemaphoreSubmitInfo();
3010     ~safe_VkTimelineSemaphoreSubmitInfo();
3011     void initialize(const VkTimelineSemaphoreSubmitInfo* in_struct);
3012     void initialize(const safe_VkTimelineSemaphoreSubmitInfo* copy_src);
ptrsafe_VkTimelineSemaphoreSubmitInfo3013     VkTimelineSemaphoreSubmitInfo *ptr() { return reinterpret_cast<VkTimelineSemaphoreSubmitInfo *>(this); }
ptrsafe_VkTimelineSemaphoreSubmitInfo3014     VkTimelineSemaphoreSubmitInfo const *ptr() const { return reinterpret_cast<VkTimelineSemaphoreSubmitInfo const *>(this); }
3015 };
3016 
3017 struct safe_VkSemaphoreWaitInfo {
3018     VkStructureType sType;
3019     const void* pNext;
3020     VkSemaphoreWaitFlags flags;
3021     uint32_t semaphoreCount;
3022     VkSemaphore* pSemaphores;
3023     const uint64_t* pValues;
3024     safe_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo* in_struct);
3025     safe_VkSemaphoreWaitInfo(const safe_VkSemaphoreWaitInfo& copy_src);
3026     safe_VkSemaphoreWaitInfo& operator=(const safe_VkSemaphoreWaitInfo& copy_src);
3027     safe_VkSemaphoreWaitInfo();
3028     ~safe_VkSemaphoreWaitInfo();
3029     void initialize(const VkSemaphoreWaitInfo* in_struct);
3030     void initialize(const safe_VkSemaphoreWaitInfo* copy_src);
ptrsafe_VkSemaphoreWaitInfo3031     VkSemaphoreWaitInfo *ptr() { return reinterpret_cast<VkSemaphoreWaitInfo *>(this); }
ptrsafe_VkSemaphoreWaitInfo3032     VkSemaphoreWaitInfo const *ptr() const { return reinterpret_cast<VkSemaphoreWaitInfo const *>(this); }
3033 };
3034 
3035 struct safe_VkSemaphoreSignalInfo {
3036     VkStructureType sType;
3037     const void* pNext;
3038     VkSemaphore semaphore;
3039     uint64_t value;
3040     safe_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo* in_struct);
3041     safe_VkSemaphoreSignalInfo(const safe_VkSemaphoreSignalInfo& copy_src);
3042     safe_VkSemaphoreSignalInfo& operator=(const safe_VkSemaphoreSignalInfo& copy_src);
3043     safe_VkSemaphoreSignalInfo();
3044     ~safe_VkSemaphoreSignalInfo();
3045     void initialize(const VkSemaphoreSignalInfo* in_struct);
3046     void initialize(const safe_VkSemaphoreSignalInfo* copy_src);
ptrsafe_VkSemaphoreSignalInfo3047     VkSemaphoreSignalInfo *ptr() { return reinterpret_cast<VkSemaphoreSignalInfo *>(this); }
ptrsafe_VkSemaphoreSignalInfo3048     VkSemaphoreSignalInfo const *ptr() const { return reinterpret_cast<VkSemaphoreSignalInfo const *>(this); }
3049 };
3050 
3051 struct safe_VkPhysicalDeviceBufferDeviceAddressFeatures {
3052     VkStructureType sType;
3053     void* pNext;
3054     VkBool32 bufferDeviceAddress;
3055     VkBool32 bufferDeviceAddressCaptureReplay;
3056     VkBool32 bufferDeviceAddressMultiDevice;
3057     safe_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures* in_struct);
3058     safe_VkPhysicalDeviceBufferDeviceAddressFeatures(const safe_VkPhysicalDeviceBufferDeviceAddressFeatures& copy_src);
3059     safe_VkPhysicalDeviceBufferDeviceAddressFeatures& operator=(const safe_VkPhysicalDeviceBufferDeviceAddressFeatures& copy_src);
3060     safe_VkPhysicalDeviceBufferDeviceAddressFeatures();
3061     ~safe_VkPhysicalDeviceBufferDeviceAddressFeatures();
3062     void initialize(const VkPhysicalDeviceBufferDeviceAddressFeatures* in_struct);
3063     void initialize(const safe_VkPhysicalDeviceBufferDeviceAddressFeatures* copy_src);
ptrsafe_VkPhysicalDeviceBufferDeviceAddressFeatures3064     VkPhysicalDeviceBufferDeviceAddressFeatures *ptr() { return reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures *>(this); }
ptrsafe_VkPhysicalDeviceBufferDeviceAddressFeatures3065     VkPhysicalDeviceBufferDeviceAddressFeatures const *ptr() const { return reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures const *>(this); }
3066 };
3067 
3068 struct safe_VkBufferDeviceAddressInfo {
3069     VkStructureType sType;
3070     const void* pNext;
3071     VkBuffer buffer;
3072     safe_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo* in_struct);
3073     safe_VkBufferDeviceAddressInfo(const safe_VkBufferDeviceAddressInfo& copy_src);
3074     safe_VkBufferDeviceAddressInfo& operator=(const safe_VkBufferDeviceAddressInfo& copy_src);
3075     safe_VkBufferDeviceAddressInfo();
3076     ~safe_VkBufferDeviceAddressInfo();
3077     void initialize(const VkBufferDeviceAddressInfo* in_struct);
3078     void initialize(const safe_VkBufferDeviceAddressInfo* copy_src);
ptrsafe_VkBufferDeviceAddressInfo3079     VkBufferDeviceAddressInfo *ptr() { return reinterpret_cast<VkBufferDeviceAddressInfo *>(this); }
ptrsafe_VkBufferDeviceAddressInfo3080     VkBufferDeviceAddressInfo const *ptr() const { return reinterpret_cast<VkBufferDeviceAddressInfo const *>(this); }
3081 };
3082 
3083 struct safe_VkBufferOpaqueCaptureAddressCreateInfo {
3084     VkStructureType sType;
3085     const void* pNext;
3086     uint64_t opaqueCaptureAddress;
3087     safe_VkBufferOpaqueCaptureAddressCreateInfo(const VkBufferOpaqueCaptureAddressCreateInfo* in_struct);
3088     safe_VkBufferOpaqueCaptureAddressCreateInfo(const safe_VkBufferOpaqueCaptureAddressCreateInfo& copy_src);
3089     safe_VkBufferOpaqueCaptureAddressCreateInfo& operator=(const safe_VkBufferOpaqueCaptureAddressCreateInfo& copy_src);
3090     safe_VkBufferOpaqueCaptureAddressCreateInfo();
3091     ~safe_VkBufferOpaqueCaptureAddressCreateInfo();
3092     void initialize(const VkBufferOpaqueCaptureAddressCreateInfo* in_struct);
3093     void initialize(const safe_VkBufferOpaqueCaptureAddressCreateInfo* copy_src);
ptrsafe_VkBufferOpaqueCaptureAddressCreateInfo3094     VkBufferOpaqueCaptureAddressCreateInfo *ptr() { return reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo *>(this); }
ptrsafe_VkBufferOpaqueCaptureAddressCreateInfo3095     VkBufferOpaqueCaptureAddressCreateInfo const *ptr() const { return reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo const *>(this); }
3096 };
3097 
3098 struct safe_VkMemoryOpaqueCaptureAddressAllocateInfo {
3099     VkStructureType sType;
3100     const void* pNext;
3101     uint64_t opaqueCaptureAddress;
3102     safe_VkMemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo* in_struct);
3103     safe_VkMemoryOpaqueCaptureAddressAllocateInfo(const safe_VkMemoryOpaqueCaptureAddressAllocateInfo& copy_src);
3104     safe_VkMemoryOpaqueCaptureAddressAllocateInfo& operator=(const safe_VkMemoryOpaqueCaptureAddressAllocateInfo& copy_src);
3105     safe_VkMemoryOpaqueCaptureAddressAllocateInfo();
3106     ~safe_VkMemoryOpaqueCaptureAddressAllocateInfo();
3107     void initialize(const VkMemoryOpaqueCaptureAddressAllocateInfo* in_struct);
3108     void initialize(const safe_VkMemoryOpaqueCaptureAddressAllocateInfo* copy_src);
ptrsafe_VkMemoryOpaqueCaptureAddressAllocateInfo3109     VkMemoryOpaqueCaptureAddressAllocateInfo *ptr() { return reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo *>(this); }
ptrsafe_VkMemoryOpaqueCaptureAddressAllocateInfo3110     VkMemoryOpaqueCaptureAddressAllocateInfo const *ptr() const { return reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo const *>(this); }
3111 };
3112 
3113 struct safe_VkDeviceMemoryOpaqueCaptureAddressInfo {
3114     VkStructureType sType;
3115     const void* pNext;
3116     VkDeviceMemory memory;
3117     safe_VkDeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo* in_struct);
3118     safe_VkDeviceMemoryOpaqueCaptureAddressInfo(const safe_VkDeviceMemoryOpaqueCaptureAddressInfo& copy_src);
3119     safe_VkDeviceMemoryOpaqueCaptureAddressInfo& operator=(const safe_VkDeviceMemoryOpaqueCaptureAddressInfo& copy_src);
3120     safe_VkDeviceMemoryOpaqueCaptureAddressInfo();
3121     ~safe_VkDeviceMemoryOpaqueCaptureAddressInfo();
3122     void initialize(const VkDeviceMemoryOpaqueCaptureAddressInfo* in_struct);
3123     void initialize(const safe_VkDeviceMemoryOpaqueCaptureAddressInfo* copy_src);
ptrsafe_VkDeviceMemoryOpaqueCaptureAddressInfo3124     VkDeviceMemoryOpaqueCaptureAddressInfo *ptr() { return reinterpret_cast<VkDeviceMemoryOpaqueCaptureAddressInfo *>(this); }
ptrsafe_VkDeviceMemoryOpaqueCaptureAddressInfo3125     VkDeviceMemoryOpaqueCaptureAddressInfo const *ptr() const { return reinterpret_cast<VkDeviceMemoryOpaqueCaptureAddressInfo const *>(this); }
3126 };
3127 
3128 struct safe_VkSwapchainCreateInfoKHR {
3129     VkStructureType sType;
3130     const void* pNext;
3131     VkSwapchainCreateFlagsKHR flags;
3132     VkSurfaceKHR surface;
3133     uint32_t minImageCount;
3134     VkFormat imageFormat;
3135     VkColorSpaceKHR imageColorSpace;
3136     VkExtent2D imageExtent;
3137     uint32_t imageArrayLayers;
3138     VkImageUsageFlags imageUsage;
3139     VkSharingMode imageSharingMode;
3140     uint32_t queueFamilyIndexCount;
3141     const uint32_t* pQueueFamilyIndices;
3142     VkSurfaceTransformFlagBitsKHR preTransform;
3143     VkCompositeAlphaFlagBitsKHR compositeAlpha;
3144     VkPresentModeKHR presentMode;
3145     VkBool32 clipped;
3146     VkSwapchainKHR oldSwapchain;
3147     safe_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR* in_struct);
3148     safe_VkSwapchainCreateInfoKHR(const safe_VkSwapchainCreateInfoKHR& copy_src);
3149     safe_VkSwapchainCreateInfoKHR& operator=(const safe_VkSwapchainCreateInfoKHR& copy_src);
3150     safe_VkSwapchainCreateInfoKHR();
3151     ~safe_VkSwapchainCreateInfoKHR();
3152     void initialize(const VkSwapchainCreateInfoKHR* in_struct);
3153     void initialize(const safe_VkSwapchainCreateInfoKHR* copy_src);
ptrsafe_VkSwapchainCreateInfoKHR3154     VkSwapchainCreateInfoKHR *ptr() { return reinterpret_cast<VkSwapchainCreateInfoKHR *>(this); }
ptrsafe_VkSwapchainCreateInfoKHR3155     VkSwapchainCreateInfoKHR const *ptr() const { return reinterpret_cast<VkSwapchainCreateInfoKHR const *>(this); }
3156 };
3157 
3158 struct safe_VkPresentInfoKHR {
3159     VkStructureType sType;
3160     const void* pNext;
3161     uint32_t waitSemaphoreCount;
3162     VkSemaphore* pWaitSemaphores;
3163     uint32_t swapchainCount;
3164     VkSwapchainKHR* pSwapchains;
3165     const uint32_t* pImageIndices;
3166     VkResult* pResults;
3167     safe_VkPresentInfoKHR(const VkPresentInfoKHR* in_struct);
3168     safe_VkPresentInfoKHR(const safe_VkPresentInfoKHR& copy_src);
3169     safe_VkPresentInfoKHR& operator=(const safe_VkPresentInfoKHR& copy_src);
3170     safe_VkPresentInfoKHR();
3171     ~safe_VkPresentInfoKHR();
3172     void initialize(const VkPresentInfoKHR* in_struct);
3173     void initialize(const safe_VkPresentInfoKHR* copy_src);
ptrsafe_VkPresentInfoKHR3174     VkPresentInfoKHR *ptr() { return reinterpret_cast<VkPresentInfoKHR *>(this); }
ptrsafe_VkPresentInfoKHR3175     VkPresentInfoKHR const *ptr() const { return reinterpret_cast<VkPresentInfoKHR const *>(this); }
3176 };
3177 
3178 struct safe_VkImageSwapchainCreateInfoKHR {
3179     VkStructureType sType;
3180     const void* pNext;
3181     VkSwapchainKHR swapchain;
3182     safe_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR* in_struct);
3183     safe_VkImageSwapchainCreateInfoKHR(const safe_VkImageSwapchainCreateInfoKHR& copy_src);
3184     safe_VkImageSwapchainCreateInfoKHR& operator=(const safe_VkImageSwapchainCreateInfoKHR& copy_src);
3185     safe_VkImageSwapchainCreateInfoKHR();
3186     ~safe_VkImageSwapchainCreateInfoKHR();
3187     void initialize(const VkImageSwapchainCreateInfoKHR* in_struct);
3188     void initialize(const safe_VkImageSwapchainCreateInfoKHR* copy_src);
ptrsafe_VkImageSwapchainCreateInfoKHR3189     VkImageSwapchainCreateInfoKHR *ptr() { return reinterpret_cast<VkImageSwapchainCreateInfoKHR *>(this); }
ptrsafe_VkImageSwapchainCreateInfoKHR3190     VkImageSwapchainCreateInfoKHR const *ptr() const { return reinterpret_cast<VkImageSwapchainCreateInfoKHR const *>(this); }
3191 };
3192 
3193 struct safe_VkBindImageMemorySwapchainInfoKHR {
3194     VkStructureType sType;
3195     const void* pNext;
3196     VkSwapchainKHR swapchain;
3197     uint32_t imageIndex;
3198     safe_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR* in_struct);
3199     safe_VkBindImageMemorySwapchainInfoKHR(const safe_VkBindImageMemorySwapchainInfoKHR& copy_src);
3200     safe_VkBindImageMemorySwapchainInfoKHR& operator=(const safe_VkBindImageMemorySwapchainInfoKHR& copy_src);
3201     safe_VkBindImageMemorySwapchainInfoKHR();
3202     ~safe_VkBindImageMemorySwapchainInfoKHR();
3203     void initialize(const VkBindImageMemorySwapchainInfoKHR* in_struct);
3204     void initialize(const safe_VkBindImageMemorySwapchainInfoKHR* copy_src);
ptrsafe_VkBindImageMemorySwapchainInfoKHR3205     VkBindImageMemorySwapchainInfoKHR *ptr() { return reinterpret_cast<VkBindImageMemorySwapchainInfoKHR *>(this); }
ptrsafe_VkBindImageMemorySwapchainInfoKHR3206     VkBindImageMemorySwapchainInfoKHR const *ptr() const { return reinterpret_cast<VkBindImageMemorySwapchainInfoKHR const *>(this); }
3207 };
3208 
3209 struct safe_VkAcquireNextImageInfoKHR {
3210     VkStructureType sType;
3211     const void* pNext;
3212     VkSwapchainKHR swapchain;
3213     uint64_t timeout;
3214     VkSemaphore semaphore;
3215     VkFence fence;
3216     uint32_t deviceMask;
3217     safe_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR* in_struct);
3218     safe_VkAcquireNextImageInfoKHR(const safe_VkAcquireNextImageInfoKHR& copy_src);
3219     safe_VkAcquireNextImageInfoKHR& operator=(const safe_VkAcquireNextImageInfoKHR& copy_src);
3220     safe_VkAcquireNextImageInfoKHR();
3221     ~safe_VkAcquireNextImageInfoKHR();
3222     void initialize(const VkAcquireNextImageInfoKHR* in_struct);
3223     void initialize(const safe_VkAcquireNextImageInfoKHR* copy_src);
ptrsafe_VkAcquireNextImageInfoKHR3224     VkAcquireNextImageInfoKHR *ptr() { return reinterpret_cast<VkAcquireNextImageInfoKHR *>(this); }
ptrsafe_VkAcquireNextImageInfoKHR3225     VkAcquireNextImageInfoKHR const *ptr() const { return reinterpret_cast<VkAcquireNextImageInfoKHR const *>(this); }
3226 };
3227 
3228 struct safe_VkDeviceGroupPresentCapabilitiesKHR {
3229     VkStructureType sType;
3230     const void* pNext;
3231     uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
3232     VkDeviceGroupPresentModeFlagsKHR modes;
3233     safe_VkDeviceGroupPresentCapabilitiesKHR(const VkDeviceGroupPresentCapabilitiesKHR* in_struct);
3234     safe_VkDeviceGroupPresentCapabilitiesKHR(const safe_VkDeviceGroupPresentCapabilitiesKHR& copy_src);
3235     safe_VkDeviceGroupPresentCapabilitiesKHR& operator=(const safe_VkDeviceGroupPresentCapabilitiesKHR& copy_src);
3236     safe_VkDeviceGroupPresentCapabilitiesKHR();
3237     ~safe_VkDeviceGroupPresentCapabilitiesKHR();
3238     void initialize(const VkDeviceGroupPresentCapabilitiesKHR* in_struct);
3239     void initialize(const safe_VkDeviceGroupPresentCapabilitiesKHR* copy_src);
ptrsafe_VkDeviceGroupPresentCapabilitiesKHR3240     VkDeviceGroupPresentCapabilitiesKHR *ptr() { return reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>(this); }
ptrsafe_VkDeviceGroupPresentCapabilitiesKHR3241     VkDeviceGroupPresentCapabilitiesKHR const *ptr() const { return reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR const *>(this); }
3242 };
3243 
3244 struct safe_VkDeviceGroupPresentInfoKHR {
3245     VkStructureType sType;
3246     const void* pNext;
3247     uint32_t swapchainCount;
3248     const uint32_t* pDeviceMasks;
3249     VkDeviceGroupPresentModeFlagBitsKHR mode;
3250     safe_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR* in_struct);
3251     safe_VkDeviceGroupPresentInfoKHR(const safe_VkDeviceGroupPresentInfoKHR& copy_src);
3252     safe_VkDeviceGroupPresentInfoKHR& operator=(const safe_VkDeviceGroupPresentInfoKHR& copy_src);
3253     safe_VkDeviceGroupPresentInfoKHR();
3254     ~safe_VkDeviceGroupPresentInfoKHR();
3255     void initialize(const VkDeviceGroupPresentInfoKHR* in_struct);
3256     void initialize(const safe_VkDeviceGroupPresentInfoKHR* copy_src);
ptrsafe_VkDeviceGroupPresentInfoKHR3257     VkDeviceGroupPresentInfoKHR *ptr() { return reinterpret_cast<VkDeviceGroupPresentInfoKHR *>(this); }
ptrsafe_VkDeviceGroupPresentInfoKHR3258     VkDeviceGroupPresentInfoKHR const *ptr() const { return reinterpret_cast<VkDeviceGroupPresentInfoKHR const *>(this); }
3259 };
3260 
3261 struct safe_VkDeviceGroupSwapchainCreateInfoKHR {
3262     VkStructureType sType;
3263     const void* pNext;
3264     VkDeviceGroupPresentModeFlagsKHR modes;
3265     safe_VkDeviceGroupSwapchainCreateInfoKHR(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct);
3266     safe_VkDeviceGroupSwapchainCreateInfoKHR(const safe_VkDeviceGroupSwapchainCreateInfoKHR& copy_src);
3267     safe_VkDeviceGroupSwapchainCreateInfoKHR& operator=(const safe_VkDeviceGroupSwapchainCreateInfoKHR& copy_src);
3268     safe_VkDeviceGroupSwapchainCreateInfoKHR();
3269     ~safe_VkDeviceGroupSwapchainCreateInfoKHR();
3270     void initialize(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct);
3271     void initialize(const safe_VkDeviceGroupSwapchainCreateInfoKHR* copy_src);
ptrsafe_VkDeviceGroupSwapchainCreateInfoKHR3272     VkDeviceGroupSwapchainCreateInfoKHR *ptr() { return reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR *>(this); }
ptrsafe_VkDeviceGroupSwapchainCreateInfoKHR3273     VkDeviceGroupSwapchainCreateInfoKHR const *ptr() const { return reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR const *>(this); }
3274 };
3275 
3276 struct safe_VkDisplayModeCreateInfoKHR {
3277     VkStructureType sType;
3278     const void* pNext;
3279     VkDisplayModeCreateFlagsKHR flags;
3280     VkDisplayModeParametersKHR parameters;
3281     safe_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR* in_struct);
3282     safe_VkDisplayModeCreateInfoKHR(const safe_VkDisplayModeCreateInfoKHR& copy_src);
3283     safe_VkDisplayModeCreateInfoKHR& operator=(const safe_VkDisplayModeCreateInfoKHR& copy_src);
3284     safe_VkDisplayModeCreateInfoKHR();
3285     ~safe_VkDisplayModeCreateInfoKHR();
3286     void initialize(const VkDisplayModeCreateInfoKHR* in_struct);
3287     void initialize(const safe_VkDisplayModeCreateInfoKHR* copy_src);
ptrsafe_VkDisplayModeCreateInfoKHR3288     VkDisplayModeCreateInfoKHR *ptr() { return reinterpret_cast<VkDisplayModeCreateInfoKHR *>(this); }
ptrsafe_VkDisplayModeCreateInfoKHR3289     VkDisplayModeCreateInfoKHR const *ptr() const { return reinterpret_cast<VkDisplayModeCreateInfoKHR const *>(this); }
3290 };
3291 
3292 struct safe_VkDisplayPropertiesKHR {
3293     VkDisplayKHR display;
3294     const char* displayName;
3295     VkExtent2D physicalDimensions;
3296     VkExtent2D physicalResolution;
3297     VkSurfaceTransformFlagsKHR supportedTransforms;
3298     VkBool32 planeReorderPossible;
3299     VkBool32 persistentContent;
3300     safe_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR* in_struct);
3301     safe_VkDisplayPropertiesKHR(const safe_VkDisplayPropertiesKHR& copy_src);
3302     safe_VkDisplayPropertiesKHR& operator=(const safe_VkDisplayPropertiesKHR& copy_src);
3303     safe_VkDisplayPropertiesKHR();
3304     ~safe_VkDisplayPropertiesKHR();
3305     void initialize(const VkDisplayPropertiesKHR* in_struct);
3306     void initialize(const safe_VkDisplayPropertiesKHR* copy_src);
ptrsafe_VkDisplayPropertiesKHR3307     VkDisplayPropertiesKHR *ptr() { return reinterpret_cast<VkDisplayPropertiesKHR *>(this); }
ptrsafe_VkDisplayPropertiesKHR3308     VkDisplayPropertiesKHR const *ptr() const { return reinterpret_cast<VkDisplayPropertiesKHR const *>(this); }
3309 };
3310 
3311 struct safe_VkDisplaySurfaceCreateInfoKHR {
3312     VkStructureType sType;
3313     const void* pNext;
3314     VkDisplaySurfaceCreateFlagsKHR flags;
3315     VkDisplayModeKHR displayMode;
3316     uint32_t planeIndex;
3317     uint32_t planeStackIndex;
3318     VkSurfaceTransformFlagBitsKHR transform;
3319     float globalAlpha;
3320     VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
3321     VkExtent2D imageExtent;
3322     safe_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR* in_struct);
3323     safe_VkDisplaySurfaceCreateInfoKHR(const safe_VkDisplaySurfaceCreateInfoKHR& copy_src);
3324     safe_VkDisplaySurfaceCreateInfoKHR& operator=(const safe_VkDisplaySurfaceCreateInfoKHR& copy_src);
3325     safe_VkDisplaySurfaceCreateInfoKHR();
3326     ~safe_VkDisplaySurfaceCreateInfoKHR();
3327     void initialize(const VkDisplaySurfaceCreateInfoKHR* in_struct);
3328     void initialize(const safe_VkDisplaySurfaceCreateInfoKHR* copy_src);
ptrsafe_VkDisplaySurfaceCreateInfoKHR3329     VkDisplaySurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkDisplaySurfaceCreateInfoKHR *>(this); }
ptrsafe_VkDisplaySurfaceCreateInfoKHR3330     VkDisplaySurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkDisplaySurfaceCreateInfoKHR const *>(this); }
3331 };
3332 
3333 struct safe_VkDisplayPresentInfoKHR {
3334     VkStructureType sType;
3335     const void* pNext;
3336     VkRect2D srcRect;
3337     VkRect2D dstRect;
3338     VkBool32 persistent;
3339     safe_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR* in_struct);
3340     safe_VkDisplayPresentInfoKHR(const safe_VkDisplayPresentInfoKHR& copy_src);
3341     safe_VkDisplayPresentInfoKHR& operator=(const safe_VkDisplayPresentInfoKHR& copy_src);
3342     safe_VkDisplayPresentInfoKHR();
3343     ~safe_VkDisplayPresentInfoKHR();
3344     void initialize(const VkDisplayPresentInfoKHR* in_struct);
3345     void initialize(const safe_VkDisplayPresentInfoKHR* copy_src);
ptrsafe_VkDisplayPresentInfoKHR3346     VkDisplayPresentInfoKHR *ptr() { return reinterpret_cast<VkDisplayPresentInfoKHR *>(this); }
ptrsafe_VkDisplayPresentInfoKHR3347     VkDisplayPresentInfoKHR const *ptr() const { return reinterpret_cast<VkDisplayPresentInfoKHR const *>(this); }
3348 };
3349 
3350 #ifdef VK_USE_PLATFORM_XLIB_KHR
3351 struct safe_VkXlibSurfaceCreateInfoKHR {
3352     VkStructureType sType;
3353     const void* pNext;
3354     VkXlibSurfaceCreateFlagsKHR flags;
3355     Display* dpy;
3356     Window window;
3357     safe_VkXlibSurfaceCreateInfoKHR(const VkXlibSurfaceCreateInfoKHR* in_struct);
3358     safe_VkXlibSurfaceCreateInfoKHR(const safe_VkXlibSurfaceCreateInfoKHR& copy_src);
3359     safe_VkXlibSurfaceCreateInfoKHR& operator=(const safe_VkXlibSurfaceCreateInfoKHR& copy_src);
3360     safe_VkXlibSurfaceCreateInfoKHR();
3361     ~safe_VkXlibSurfaceCreateInfoKHR();
3362     void initialize(const VkXlibSurfaceCreateInfoKHR* in_struct);
3363     void initialize(const safe_VkXlibSurfaceCreateInfoKHR* copy_src);
ptrsafe_VkXlibSurfaceCreateInfoKHR3364     VkXlibSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkXlibSurfaceCreateInfoKHR *>(this); }
ptrsafe_VkXlibSurfaceCreateInfoKHR3365     VkXlibSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkXlibSurfaceCreateInfoKHR const *>(this); }
3366 };
3367 #endif // VK_USE_PLATFORM_XLIB_KHR
3368 
3369 #ifdef VK_USE_PLATFORM_XCB_KHR
3370 struct safe_VkXcbSurfaceCreateInfoKHR {
3371     VkStructureType sType;
3372     const void* pNext;
3373     VkXcbSurfaceCreateFlagsKHR flags;
3374     xcb_connection_t* connection;
3375     xcb_window_t window;
3376     safe_VkXcbSurfaceCreateInfoKHR(const VkXcbSurfaceCreateInfoKHR* in_struct);
3377     safe_VkXcbSurfaceCreateInfoKHR(const safe_VkXcbSurfaceCreateInfoKHR& copy_src);
3378     safe_VkXcbSurfaceCreateInfoKHR& operator=(const safe_VkXcbSurfaceCreateInfoKHR& copy_src);
3379     safe_VkXcbSurfaceCreateInfoKHR();
3380     ~safe_VkXcbSurfaceCreateInfoKHR();
3381     void initialize(const VkXcbSurfaceCreateInfoKHR* in_struct);
3382     void initialize(const safe_VkXcbSurfaceCreateInfoKHR* copy_src);
ptrsafe_VkXcbSurfaceCreateInfoKHR3383     VkXcbSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkXcbSurfaceCreateInfoKHR *>(this); }
ptrsafe_VkXcbSurfaceCreateInfoKHR3384     VkXcbSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkXcbSurfaceCreateInfoKHR const *>(this); }
3385 };
3386 #endif // VK_USE_PLATFORM_XCB_KHR
3387 
3388 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
3389 struct safe_VkWaylandSurfaceCreateInfoKHR {
3390     VkStructureType sType;
3391     const void* pNext;
3392     VkWaylandSurfaceCreateFlagsKHR flags;
3393     struct wl_display* display;
3394     struct wl_surface* surface;
3395     safe_VkWaylandSurfaceCreateInfoKHR(const VkWaylandSurfaceCreateInfoKHR* in_struct);
3396     safe_VkWaylandSurfaceCreateInfoKHR(const safe_VkWaylandSurfaceCreateInfoKHR& copy_src);
3397     safe_VkWaylandSurfaceCreateInfoKHR& operator=(const safe_VkWaylandSurfaceCreateInfoKHR& copy_src);
3398     safe_VkWaylandSurfaceCreateInfoKHR();
3399     ~safe_VkWaylandSurfaceCreateInfoKHR();
3400     void initialize(const VkWaylandSurfaceCreateInfoKHR* in_struct);
3401     void initialize(const safe_VkWaylandSurfaceCreateInfoKHR* copy_src);
ptrsafe_VkWaylandSurfaceCreateInfoKHR3402     VkWaylandSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkWaylandSurfaceCreateInfoKHR *>(this); }
ptrsafe_VkWaylandSurfaceCreateInfoKHR3403     VkWaylandSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkWaylandSurfaceCreateInfoKHR const *>(this); }
3404 };
3405 #endif // VK_USE_PLATFORM_WAYLAND_KHR
3406 
3407 #ifdef VK_USE_PLATFORM_ANDROID_KHR
3408 struct safe_VkAndroidSurfaceCreateInfoKHR {
3409     VkStructureType sType;
3410     const void* pNext;
3411     VkAndroidSurfaceCreateFlagsKHR flags;
3412     struct ANativeWindow* window;
3413     safe_VkAndroidSurfaceCreateInfoKHR(const VkAndroidSurfaceCreateInfoKHR* in_struct);
3414     safe_VkAndroidSurfaceCreateInfoKHR(const safe_VkAndroidSurfaceCreateInfoKHR& copy_src);
3415     safe_VkAndroidSurfaceCreateInfoKHR& operator=(const safe_VkAndroidSurfaceCreateInfoKHR& copy_src);
3416     safe_VkAndroidSurfaceCreateInfoKHR();
3417     ~safe_VkAndroidSurfaceCreateInfoKHR();
3418     void initialize(const VkAndroidSurfaceCreateInfoKHR* in_struct);
3419     void initialize(const safe_VkAndroidSurfaceCreateInfoKHR* copy_src);
ptrsafe_VkAndroidSurfaceCreateInfoKHR3420     VkAndroidSurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkAndroidSurfaceCreateInfoKHR *>(this); }
ptrsafe_VkAndroidSurfaceCreateInfoKHR3421     VkAndroidSurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkAndroidSurfaceCreateInfoKHR const *>(this); }
3422 };
3423 #endif // VK_USE_PLATFORM_ANDROID_KHR
3424 
3425 #ifdef VK_USE_PLATFORM_WIN32_KHR
3426 struct safe_VkWin32SurfaceCreateInfoKHR {
3427     VkStructureType sType;
3428     const void* pNext;
3429     VkWin32SurfaceCreateFlagsKHR flags;
3430     HINSTANCE hinstance;
3431     HWND hwnd;
3432     safe_VkWin32SurfaceCreateInfoKHR(const VkWin32SurfaceCreateInfoKHR* in_struct);
3433     safe_VkWin32SurfaceCreateInfoKHR(const safe_VkWin32SurfaceCreateInfoKHR& copy_src);
3434     safe_VkWin32SurfaceCreateInfoKHR& operator=(const safe_VkWin32SurfaceCreateInfoKHR& copy_src);
3435     safe_VkWin32SurfaceCreateInfoKHR();
3436     ~safe_VkWin32SurfaceCreateInfoKHR();
3437     void initialize(const VkWin32SurfaceCreateInfoKHR* in_struct);
3438     void initialize(const safe_VkWin32SurfaceCreateInfoKHR* copy_src);
ptrsafe_VkWin32SurfaceCreateInfoKHR3439     VkWin32SurfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkWin32SurfaceCreateInfoKHR *>(this); }
ptrsafe_VkWin32SurfaceCreateInfoKHR3440     VkWin32SurfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkWin32SurfaceCreateInfoKHR const *>(this); }
3441 };
3442 #endif // VK_USE_PLATFORM_WIN32_KHR
3443 
3444 #ifdef VK_USE_PLATFORM_WIN32_KHR
3445 struct safe_VkImportMemoryWin32HandleInfoKHR {
3446     VkStructureType sType;
3447     const void* pNext;
3448     VkExternalMemoryHandleTypeFlagBits handleType;
3449     HANDLE handle;
3450     LPCWSTR name;
3451     safe_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR* in_struct);
3452     safe_VkImportMemoryWin32HandleInfoKHR(const safe_VkImportMemoryWin32HandleInfoKHR& copy_src);
3453     safe_VkImportMemoryWin32HandleInfoKHR& operator=(const safe_VkImportMemoryWin32HandleInfoKHR& copy_src);
3454     safe_VkImportMemoryWin32HandleInfoKHR();
3455     ~safe_VkImportMemoryWin32HandleInfoKHR();
3456     void initialize(const VkImportMemoryWin32HandleInfoKHR* in_struct);
3457     void initialize(const safe_VkImportMemoryWin32HandleInfoKHR* copy_src);
ptrsafe_VkImportMemoryWin32HandleInfoKHR3458     VkImportMemoryWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkImportMemoryWin32HandleInfoKHR *>(this); }
ptrsafe_VkImportMemoryWin32HandleInfoKHR3459     VkImportMemoryWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkImportMemoryWin32HandleInfoKHR const *>(this); }
3460 };
3461 #endif // VK_USE_PLATFORM_WIN32_KHR
3462 
3463 #ifdef VK_USE_PLATFORM_WIN32_KHR
3464 struct safe_VkExportMemoryWin32HandleInfoKHR {
3465     VkStructureType sType;
3466     const void* pNext;
3467     const SECURITY_ATTRIBUTES* pAttributes;
3468     DWORD dwAccess;
3469     LPCWSTR name;
3470     safe_VkExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR* in_struct);
3471     safe_VkExportMemoryWin32HandleInfoKHR(const safe_VkExportMemoryWin32HandleInfoKHR& copy_src);
3472     safe_VkExportMemoryWin32HandleInfoKHR& operator=(const safe_VkExportMemoryWin32HandleInfoKHR& copy_src);
3473     safe_VkExportMemoryWin32HandleInfoKHR();
3474     ~safe_VkExportMemoryWin32HandleInfoKHR();
3475     void initialize(const VkExportMemoryWin32HandleInfoKHR* in_struct);
3476     void initialize(const safe_VkExportMemoryWin32HandleInfoKHR* copy_src);
ptrsafe_VkExportMemoryWin32HandleInfoKHR3477     VkExportMemoryWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkExportMemoryWin32HandleInfoKHR *>(this); }
ptrsafe_VkExportMemoryWin32HandleInfoKHR3478     VkExportMemoryWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkExportMemoryWin32HandleInfoKHR const *>(this); }
3479 };
3480 #endif // VK_USE_PLATFORM_WIN32_KHR
3481 
3482 #ifdef VK_USE_PLATFORM_WIN32_KHR
3483 struct safe_VkMemoryWin32HandlePropertiesKHR {
3484     VkStructureType sType;
3485     void* pNext;
3486     uint32_t memoryTypeBits;
3487     safe_VkMemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR* in_struct);
3488     safe_VkMemoryWin32HandlePropertiesKHR(const safe_VkMemoryWin32HandlePropertiesKHR& copy_src);
3489     safe_VkMemoryWin32HandlePropertiesKHR& operator=(const safe_VkMemoryWin32HandlePropertiesKHR& copy_src);
3490     safe_VkMemoryWin32HandlePropertiesKHR();
3491     ~safe_VkMemoryWin32HandlePropertiesKHR();
3492     void initialize(const VkMemoryWin32HandlePropertiesKHR* in_struct);
3493     void initialize(const safe_VkMemoryWin32HandlePropertiesKHR* copy_src);
ptrsafe_VkMemoryWin32HandlePropertiesKHR3494     VkMemoryWin32HandlePropertiesKHR *ptr() { return reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>(this); }
ptrsafe_VkMemoryWin32HandlePropertiesKHR3495     VkMemoryWin32HandlePropertiesKHR const *ptr() const { return reinterpret_cast<VkMemoryWin32HandlePropertiesKHR const *>(this); }
3496 };
3497 #endif // VK_USE_PLATFORM_WIN32_KHR
3498 
3499 #ifdef VK_USE_PLATFORM_WIN32_KHR
3500 struct safe_VkMemoryGetWin32HandleInfoKHR {
3501     VkStructureType sType;
3502     const void* pNext;
3503     VkDeviceMemory memory;
3504     VkExternalMemoryHandleTypeFlagBits handleType;
3505     safe_VkMemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR* in_struct);
3506     safe_VkMemoryGetWin32HandleInfoKHR(const safe_VkMemoryGetWin32HandleInfoKHR& copy_src);
3507     safe_VkMemoryGetWin32HandleInfoKHR& operator=(const safe_VkMemoryGetWin32HandleInfoKHR& copy_src);
3508     safe_VkMemoryGetWin32HandleInfoKHR();
3509     ~safe_VkMemoryGetWin32HandleInfoKHR();
3510     void initialize(const VkMemoryGetWin32HandleInfoKHR* in_struct);
3511     void initialize(const safe_VkMemoryGetWin32HandleInfoKHR* copy_src);
ptrsafe_VkMemoryGetWin32HandleInfoKHR3512     VkMemoryGetWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkMemoryGetWin32HandleInfoKHR *>(this); }
ptrsafe_VkMemoryGetWin32HandleInfoKHR3513     VkMemoryGetWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkMemoryGetWin32HandleInfoKHR const *>(this); }
3514 };
3515 #endif // VK_USE_PLATFORM_WIN32_KHR
3516 
3517 struct safe_VkImportMemoryFdInfoKHR {
3518     VkStructureType sType;
3519     const void* pNext;
3520     VkExternalMemoryHandleTypeFlagBits handleType;
3521     int fd;
3522     safe_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR* in_struct);
3523     safe_VkImportMemoryFdInfoKHR(const safe_VkImportMemoryFdInfoKHR& copy_src);
3524     safe_VkImportMemoryFdInfoKHR& operator=(const safe_VkImportMemoryFdInfoKHR& copy_src);
3525     safe_VkImportMemoryFdInfoKHR();
3526     ~safe_VkImportMemoryFdInfoKHR();
3527     void initialize(const VkImportMemoryFdInfoKHR* in_struct);
3528     void initialize(const safe_VkImportMemoryFdInfoKHR* copy_src);
ptrsafe_VkImportMemoryFdInfoKHR3529     VkImportMemoryFdInfoKHR *ptr() { return reinterpret_cast<VkImportMemoryFdInfoKHR *>(this); }
ptrsafe_VkImportMemoryFdInfoKHR3530     VkImportMemoryFdInfoKHR const *ptr() const { return reinterpret_cast<VkImportMemoryFdInfoKHR const *>(this); }
3531 };
3532 
3533 struct safe_VkMemoryFdPropertiesKHR {
3534     VkStructureType sType;
3535     void* pNext;
3536     uint32_t memoryTypeBits;
3537     safe_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR* in_struct);
3538     safe_VkMemoryFdPropertiesKHR(const safe_VkMemoryFdPropertiesKHR& copy_src);
3539     safe_VkMemoryFdPropertiesKHR& operator=(const safe_VkMemoryFdPropertiesKHR& copy_src);
3540     safe_VkMemoryFdPropertiesKHR();
3541     ~safe_VkMemoryFdPropertiesKHR();
3542     void initialize(const VkMemoryFdPropertiesKHR* in_struct);
3543     void initialize(const safe_VkMemoryFdPropertiesKHR* copy_src);
ptrsafe_VkMemoryFdPropertiesKHR3544     VkMemoryFdPropertiesKHR *ptr() { return reinterpret_cast<VkMemoryFdPropertiesKHR *>(this); }
ptrsafe_VkMemoryFdPropertiesKHR3545     VkMemoryFdPropertiesKHR const *ptr() const { return reinterpret_cast<VkMemoryFdPropertiesKHR const *>(this); }
3546 };
3547 
3548 struct safe_VkMemoryGetFdInfoKHR {
3549     VkStructureType sType;
3550     const void* pNext;
3551     VkDeviceMemory memory;
3552     VkExternalMemoryHandleTypeFlagBits handleType;
3553     safe_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR* in_struct);
3554     safe_VkMemoryGetFdInfoKHR(const safe_VkMemoryGetFdInfoKHR& copy_src);
3555     safe_VkMemoryGetFdInfoKHR& operator=(const safe_VkMemoryGetFdInfoKHR& copy_src);
3556     safe_VkMemoryGetFdInfoKHR();
3557     ~safe_VkMemoryGetFdInfoKHR();
3558     void initialize(const VkMemoryGetFdInfoKHR* in_struct);
3559     void initialize(const safe_VkMemoryGetFdInfoKHR* copy_src);
ptrsafe_VkMemoryGetFdInfoKHR3560     VkMemoryGetFdInfoKHR *ptr() { return reinterpret_cast<VkMemoryGetFdInfoKHR *>(this); }
ptrsafe_VkMemoryGetFdInfoKHR3561     VkMemoryGetFdInfoKHR const *ptr() const { return reinterpret_cast<VkMemoryGetFdInfoKHR const *>(this); }
3562 };
3563 
3564 #ifdef VK_USE_PLATFORM_WIN32_KHR
3565 struct safe_VkWin32KeyedMutexAcquireReleaseInfoKHR {
3566     VkStructureType sType;
3567     const void* pNext;
3568     uint32_t acquireCount;
3569     VkDeviceMemory* pAcquireSyncs;
3570     const uint64_t* pAcquireKeys;
3571     const uint32_t* pAcquireTimeouts;
3572     uint32_t releaseCount;
3573     VkDeviceMemory* pReleaseSyncs;
3574     const uint64_t* pReleaseKeys;
3575     safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct);
3576     safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src);
3577     safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& operator=(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src);
3578     safe_VkWin32KeyedMutexAcquireReleaseInfoKHR();
3579     ~safe_VkWin32KeyedMutexAcquireReleaseInfoKHR();
3580     void initialize(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct);
3581     void initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR* copy_src);
ptrsafe_VkWin32KeyedMutexAcquireReleaseInfoKHR3582     VkWin32KeyedMutexAcquireReleaseInfoKHR *ptr() { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR *>(this); }
ptrsafe_VkWin32KeyedMutexAcquireReleaseInfoKHR3583     VkWin32KeyedMutexAcquireReleaseInfoKHR const *ptr() const { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR const *>(this); }
3584 };
3585 #endif // VK_USE_PLATFORM_WIN32_KHR
3586 
3587 #ifdef VK_USE_PLATFORM_WIN32_KHR
3588 struct safe_VkImportSemaphoreWin32HandleInfoKHR {
3589     VkStructureType sType;
3590     const void* pNext;
3591     VkSemaphore semaphore;
3592     VkSemaphoreImportFlags flags;
3593     VkExternalSemaphoreHandleTypeFlagBits handleType;
3594     HANDLE handle;
3595     LPCWSTR name;
3596     safe_VkImportSemaphoreWin32HandleInfoKHR(const VkImportSemaphoreWin32HandleInfoKHR* in_struct);
3597     safe_VkImportSemaphoreWin32HandleInfoKHR(const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src);
3598     safe_VkImportSemaphoreWin32HandleInfoKHR& operator=(const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src);
3599     safe_VkImportSemaphoreWin32HandleInfoKHR();
3600     ~safe_VkImportSemaphoreWin32HandleInfoKHR();
3601     void initialize(const VkImportSemaphoreWin32HandleInfoKHR* in_struct);
3602     void initialize(const safe_VkImportSemaphoreWin32HandleInfoKHR* copy_src);
ptrsafe_VkImportSemaphoreWin32HandleInfoKHR3603     VkImportSemaphoreWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR *>(this); }
ptrsafe_VkImportSemaphoreWin32HandleInfoKHR3604     VkImportSemaphoreWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR const *>(this); }
3605 };
3606 #endif // VK_USE_PLATFORM_WIN32_KHR
3607 
3608 #ifdef VK_USE_PLATFORM_WIN32_KHR
3609 struct safe_VkExportSemaphoreWin32HandleInfoKHR {
3610     VkStructureType sType;
3611     const void* pNext;
3612     const SECURITY_ATTRIBUTES* pAttributes;
3613     DWORD dwAccess;
3614     LPCWSTR name;
3615     safe_VkExportSemaphoreWin32HandleInfoKHR(const VkExportSemaphoreWin32HandleInfoKHR* in_struct);
3616     safe_VkExportSemaphoreWin32HandleInfoKHR(const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src);
3617     safe_VkExportSemaphoreWin32HandleInfoKHR& operator=(const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src);
3618     safe_VkExportSemaphoreWin32HandleInfoKHR();
3619     ~safe_VkExportSemaphoreWin32HandleInfoKHR();
3620     void initialize(const VkExportSemaphoreWin32HandleInfoKHR* in_struct);
3621     void initialize(const safe_VkExportSemaphoreWin32HandleInfoKHR* copy_src);
ptrsafe_VkExportSemaphoreWin32HandleInfoKHR3622     VkExportSemaphoreWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR *>(this); }
ptrsafe_VkExportSemaphoreWin32HandleInfoKHR3623     VkExportSemaphoreWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR const *>(this); }
3624 };
3625 #endif // VK_USE_PLATFORM_WIN32_KHR
3626 
3627 #ifdef VK_USE_PLATFORM_WIN32_KHR
3628 struct safe_VkD3D12FenceSubmitInfoKHR {
3629     VkStructureType sType;
3630     const void* pNext;
3631     uint32_t waitSemaphoreValuesCount;
3632     const uint64_t* pWaitSemaphoreValues;
3633     uint32_t signalSemaphoreValuesCount;
3634     const uint64_t* pSignalSemaphoreValues;
3635     safe_VkD3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR* in_struct);
3636     safe_VkD3D12FenceSubmitInfoKHR(const safe_VkD3D12FenceSubmitInfoKHR& copy_src);
3637     safe_VkD3D12FenceSubmitInfoKHR& operator=(const safe_VkD3D12FenceSubmitInfoKHR& copy_src);
3638     safe_VkD3D12FenceSubmitInfoKHR();
3639     ~safe_VkD3D12FenceSubmitInfoKHR();
3640     void initialize(const VkD3D12FenceSubmitInfoKHR* in_struct);
3641     void initialize(const safe_VkD3D12FenceSubmitInfoKHR* copy_src);
ptrsafe_VkD3D12FenceSubmitInfoKHR3642     VkD3D12FenceSubmitInfoKHR *ptr() { return reinterpret_cast<VkD3D12FenceSubmitInfoKHR *>(this); }
ptrsafe_VkD3D12FenceSubmitInfoKHR3643     VkD3D12FenceSubmitInfoKHR const *ptr() const { return reinterpret_cast<VkD3D12FenceSubmitInfoKHR const *>(this); }
3644 };
3645 #endif // VK_USE_PLATFORM_WIN32_KHR
3646 
3647 #ifdef VK_USE_PLATFORM_WIN32_KHR
3648 struct safe_VkSemaphoreGetWin32HandleInfoKHR {
3649     VkStructureType sType;
3650     const void* pNext;
3651     VkSemaphore semaphore;
3652     VkExternalSemaphoreHandleTypeFlagBits handleType;
3653     safe_VkSemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR* in_struct);
3654     safe_VkSemaphoreGetWin32HandleInfoKHR(const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src);
3655     safe_VkSemaphoreGetWin32HandleInfoKHR& operator=(const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src);
3656     safe_VkSemaphoreGetWin32HandleInfoKHR();
3657     ~safe_VkSemaphoreGetWin32HandleInfoKHR();
3658     void initialize(const VkSemaphoreGetWin32HandleInfoKHR* in_struct);
3659     void initialize(const safe_VkSemaphoreGetWin32HandleInfoKHR* copy_src);
ptrsafe_VkSemaphoreGetWin32HandleInfoKHR3660     VkSemaphoreGetWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR *>(this); }
ptrsafe_VkSemaphoreGetWin32HandleInfoKHR3661     VkSemaphoreGetWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR const *>(this); }
3662 };
3663 #endif // VK_USE_PLATFORM_WIN32_KHR
3664 
3665 struct safe_VkImportSemaphoreFdInfoKHR {
3666     VkStructureType sType;
3667     const void* pNext;
3668     VkSemaphore semaphore;
3669     VkSemaphoreImportFlags flags;
3670     VkExternalSemaphoreHandleTypeFlagBits handleType;
3671     int fd;
3672     safe_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR* in_struct);
3673     safe_VkImportSemaphoreFdInfoKHR(const safe_VkImportSemaphoreFdInfoKHR& copy_src);
3674     safe_VkImportSemaphoreFdInfoKHR& operator=(const safe_VkImportSemaphoreFdInfoKHR& copy_src);
3675     safe_VkImportSemaphoreFdInfoKHR();
3676     ~safe_VkImportSemaphoreFdInfoKHR();
3677     void initialize(const VkImportSemaphoreFdInfoKHR* in_struct);
3678     void initialize(const safe_VkImportSemaphoreFdInfoKHR* copy_src);
ptrsafe_VkImportSemaphoreFdInfoKHR3679     VkImportSemaphoreFdInfoKHR *ptr() { return reinterpret_cast<VkImportSemaphoreFdInfoKHR *>(this); }
ptrsafe_VkImportSemaphoreFdInfoKHR3680     VkImportSemaphoreFdInfoKHR const *ptr() const { return reinterpret_cast<VkImportSemaphoreFdInfoKHR const *>(this); }
3681 };
3682 
3683 struct safe_VkSemaphoreGetFdInfoKHR {
3684     VkStructureType sType;
3685     const void* pNext;
3686     VkSemaphore semaphore;
3687     VkExternalSemaphoreHandleTypeFlagBits handleType;
3688     safe_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR* in_struct);
3689     safe_VkSemaphoreGetFdInfoKHR(const safe_VkSemaphoreGetFdInfoKHR& copy_src);
3690     safe_VkSemaphoreGetFdInfoKHR& operator=(const safe_VkSemaphoreGetFdInfoKHR& copy_src);
3691     safe_VkSemaphoreGetFdInfoKHR();
3692     ~safe_VkSemaphoreGetFdInfoKHR();
3693     void initialize(const VkSemaphoreGetFdInfoKHR* in_struct);
3694     void initialize(const safe_VkSemaphoreGetFdInfoKHR* copy_src);
ptrsafe_VkSemaphoreGetFdInfoKHR3695     VkSemaphoreGetFdInfoKHR *ptr() { return reinterpret_cast<VkSemaphoreGetFdInfoKHR *>(this); }
ptrsafe_VkSemaphoreGetFdInfoKHR3696     VkSemaphoreGetFdInfoKHR const *ptr() const { return reinterpret_cast<VkSemaphoreGetFdInfoKHR const *>(this); }
3697 };
3698 
3699 struct safe_VkPhysicalDevicePushDescriptorPropertiesKHR {
3700     VkStructureType sType;
3701     void* pNext;
3702     uint32_t maxPushDescriptors;
3703     safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct);
3704     safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src);
3705     safe_VkPhysicalDevicePushDescriptorPropertiesKHR& operator=(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src);
3706     safe_VkPhysicalDevicePushDescriptorPropertiesKHR();
3707     ~safe_VkPhysicalDevicePushDescriptorPropertiesKHR();
3708     void initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct);
3709     void initialize(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR* copy_src);
ptrsafe_VkPhysicalDevicePushDescriptorPropertiesKHR3710     VkPhysicalDevicePushDescriptorPropertiesKHR *ptr() { return reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR *>(this); }
ptrsafe_VkPhysicalDevicePushDescriptorPropertiesKHR3711     VkPhysicalDevicePushDescriptorPropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR const *>(this); }
3712 };
3713 
3714 struct safe_VkPresentRegionKHR {
3715     uint32_t rectangleCount;
3716     const VkRectLayerKHR* pRectangles;
3717     safe_VkPresentRegionKHR(const VkPresentRegionKHR* in_struct);
3718     safe_VkPresentRegionKHR(const safe_VkPresentRegionKHR& copy_src);
3719     safe_VkPresentRegionKHR& operator=(const safe_VkPresentRegionKHR& copy_src);
3720     safe_VkPresentRegionKHR();
3721     ~safe_VkPresentRegionKHR();
3722     void initialize(const VkPresentRegionKHR* in_struct);
3723     void initialize(const safe_VkPresentRegionKHR* copy_src);
ptrsafe_VkPresentRegionKHR3724     VkPresentRegionKHR *ptr() { return reinterpret_cast<VkPresentRegionKHR *>(this); }
ptrsafe_VkPresentRegionKHR3725     VkPresentRegionKHR const *ptr() const { return reinterpret_cast<VkPresentRegionKHR const *>(this); }
3726 };
3727 
3728 struct safe_VkPresentRegionsKHR {
3729     VkStructureType sType;
3730     const void* pNext;
3731     uint32_t swapchainCount;
3732     safe_VkPresentRegionKHR* pRegions;
3733     safe_VkPresentRegionsKHR(const VkPresentRegionsKHR* in_struct);
3734     safe_VkPresentRegionsKHR(const safe_VkPresentRegionsKHR& copy_src);
3735     safe_VkPresentRegionsKHR& operator=(const safe_VkPresentRegionsKHR& copy_src);
3736     safe_VkPresentRegionsKHR();
3737     ~safe_VkPresentRegionsKHR();
3738     void initialize(const VkPresentRegionsKHR* in_struct);
3739     void initialize(const safe_VkPresentRegionsKHR* copy_src);
ptrsafe_VkPresentRegionsKHR3740     VkPresentRegionsKHR *ptr() { return reinterpret_cast<VkPresentRegionsKHR *>(this); }
ptrsafe_VkPresentRegionsKHR3741     VkPresentRegionsKHR const *ptr() const { return reinterpret_cast<VkPresentRegionsKHR const *>(this); }
3742 };
3743 
3744 struct safe_VkSharedPresentSurfaceCapabilitiesKHR {
3745     VkStructureType sType;
3746     void* pNext;
3747     VkImageUsageFlags sharedPresentSupportedUsageFlags;
3748     safe_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct);
3749     safe_VkSharedPresentSurfaceCapabilitiesKHR(const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src);
3750     safe_VkSharedPresentSurfaceCapabilitiesKHR& operator=(const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src);
3751     safe_VkSharedPresentSurfaceCapabilitiesKHR();
3752     ~safe_VkSharedPresentSurfaceCapabilitiesKHR();
3753     void initialize(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct);
3754     void initialize(const safe_VkSharedPresentSurfaceCapabilitiesKHR* copy_src);
ptrsafe_VkSharedPresentSurfaceCapabilitiesKHR3755     VkSharedPresentSurfaceCapabilitiesKHR *ptr() { return reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR *>(this); }
ptrsafe_VkSharedPresentSurfaceCapabilitiesKHR3756     VkSharedPresentSurfaceCapabilitiesKHR const *ptr() const { return reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR const *>(this); }
3757 };
3758 
3759 #ifdef VK_USE_PLATFORM_WIN32_KHR
3760 struct safe_VkImportFenceWin32HandleInfoKHR {
3761     VkStructureType sType;
3762     const void* pNext;
3763     VkFence fence;
3764     VkFenceImportFlags flags;
3765     VkExternalFenceHandleTypeFlagBits handleType;
3766     HANDLE handle;
3767     LPCWSTR name;
3768     safe_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR* in_struct);
3769     safe_VkImportFenceWin32HandleInfoKHR(const safe_VkImportFenceWin32HandleInfoKHR& copy_src);
3770     safe_VkImportFenceWin32HandleInfoKHR& operator=(const safe_VkImportFenceWin32HandleInfoKHR& copy_src);
3771     safe_VkImportFenceWin32HandleInfoKHR();
3772     ~safe_VkImportFenceWin32HandleInfoKHR();
3773     void initialize(const VkImportFenceWin32HandleInfoKHR* in_struct);
3774     void initialize(const safe_VkImportFenceWin32HandleInfoKHR* copy_src);
ptrsafe_VkImportFenceWin32HandleInfoKHR3775     VkImportFenceWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkImportFenceWin32HandleInfoKHR *>(this); }
ptrsafe_VkImportFenceWin32HandleInfoKHR3776     VkImportFenceWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkImportFenceWin32HandleInfoKHR const *>(this); }
3777 };
3778 #endif // VK_USE_PLATFORM_WIN32_KHR
3779 
3780 #ifdef VK_USE_PLATFORM_WIN32_KHR
3781 struct safe_VkExportFenceWin32HandleInfoKHR {
3782     VkStructureType sType;
3783     const void* pNext;
3784     const SECURITY_ATTRIBUTES* pAttributes;
3785     DWORD dwAccess;
3786     LPCWSTR name;
3787     safe_VkExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR* in_struct);
3788     safe_VkExportFenceWin32HandleInfoKHR(const safe_VkExportFenceWin32HandleInfoKHR& copy_src);
3789     safe_VkExportFenceWin32HandleInfoKHR& operator=(const safe_VkExportFenceWin32HandleInfoKHR& copy_src);
3790     safe_VkExportFenceWin32HandleInfoKHR();
3791     ~safe_VkExportFenceWin32HandleInfoKHR();
3792     void initialize(const VkExportFenceWin32HandleInfoKHR* in_struct);
3793     void initialize(const safe_VkExportFenceWin32HandleInfoKHR* copy_src);
ptrsafe_VkExportFenceWin32HandleInfoKHR3794     VkExportFenceWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkExportFenceWin32HandleInfoKHR *>(this); }
ptrsafe_VkExportFenceWin32HandleInfoKHR3795     VkExportFenceWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkExportFenceWin32HandleInfoKHR const *>(this); }
3796 };
3797 #endif // VK_USE_PLATFORM_WIN32_KHR
3798 
3799 #ifdef VK_USE_PLATFORM_WIN32_KHR
3800 struct safe_VkFenceGetWin32HandleInfoKHR {
3801     VkStructureType sType;
3802     const void* pNext;
3803     VkFence fence;
3804     VkExternalFenceHandleTypeFlagBits handleType;
3805     safe_VkFenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR* in_struct);
3806     safe_VkFenceGetWin32HandleInfoKHR(const safe_VkFenceGetWin32HandleInfoKHR& copy_src);
3807     safe_VkFenceGetWin32HandleInfoKHR& operator=(const safe_VkFenceGetWin32HandleInfoKHR& copy_src);
3808     safe_VkFenceGetWin32HandleInfoKHR();
3809     ~safe_VkFenceGetWin32HandleInfoKHR();
3810     void initialize(const VkFenceGetWin32HandleInfoKHR* in_struct);
3811     void initialize(const safe_VkFenceGetWin32HandleInfoKHR* copy_src);
ptrsafe_VkFenceGetWin32HandleInfoKHR3812     VkFenceGetWin32HandleInfoKHR *ptr() { return reinterpret_cast<VkFenceGetWin32HandleInfoKHR *>(this); }
ptrsafe_VkFenceGetWin32HandleInfoKHR3813     VkFenceGetWin32HandleInfoKHR const *ptr() const { return reinterpret_cast<VkFenceGetWin32HandleInfoKHR const *>(this); }
3814 };
3815 #endif // VK_USE_PLATFORM_WIN32_KHR
3816 
3817 struct safe_VkImportFenceFdInfoKHR {
3818     VkStructureType sType;
3819     const void* pNext;
3820     VkFence fence;
3821     VkFenceImportFlags flags;
3822     VkExternalFenceHandleTypeFlagBits handleType;
3823     int fd;
3824     safe_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR* in_struct);
3825     safe_VkImportFenceFdInfoKHR(const safe_VkImportFenceFdInfoKHR& copy_src);
3826     safe_VkImportFenceFdInfoKHR& operator=(const safe_VkImportFenceFdInfoKHR& copy_src);
3827     safe_VkImportFenceFdInfoKHR();
3828     ~safe_VkImportFenceFdInfoKHR();
3829     void initialize(const VkImportFenceFdInfoKHR* in_struct);
3830     void initialize(const safe_VkImportFenceFdInfoKHR* copy_src);
ptrsafe_VkImportFenceFdInfoKHR3831     VkImportFenceFdInfoKHR *ptr() { return reinterpret_cast<VkImportFenceFdInfoKHR *>(this); }
ptrsafe_VkImportFenceFdInfoKHR3832     VkImportFenceFdInfoKHR const *ptr() const { return reinterpret_cast<VkImportFenceFdInfoKHR const *>(this); }
3833 };
3834 
3835 struct safe_VkFenceGetFdInfoKHR {
3836     VkStructureType sType;
3837     const void* pNext;
3838     VkFence fence;
3839     VkExternalFenceHandleTypeFlagBits handleType;
3840     safe_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR* in_struct);
3841     safe_VkFenceGetFdInfoKHR(const safe_VkFenceGetFdInfoKHR& copy_src);
3842     safe_VkFenceGetFdInfoKHR& operator=(const safe_VkFenceGetFdInfoKHR& copy_src);
3843     safe_VkFenceGetFdInfoKHR();
3844     ~safe_VkFenceGetFdInfoKHR();
3845     void initialize(const VkFenceGetFdInfoKHR* in_struct);
3846     void initialize(const safe_VkFenceGetFdInfoKHR* copy_src);
ptrsafe_VkFenceGetFdInfoKHR3847     VkFenceGetFdInfoKHR *ptr() { return reinterpret_cast<VkFenceGetFdInfoKHR *>(this); }
ptrsafe_VkFenceGetFdInfoKHR3848     VkFenceGetFdInfoKHR const *ptr() const { return reinterpret_cast<VkFenceGetFdInfoKHR const *>(this); }
3849 };
3850 
3851 struct safe_VkPhysicalDevicePerformanceQueryFeaturesKHR {
3852     VkStructureType sType;
3853     void* pNext;
3854     VkBool32 performanceCounterQueryPools;
3855     VkBool32 performanceCounterMultipleQueryPools;
3856     safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct);
3857     safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src);
3858     safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& operator=(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src);
3859     safe_VkPhysicalDevicePerformanceQueryFeaturesKHR();
3860     ~safe_VkPhysicalDevicePerformanceQueryFeaturesKHR();
3861     void initialize(const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct);
3862     void initialize(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR* copy_src);
ptrsafe_VkPhysicalDevicePerformanceQueryFeaturesKHR3863     VkPhysicalDevicePerformanceQueryFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR *>(this); }
ptrsafe_VkPhysicalDevicePerformanceQueryFeaturesKHR3864     VkPhysicalDevicePerformanceQueryFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR const *>(this); }
3865 };
3866 
3867 struct safe_VkPhysicalDevicePerformanceQueryPropertiesKHR {
3868     VkStructureType sType;
3869     void* pNext;
3870     VkBool32 allowCommandBufferQueryCopies;
3871     safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct);
3872     safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src);
3873     safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& operator=(const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src);
3874     safe_VkPhysicalDevicePerformanceQueryPropertiesKHR();
3875     ~safe_VkPhysicalDevicePerformanceQueryPropertiesKHR();
3876     void initialize(const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct);
3877     void initialize(const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR* copy_src);
ptrsafe_VkPhysicalDevicePerformanceQueryPropertiesKHR3878     VkPhysicalDevicePerformanceQueryPropertiesKHR *ptr() { return reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR *>(this); }
ptrsafe_VkPhysicalDevicePerformanceQueryPropertiesKHR3879     VkPhysicalDevicePerformanceQueryPropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR const *>(this); }
3880 };
3881 
3882 struct safe_VkPerformanceCounterKHR {
3883     VkStructureType sType;
3884     const void* pNext;
3885     VkPerformanceCounterUnitKHR unit;
3886     VkPerformanceCounterScopeKHR scope;
3887     VkPerformanceCounterStorageKHR storage;
3888     uint8_t uuid[VK_UUID_SIZE];
3889     safe_VkPerformanceCounterKHR(const VkPerformanceCounterKHR* in_struct);
3890     safe_VkPerformanceCounterKHR(const safe_VkPerformanceCounterKHR& copy_src);
3891     safe_VkPerformanceCounterKHR& operator=(const safe_VkPerformanceCounterKHR& copy_src);
3892     safe_VkPerformanceCounterKHR();
3893     ~safe_VkPerformanceCounterKHR();
3894     void initialize(const VkPerformanceCounterKHR* in_struct);
3895     void initialize(const safe_VkPerformanceCounterKHR* copy_src);
ptrsafe_VkPerformanceCounterKHR3896     VkPerformanceCounterKHR *ptr() { return reinterpret_cast<VkPerformanceCounterKHR *>(this); }
ptrsafe_VkPerformanceCounterKHR3897     VkPerformanceCounterKHR const *ptr() const { return reinterpret_cast<VkPerformanceCounterKHR const *>(this); }
3898 };
3899 
3900 struct safe_VkPerformanceCounterDescriptionKHR {
3901     VkStructureType sType;
3902     const void* pNext;
3903     VkPerformanceCounterDescriptionFlagsKHR flags;
3904     char name[VK_MAX_DESCRIPTION_SIZE];
3905     char category[VK_MAX_DESCRIPTION_SIZE];
3906     char description[VK_MAX_DESCRIPTION_SIZE];
3907     safe_VkPerformanceCounterDescriptionKHR(const VkPerformanceCounterDescriptionKHR* in_struct);
3908     safe_VkPerformanceCounterDescriptionKHR(const safe_VkPerformanceCounterDescriptionKHR& copy_src);
3909     safe_VkPerformanceCounterDescriptionKHR& operator=(const safe_VkPerformanceCounterDescriptionKHR& copy_src);
3910     safe_VkPerformanceCounterDescriptionKHR();
3911     ~safe_VkPerformanceCounterDescriptionKHR();
3912     void initialize(const VkPerformanceCounterDescriptionKHR* in_struct);
3913     void initialize(const safe_VkPerformanceCounterDescriptionKHR* copy_src);
ptrsafe_VkPerformanceCounterDescriptionKHR3914     VkPerformanceCounterDescriptionKHR *ptr() { return reinterpret_cast<VkPerformanceCounterDescriptionKHR *>(this); }
ptrsafe_VkPerformanceCounterDescriptionKHR3915     VkPerformanceCounterDescriptionKHR const *ptr() const { return reinterpret_cast<VkPerformanceCounterDescriptionKHR const *>(this); }
3916 };
3917 
3918 struct safe_VkQueryPoolPerformanceCreateInfoKHR {
3919     VkStructureType sType;
3920     const void* pNext;
3921     uint32_t queueFamilyIndex;
3922     uint32_t counterIndexCount;
3923     const uint32_t* pCounterIndices;
3924     safe_VkQueryPoolPerformanceCreateInfoKHR(const VkQueryPoolPerformanceCreateInfoKHR* in_struct);
3925     safe_VkQueryPoolPerformanceCreateInfoKHR(const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src);
3926     safe_VkQueryPoolPerformanceCreateInfoKHR& operator=(const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src);
3927     safe_VkQueryPoolPerformanceCreateInfoKHR();
3928     ~safe_VkQueryPoolPerformanceCreateInfoKHR();
3929     void initialize(const VkQueryPoolPerformanceCreateInfoKHR* in_struct);
3930     void initialize(const safe_VkQueryPoolPerformanceCreateInfoKHR* copy_src);
ptrsafe_VkQueryPoolPerformanceCreateInfoKHR3931     VkQueryPoolPerformanceCreateInfoKHR *ptr() { return reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR *>(this); }
ptrsafe_VkQueryPoolPerformanceCreateInfoKHR3932     VkQueryPoolPerformanceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR const *>(this); }
3933 };
3934 
3935 struct safe_VkAcquireProfilingLockInfoKHR {
3936     VkStructureType sType;
3937     const void* pNext;
3938     VkAcquireProfilingLockFlagsKHR flags;
3939     uint64_t timeout;
3940     safe_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR* in_struct);
3941     safe_VkAcquireProfilingLockInfoKHR(const safe_VkAcquireProfilingLockInfoKHR& copy_src);
3942     safe_VkAcquireProfilingLockInfoKHR& operator=(const safe_VkAcquireProfilingLockInfoKHR& copy_src);
3943     safe_VkAcquireProfilingLockInfoKHR();
3944     ~safe_VkAcquireProfilingLockInfoKHR();
3945     void initialize(const VkAcquireProfilingLockInfoKHR* in_struct);
3946     void initialize(const safe_VkAcquireProfilingLockInfoKHR* copy_src);
ptrsafe_VkAcquireProfilingLockInfoKHR3947     VkAcquireProfilingLockInfoKHR *ptr() { return reinterpret_cast<VkAcquireProfilingLockInfoKHR *>(this); }
ptrsafe_VkAcquireProfilingLockInfoKHR3948     VkAcquireProfilingLockInfoKHR const *ptr() const { return reinterpret_cast<VkAcquireProfilingLockInfoKHR const *>(this); }
3949 };
3950 
3951 struct safe_VkPerformanceQuerySubmitInfoKHR {
3952     VkStructureType sType;
3953     const void* pNext;
3954     uint32_t counterPassIndex;
3955     safe_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR* in_struct);
3956     safe_VkPerformanceQuerySubmitInfoKHR(const safe_VkPerformanceQuerySubmitInfoKHR& copy_src);
3957     safe_VkPerformanceQuerySubmitInfoKHR& operator=(const safe_VkPerformanceQuerySubmitInfoKHR& copy_src);
3958     safe_VkPerformanceQuerySubmitInfoKHR();
3959     ~safe_VkPerformanceQuerySubmitInfoKHR();
3960     void initialize(const VkPerformanceQuerySubmitInfoKHR* in_struct);
3961     void initialize(const safe_VkPerformanceQuerySubmitInfoKHR* copy_src);
ptrsafe_VkPerformanceQuerySubmitInfoKHR3962     VkPerformanceQuerySubmitInfoKHR *ptr() { return reinterpret_cast<VkPerformanceQuerySubmitInfoKHR *>(this); }
ptrsafe_VkPerformanceQuerySubmitInfoKHR3963     VkPerformanceQuerySubmitInfoKHR const *ptr() const { return reinterpret_cast<VkPerformanceQuerySubmitInfoKHR const *>(this); }
3964 };
3965 
3966 struct safe_VkPhysicalDeviceSurfaceInfo2KHR {
3967     VkStructureType sType;
3968     const void* pNext;
3969     VkSurfaceKHR surface;
3970     safe_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct);
3971     safe_VkPhysicalDeviceSurfaceInfo2KHR(const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src);
3972     safe_VkPhysicalDeviceSurfaceInfo2KHR& operator=(const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src);
3973     safe_VkPhysicalDeviceSurfaceInfo2KHR();
3974     ~safe_VkPhysicalDeviceSurfaceInfo2KHR();
3975     void initialize(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct);
3976     void initialize(const safe_VkPhysicalDeviceSurfaceInfo2KHR* copy_src);
ptrsafe_VkPhysicalDeviceSurfaceInfo2KHR3977     VkPhysicalDeviceSurfaceInfo2KHR *ptr() { return reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR *>(this); }
ptrsafe_VkPhysicalDeviceSurfaceInfo2KHR3978     VkPhysicalDeviceSurfaceInfo2KHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR const *>(this); }
3979 };
3980 
3981 struct safe_VkSurfaceCapabilities2KHR {
3982     VkStructureType sType;
3983     void* pNext;
3984     VkSurfaceCapabilitiesKHR surfaceCapabilities;
3985     safe_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR* in_struct);
3986     safe_VkSurfaceCapabilities2KHR(const safe_VkSurfaceCapabilities2KHR& copy_src);
3987     safe_VkSurfaceCapabilities2KHR& operator=(const safe_VkSurfaceCapabilities2KHR& copy_src);
3988     safe_VkSurfaceCapabilities2KHR();
3989     ~safe_VkSurfaceCapabilities2KHR();
3990     void initialize(const VkSurfaceCapabilities2KHR* in_struct);
3991     void initialize(const safe_VkSurfaceCapabilities2KHR* copy_src);
ptrsafe_VkSurfaceCapabilities2KHR3992     VkSurfaceCapabilities2KHR *ptr() { return reinterpret_cast<VkSurfaceCapabilities2KHR *>(this); }
ptrsafe_VkSurfaceCapabilities2KHR3993     VkSurfaceCapabilities2KHR const *ptr() const { return reinterpret_cast<VkSurfaceCapabilities2KHR const *>(this); }
3994 };
3995 
3996 struct safe_VkSurfaceFormat2KHR {
3997     VkStructureType sType;
3998     void* pNext;
3999     VkSurfaceFormatKHR surfaceFormat;
4000     safe_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR* in_struct);
4001     safe_VkSurfaceFormat2KHR(const safe_VkSurfaceFormat2KHR& copy_src);
4002     safe_VkSurfaceFormat2KHR& operator=(const safe_VkSurfaceFormat2KHR& copy_src);
4003     safe_VkSurfaceFormat2KHR();
4004     ~safe_VkSurfaceFormat2KHR();
4005     void initialize(const VkSurfaceFormat2KHR* in_struct);
4006     void initialize(const safe_VkSurfaceFormat2KHR* copy_src);
ptrsafe_VkSurfaceFormat2KHR4007     VkSurfaceFormat2KHR *ptr() { return reinterpret_cast<VkSurfaceFormat2KHR *>(this); }
ptrsafe_VkSurfaceFormat2KHR4008     VkSurfaceFormat2KHR const *ptr() const { return reinterpret_cast<VkSurfaceFormat2KHR const *>(this); }
4009 };
4010 
4011 struct safe_VkDisplayProperties2KHR {
4012     VkStructureType sType;
4013     void* pNext;
4014     safe_VkDisplayPropertiesKHR displayProperties;
4015     safe_VkDisplayProperties2KHR(const VkDisplayProperties2KHR* in_struct);
4016     safe_VkDisplayProperties2KHR(const safe_VkDisplayProperties2KHR& copy_src);
4017     safe_VkDisplayProperties2KHR& operator=(const safe_VkDisplayProperties2KHR& copy_src);
4018     safe_VkDisplayProperties2KHR();
4019     ~safe_VkDisplayProperties2KHR();
4020     void initialize(const VkDisplayProperties2KHR* in_struct);
4021     void initialize(const safe_VkDisplayProperties2KHR* copy_src);
ptrsafe_VkDisplayProperties2KHR4022     VkDisplayProperties2KHR *ptr() { return reinterpret_cast<VkDisplayProperties2KHR *>(this); }
ptrsafe_VkDisplayProperties2KHR4023     VkDisplayProperties2KHR const *ptr() const { return reinterpret_cast<VkDisplayProperties2KHR const *>(this); }
4024 };
4025 
4026 struct safe_VkDisplayPlaneProperties2KHR {
4027     VkStructureType sType;
4028     void* pNext;
4029     VkDisplayPlanePropertiesKHR displayPlaneProperties;
4030     safe_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR* in_struct);
4031     safe_VkDisplayPlaneProperties2KHR(const safe_VkDisplayPlaneProperties2KHR& copy_src);
4032     safe_VkDisplayPlaneProperties2KHR& operator=(const safe_VkDisplayPlaneProperties2KHR& copy_src);
4033     safe_VkDisplayPlaneProperties2KHR();
4034     ~safe_VkDisplayPlaneProperties2KHR();
4035     void initialize(const VkDisplayPlaneProperties2KHR* in_struct);
4036     void initialize(const safe_VkDisplayPlaneProperties2KHR* copy_src);
ptrsafe_VkDisplayPlaneProperties2KHR4037     VkDisplayPlaneProperties2KHR *ptr() { return reinterpret_cast<VkDisplayPlaneProperties2KHR *>(this); }
ptrsafe_VkDisplayPlaneProperties2KHR4038     VkDisplayPlaneProperties2KHR const *ptr() const { return reinterpret_cast<VkDisplayPlaneProperties2KHR const *>(this); }
4039 };
4040 
4041 struct safe_VkDisplayModeProperties2KHR {
4042     VkStructureType sType;
4043     void* pNext;
4044     VkDisplayModePropertiesKHR displayModeProperties;
4045     safe_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR* in_struct);
4046     safe_VkDisplayModeProperties2KHR(const safe_VkDisplayModeProperties2KHR& copy_src);
4047     safe_VkDisplayModeProperties2KHR& operator=(const safe_VkDisplayModeProperties2KHR& copy_src);
4048     safe_VkDisplayModeProperties2KHR();
4049     ~safe_VkDisplayModeProperties2KHR();
4050     void initialize(const VkDisplayModeProperties2KHR* in_struct);
4051     void initialize(const safe_VkDisplayModeProperties2KHR* copy_src);
ptrsafe_VkDisplayModeProperties2KHR4052     VkDisplayModeProperties2KHR *ptr() { return reinterpret_cast<VkDisplayModeProperties2KHR *>(this); }
ptrsafe_VkDisplayModeProperties2KHR4053     VkDisplayModeProperties2KHR const *ptr() const { return reinterpret_cast<VkDisplayModeProperties2KHR const *>(this); }
4054 };
4055 
4056 struct safe_VkDisplayPlaneInfo2KHR {
4057     VkStructureType sType;
4058     const void* pNext;
4059     VkDisplayModeKHR mode;
4060     uint32_t planeIndex;
4061     safe_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR* in_struct);
4062     safe_VkDisplayPlaneInfo2KHR(const safe_VkDisplayPlaneInfo2KHR& copy_src);
4063     safe_VkDisplayPlaneInfo2KHR& operator=(const safe_VkDisplayPlaneInfo2KHR& copy_src);
4064     safe_VkDisplayPlaneInfo2KHR();
4065     ~safe_VkDisplayPlaneInfo2KHR();
4066     void initialize(const VkDisplayPlaneInfo2KHR* in_struct);
4067     void initialize(const safe_VkDisplayPlaneInfo2KHR* copy_src);
ptrsafe_VkDisplayPlaneInfo2KHR4068     VkDisplayPlaneInfo2KHR *ptr() { return reinterpret_cast<VkDisplayPlaneInfo2KHR *>(this); }
ptrsafe_VkDisplayPlaneInfo2KHR4069     VkDisplayPlaneInfo2KHR const *ptr() const { return reinterpret_cast<VkDisplayPlaneInfo2KHR const *>(this); }
4070 };
4071 
4072 struct safe_VkDisplayPlaneCapabilities2KHR {
4073     VkStructureType sType;
4074     void* pNext;
4075     VkDisplayPlaneCapabilitiesKHR capabilities;
4076     safe_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR* in_struct);
4077     safe_VkDisplayPlaneCapabilities2KHR(const safe_VkDisplayPlaneCapabilities2KHR& copy_src);
4078     safe_VkDisplayPlaneCapabilities2KHR& operator=(const safe_VkDisplayPlaneCapabilities2KHR& copy_src);
4079     safe_VkDisplayPlaneCapabilities2KHR();
4080     ~safe_VkDisplayPlaneCapabilities2KHR();
4081     void initialize(const VkDisplayPlaneCapabilities2KHR* in_struct);
4082     void initialize(const safe_VkDisplayPlaneCapabilities2KHR* copy_src);
ptrsafe_VkDisplayPlaneCapabilities2KHR4083     VkDisplayPlaneCapabilities2KHR *ptr() { return reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>(this); }
ptrsafe_VkDisplayPlaneCapabilities2KHR4084     VkDisplayPlaneCapabilities2KHR const *ptr() const { return reinterpret_cast<VkDisplayPlaneCapabilities2KHR const *>(this); }
4085 };
4086 
4087 #ifdef VK_ENABLE_BETA_EXTENSIONS
4088 struct safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR {
4089     VkStructureType sType;
4090     void* pNext;
4091     VkBool32 constantAlphaColorBlendFactors;
4092     VkBool32 events;
4093     VkBool32 imageViewFormatReinterpretation;
4094     VkBool32 imageViewFormatSwizzle;
4095     VkBool32 imageView2DOn3DImage;
4096     VkBool32 multisampleArrayImage;
4097     VkBool32 mutableComparisonSamplers;
4098     VkBool32 pointPolygons;
4099     VkBool32 samplerMipLodBias;
4100     VkBool32 separateStencilMaskRef;
4101     VkBool32 shaderSampleRateInterpolationFunctions;
4102     VkBool32 tessellationIsolines;
4103     VkBool32 tessellationPointMode;
4104     VkBool32 triangleFans;
4105     VkBool32 vertexAttributeAccessBeyondStride;
4106     safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct);
4107     safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src);
4108     safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& operator=(const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src);
4109     safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR();
4110     ~safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR();
4111     void initialize(const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct);
4112     void initialize(const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR* copy_src);
ptrsafe_VkPhysicalDevicePortabilitySubsetFeaturesKHR4113     VkPhysicalDevicePortabilitySubsetFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(this); }
ptrsafe_VkPhysicalDevicePortabilitySubsetFeaturesKHR4114     VkPhysicalDevicePortabilitySubsetFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR const *>(this); }
4115 };
4116 #endif // VK_ENABLE_BETA_EXTENSIONS
4117 
4118 #ifdef VK_ENABLE_BETA_EXTENSIONS
4119 struct safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR {
4120     VkStructureType sType;
4121     void* pNext;
4122     uint32_t minVertexInputBindingStrideAlignment;
4123     safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct);
4124     safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src);
4125     safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& operator=(const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src);
4126     safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR();
4127     ~safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR();
4128     void initialize(const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct);
4129     void initialize(const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR* copy_src);
ptrsafe_VkPhysicalDevicePortabilitySubsetPropertiesKHR4130     VkPhysicalDevicePortabilitySubsetPropertiesKHR *ptr() { return reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR *>(this); }
ptrsafe_VkPhysicalDevicePortabilitySubsetPropertiesKHR4131     VkPhysicalDevicePortabilitySubsetPropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR const *>(this); }
4132 };
4133 #endif // VK_ENABLE_BETA_EXTENSIONS
4134 
4135 struct safe_VkPhysicalDeviceShaderClockFeaturesKHR {
4136     VkStructureType sType;
4137     void* pNext;
4138     VkBool32 shaderSubgroupClock;
4139     VkBool32 shaderDeviceClock;
4140     safe_VkPhysicalDeviceShaderClockFeaturesKHR(const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct);
4141     safe_VkPhysicalDeviceShaderClockFeaturesKHR(const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src);
4142     safe_VkPhysicalDeviceShaderClockFeaturesKHR& operator=(const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src);
4143     safe_VkPhysicalDeviceShaderClockFeaturesKHR();
4144     ~safe_VkPhysicalDeviceShaderClockFeaturesKHR();
4145     void initialize(const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct);
4146     void initialize(const safe_VkPhysicalDeviceShaderClockFeaturesKHR* copy_src);
ptrsafe_VkPhysicalDeviceShaderClockFeaturesKHR4147     VkPhysicalDeviceShaderClockFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR *>(this); }
ptrsafe_VkPhysicalDeviceShaderClockFeaturesKHR4148     VkPhysicalDeviceShaderClockFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR const *>(this); }
4149 };
4150 
4151 struct safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR {
4152     VkStructureType sType;
4153     void* pNext;
4154     VkBool32 shaderTerminateInvocation;
4155     safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* in_struct);
4156     safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(const safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR& copy_src);
4157     safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR& operator=(const safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR& copy_src);
4158     safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR();
4159     ~safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR();
4160     void initialize(const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* in_struct);
4161     void initialize(const safe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* copy_src);
ptrsafe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR4162     VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *>(this); }
ptrsafe_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR4163     VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR const *>(this); }
4164 };
4165 
4166 struct safe_VkFragmentShadingRateAttachmentInfoKHR {
4167     VkStructureType sType;
4168     const void* pNext;
4169     safe_VkAttachmentReference2* pFragmentShadingRateAttachment;
4170     VkExtent2D shadingRateAttachmentTexelSize;
4171     safe_VkFragmentShadingRateAttachmentInfoKHR(const VkFragmentShadingRateAttachmentInfoKHR* in_struct);
4172     safe_VkFragmentShadingRateAttachmentInfoKHR(const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src);
4173     safe_VkFragmentShadingRateAttachmentInfoKHR& operator=(const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src);
4174     safe_VkFragmentShadingRateAttachmentInfoKHR();
4175     ~safe_VkFragmentShadingRateAttachmentInfoKHR();
4176     void initialize(const VkFragmentShadingRateAttachmentInfoKHR* in_struct);
4177     void initialize(const safe_VkFragmentShadingRateAttachmentInfoKHR* copy_src);
ptrsafe_VkFragmentShadingRateAttachmentInfoKHR4178     VkFragmentShadingRateAttachmentInfoKHR *ptr() { return reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR *>(this); }
ptrsafe_VkFragmentShadingRateAttachmentInfoKHR4179     VkFragmentShadingRateAttachmentInfoKHR const *ptr() const { return reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR const *>(this); }
4180 };
4181 
4182 struct safe_VkPipelineFragmentShadingRateStateCreateInfoKHR {
4183     VkStructureType sType;
4184     const void* pNext;
4185     VkExtent2D fragmentSize;
4186     VkFragmentShadingRateCombinerOpKHR combinerOps[2];
4187     safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct);
4188     safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src);
4189     safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& operator=(const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src);
4190     safe_VkPipelineFragmentShadingRateStateCreateInfoKHR();
4191     ~safe_VkPipelineFragmentShadingRateStateCreateInfoKHR();
4192     void initialize(const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct);
4193     void initialize(const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR* copy_src);
ptrsafe_VkPipelineFragmentShadingRateStateCreateInfoKHR4194     VkPipelineFragmentShadingRateStateCreateInfoKHR *ptr() { return reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR *>(this); }
ptrsafe_VkPipelineFragmentShadingRateStateCreateInfoKHR4195     VkPipelineFragmentShadingRateStateCreateInfoKHR const *ptr() const { return reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR const *>(this); }
4196 };
4197 
4198 struct safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR {
4199     VkStructureType sType;
4200     void* pNext;
4201     VkBool32 pipelineFragmentShadingRate;
4202     VkBool32 primitiveFragmentShadingRate;
4203     VkBool32 attachmentFragmentShadingRate;
4204     safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct);
4205     safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src);
4206     safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& operator=(const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src);
4207     safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR();
4208     ~safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR();
4209     void initialize(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct);
4210     void initialize(const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR* copy_src);
ptrsafe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR4211     VkPhysicalDeviceFragmentShadingRateFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>(this); }
ptrsafe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR4212     VkPhysicalDeviceFragmentShadingRateFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR const *>(this); }
4213 };
4214 
4215 struct safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR {
4216     VkStructureType sType;
4217     void* pNext;
4218     VkExtent2D minFragmentShadingRateAttachmentTexelSize;
4219     VkExtent2D maxFragmentShadingRateAttachmentTexelSize;
4220     uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
4221     VkBool32 primitiveFragmentShadingRateWithMultipleViewports;
4222     VkBool32 layeredShadingRateAttachments;
4223     VkBool32 fragmentShadingRateNonTrivialCombinerOps;
4224     VkExtent2D maxFragmentSize;
4225     uint32_t maxFragmentSizeAspectRatio;
4226     uint32_t maxFragmentShadingRateCoverageSamples;
4227     VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples;
4228     VkBool32 fragmentShadingRateWithShaderDepthStencilWrites;
4229     VkBool32 fragmentShadingRateWithSampleMask;
4230     VkBool32 fragmentShadingRateWithShaderSampleMask;
4231     VkBool32 fragmentShadingRateWithConservativeRasterization;
4232     VkBool32 fragmentShadingRateWithFragmentShaderInterlock;
4233     VkBool32 fragmentShadingRateWithCustomSampleLocations;
4234     VkBool32 fragmentShadingRateStrictMultiplyCombiner;
4235     safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct);
4236     safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src);
4237     safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& operator=(const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src);
4238     safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR();
4239     ~safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR();
4240     void initialize(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct);
4241     void initialize(const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR* copy_src);
ptrsafe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR4242     VkPhysicalDeviceFragmentShadingRatePropertiesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR *>(this); }
ptrsafe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR4243     VkPhysicalDeviceFragmentShadingRatePropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR const *>(this); }
4244 };
4245 
4246 struct safe_VkPhysicalDeviceFragmentShadingRateKHR {
4247     VkStructureType sType;
4248     void* pNext;
4249     VkSampleCountFlags sampleCounts;
4250     VkExtent2D fragmentSize;
4251     safe_VkPhysicalDeviceFragmentShadingRateKHR(const VkPhysicalDeviceFragmentShadingRateKHR* in_struct);
4252     safe_VkPhysicalDeviceFragmentShadingRateKHR(const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src);
4253     safe_VkPhysicalDeviceFragmentShadingRateKHR& operator=(const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src);
4254     safe_VkPhysicalDeviceFragmentShadingRateKHR();
4255     ~safe_VkPhysicalDeviceFragmentShadingRateKHR();
4256     void initialize(const VkPhysicalDeviceFragmentShadingRateKHR* in_struct);
4257     void initialize(const safe_VkPhysicalDeviceFragmentShadingRateKHR* copy_src);
ptrsafe_VkPhysicalDeviceFragmentShadingRateKHR4258     VkPhysicalDeviceFragmentShadingRateKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>(this); }
ptrsafe_VkPhysicalDeviceFragmentShadingRateKHR4259     VkPhysicalDeviceFragmentShadingRateKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR const *>(this); }
4260 };
4261 
4262 struct safe_VkSurfaceProtectedCapabilitiesKHR {
4263     VkStructureType sType;
4264     const void* pNext;
4265     VkBool32 supportsProtected;
4266     safe_VkSurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR* in_struct);
4267     safe_VkSurfaceProtectedCapabilitiesKHR(const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src);
4268     safe_VkSurfaceProtectedCapabilitiesKHR& operator=(const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src);
4269     safe_VkSurfaceProtectedCapabilitiesKHR();
4270     ~safe_VkSurfaceProtectedCapabilitiesKHR();
4271     void initialize(const VkSurfaceProtectedCapabilitiesKHR* in_struct);
4272     void initialize(const safe_VkSurfaceProtectedCapabilitiesKHR* copy_src);
ptrsafe_VkSurfaceProtectedCapabilitiesKHR4273     VkSurfaceProtectedCapabilitiesKHR *ptr() { return reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR *>(this); }
ptrsafe_VkSurfaceProtectedCapabilitiesKHR4274     VkSurfaceProtectedCapabilitiesKHR const *ptr() const { return reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR const *>(this); }
4275 };
4276 
4277 #ifdef VK_ENABLE_BETA_EXTENSIONS
4278 struct safe_VkDeferredOperationInfoKHR {
4279     VkStructureType sType;
4280     const void* pNext;
4281     VkDeferredOperationKHR operationHandle;
4282     safe_VkDeferredOperationInfoKHR(const VkDeferredOperationInfoKHR* in_struct);
4283     safe_VkDeferredOperationInfoKHR(const safe_VkDeferredOperationInfoKHR& copy_src);
4284     safe_VkDeferredOperationInfoKHR& operator=(const safe_VkDeferredOperationInfoKHR& copy_src);
4285     safe_VkDeferredOperationInfoKHR();
4286     ~safe_VkDeferredOperationInfoKHR();
4287     void initialize(const VkDeferredOperationInfoKHR* in_struct);
4288     void initialize(const safe_VkDeferredOperationInfoKHR* copy_src);
ptrsafe_VkDeferredOperationInfoKHR4289     VkDeferredOperationInfoKHR *ptr() { return reinterpret_cast<VkDeferredOperationInfoKHR *>(this); }
ptrsafe_VkDeferredOperationInfoKHR4290     VkDeferredOperationInfoKHR const *ptr() const { return reinterpret_cast<VkDeferredOperationInfoKHR const *>(this); }
4291 };
4292 #endif // VK_ENABLE_BETA_EXTENSIONS
4293 
4294 struct safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
4295     VkStructureType sType;
4296     void* pNext;
4297     VkBool32 pipelineExecutableInfo;
4298     safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct);
4299     safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src);
4300     safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src);
4301     safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR();
4302     ~safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR();
4303     void initialize(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct);
4304     void initialize(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* copy_src);
ptrsafe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR4305     VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>(this); }
ptrsafe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR4306     VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const *>(this); }
4307 };
4308 
4309 struct safe_VkPipelineInfoKHR {
4310     VkStructureType sType;
4311     const void* pNext;
4312     VkPipeline pipeline;
4313     safe_VkPipelineInfoKHR(const VkPipelineInfoKHR* in_struct);
4314     safe_VkPipelineInfoKHR(const safe_VkPipelineInfoKHR& copy_src);
4315     safe_VkPipelineInfoKHR& operator=(const safe_VkPipelineInfoKHR& copy_src);
4316     safe_VkPipelineInfoKHR();
4317     ~safe_VkPipelineInfoKHR();
4318     void initialize(const VkPipelineInfoKHR* in_struct);
4319     void initialize(const safe_VkPipelineInfoKHR* copy_src);
ptrsafe_VkPipelineInfoKHR4320     VkPipelineInfoKHR *ptr() { return reinterpret_cast<VkPipelineInfoKHR *>(this); }
ptrsafe_VkPipelineInfoKHR4321     VkPipelineInfoKHR const *ptr() const { return reinterpret_cast<VkPipelineInfoKHR const *>(this); }
4322 };
4323 
4324 struct safe_VkPipelineExecutablePropertiesKHR {
4325     VkStructureType sType;
4326     void* pNext;
4327     VkShaderStageFlags stages;
4328     char name[VK_MAX_DESCRIPTION_SIZE];
4329     char description[VK_MAX_DESCRIPTION_SIZE];
4330     uint32_t subgroupSize;
4331     safe_VkPipelineExecutablePropertiesKHR(const VkPipelineExecutablePropertiesKHR* in_struct);
4332     safe_VkPipelineExecutablePropertiesKHR(const safe_VkPipelineExecutablePropertiesKHR& copy_src);
4333     safe_VkPipelineExecutablePropertiesKHR& operator=(const safe_VkPipelineExecutablePropertiesKHR& copy_src);
4334     safe_VkPipelineExecutablePropertiesKHR();
4335     ~safe_VkPipelineExecutablePropertiesKHR();
4336     void initialize(const VkPipelineExecutablePropertiesKHR* in_struct);
4337     void initialize(const safe_VkPipelineExecutablePropertiesKHR* copy_src);
ptrsafe_VkPipelineExecutablePropertiesKHR4338     VkPipelineExecutablePropertiesKHR *ptr() { return reinterpret_cast<VkPipelineExecutablePropertiesKHR *>(this); }
ptrsafe_VkPipelineExecutablePropertiesKHR4339     VkPipelineExecutablePropertiesKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutablePropertiesKHR const *>(this); }
4340 };
4341 
4342 struct safe_VkPipelineExecutableInfoKHR {
4343     VkStructureType sType;
4344     const void* pNext;
4345     VkPipeline pipeline;
4346     uint32_t executableIndex;
4347     safe_VkPipelineExecutableInfoKHR(const VkPipelineExecutableInfoKHR* in_struct);
4348     safe_VkPipelineExecutableInfoKHR(const safe_VkPipelineExecutableInfoKHR& copy_src);
4349     safe_VkPipelineExecutableInfoKHR& operator=(const safe_VkPipelineExecutableInfoKHR& copy_src);
4350     safe_VkPipelineExecutableInfoKHR();
4351     ~safe_VkPipelineExecutableInfoKHR();
4352     void initialize(const VkPipelineExecutableInfoKHR* in_struct);
4353     void initialize(const safe_VkPipelineExecutableInfoKHR* copy_src);
ptrsafe_VkPipelineExecutableInfoKHR4354     VkPipelineExecutableInfoKHR *ptr() { return reinterpret_cast<VkPipelineExecutableInfoKHR *>(this); }
ptrsafe_VkPipelineExecutableInfoKHR4355     VkPipelineExecutableInfoKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutableInfoKHR const *>(this); }
4356 };
4357 
4358 struct safe_VkPipelineExecutableStatisticKHR {
4359     VkStructureType sType;
4360     void* pNext;
4361     char name[VK_MAX_DESCRIPTION_SIZE];
4362     char description[VK_MAX_DESCRIPTION_SIZE];
4363     VkPipelineExecutableStatisticFormatKHR format;
4364     VkPipelineExecutableStatisticValueKHR value;
4365     safe_VkPipelineExecutableStatisticKHR(const VkPipelineExecutableStatisticKHR* in_struct);
4366     safe_VkPipelineExecutableStatisticKHR(const safe_VkPipelineExecutableStatisticKHR& copy_src);
4367     safe_VkPipelineExecutableStatisticKHR& operator=(const safe_VkPipelineExecutableStatisticKHR& copy_src);
4368     safe_VkPipelineExecutableStatisticKHR();
4369     ~safe_VkPipelineExecutableStatisticKHR();
4370     void initialize(const VkPipelineExecutableStatisticKHR* in_struct);
4371     void initialize(const safe_VkPipelineExecutableStatisticKHR* copy_src);
ptrsafe_VkPipelineExecutableStatisticKHR4372     VkPipelineExecutableStatisticKHR *ptr() { return reinterpret_cast<VkPipelineExecutableStatisticKHR *>(this); }
ptrsafe_VkPipelineExecutableStatisticKHR4373     VkPipelineExecutableStatisticKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutableStatisticKHR const *>(this); }
4374 };
4375 
4376 struct safe_VkPipelineExecutableInternalRepresentationKHR {
4377     VkStructureType sType;
4378     void* pNext;
4379     char name[VK_MAX_DESCRIPTION_SIZE];
4380     char description[VK_MAX_DESCRIPTION_SIZE];
4381     VkBool32 isText;
4382     size_t dataSize;
4383     void* pData;
4384     safe_VkPipelineExecutableInternalRepresentationKHR(const VkPipelineExecutableInternalRepresentationKHR* in_struct);
4385     safe_VkPipelineExecutableInternalRepresentationKHR(const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src);
4386     safe_VkPipelineExecutableInternalRepresentationKHR& operator=(const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src);
4387     safe_VkPipelineExecutableInternalRepresentationKHR();
4388     ~safe_VkPipelineExecutableInternalRepresentationKHR();
4389     void initialize(const VkPipelineExecutableInternalRepresentationKHR* in_struct);
4390     void initialize(const safe_VkPipelineExecutableInternalRepresentationKHR* copy_src);
ptrsafe_VkPipelineExecutableInternalRepresentationKHR4391     VkPipelineExecutableInternalRepresentationKHR *ptr() { return reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>(this); }
ptrsafe_VkPipelineExecutableInternalRepresentationKHR4392     VkPipelineExecutableInternalRepresentationKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR const *>(this); }
4393 };
4394 
4395 #ifdef VK_ENABLE_BETA_EXTENSIONS
4396 struct safe_VkPipelineLibraryCreateInfoKHR {
4397     VkStructureType sType;
4398     const void* pNext;
4399     uint32_t libraryCount;
4400     VkPipeline* pLibraries;
4401     safe_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR* in_struct);
4402     safe_VkPipelineLibraryCreateInfoKHR(const safe_VkPipelineLibraryCreateInfoKHR& copy_src);
4403     safe_VkPipelineLibraryCreateInfoKHR& operator=(const safe_VkPipelineLibraryCreateInfoKHR& copy_src);
4404     safe_VkPipelineLibraryCreateInfoKHR();
4405     ~safe_VkPipelineLibraryCreateInfoKHR();
4406     void initialize(const VkPipelineLibraryCreateInfoKHR* in_struct);
4407     void initialize(const safe_VkPipelineLibraryCreateInfoKHR* copy_src);
ptrsafe_VkPipelineLibraryCreateInfoKHR4408     VkPipelineLibraryCreateInfoKHR *ptr() { return reinterpret_cast<VkPipelineLibraryCreateInfoKHR *>(this); }
ptrsafe_VkPipelineLibraryCreateInfoKHR4409     VkPipelineLibraryCreateInfoKHR const *ptr() const { return reinterpret_cast<VkPipelineLibraryCreateInfoKHR const *>(this); }
4410 };
4411 #endif // VK_ENABLE_BETA_EXTENSIONS
4412 
4413 struct safe_VkBufferCopy2KHR {
4414     VkStructureType sType;
4415     const void* pNext;
4416     VkDeviceSize srcOffset;
4417     VkDeviceSize dstOffset;
4418     VkDeviceSize size;
4419     safe_VkBufferCopy2KHR(const VkBufferCopy2KHR* in_struct);
4420     safe_VkBufferCopy2KHR(const safe_VkBufferCopy2KHR& copy_src);
4421     safe_VkBufferCopy2KHR& operator=(const safe_VkBufferCopy2KHR& copy_src);
4422     safe_VkBufferCopy2KHR();
4423     ~safe_VkBufferCopy2KHR();
4424     void initialize(const VkBufferCopy2KHR* in_struct);
4425     void initialize(const safe_VkBufferCopy2KHR* copy_src);
ptrsafe_VkBufferCopy2KHR4426     VkBufferCopy2KHR *ptr() { return reinterpret_cast<VkBufferCopy2KHR *>(this); }
ptrsafe_VkBufferCopy2KHR4427     VkBufferCopy2KHR const *ptr() const { return reinterpret_cast<VkBufferCopy2KHR const *>(this); }
4428 };
4429 
4430 struct safe_VkCopyBufferInfo2KHR {
4431     VkStructureType sType;
4432     const void* pNext;
4433     VkBuffer srcBuffer;
4434     VkBuffer dstBuffer;
4435     uint32_t regionCount;
4436     safe_VkBufferCopy2KHR* pRegions;
4437     safe_VkCopyBufferInfo2KHR(const VkCopyBufferInfo2KHR* in_struct);
4438     safe_VkCopyBufferInfo2KHR(const safe_VkCopyBufferInfo2KHR& copy_src);
4439     safe_VkCopyBufferInfo2KHR& operator=(const safe_VkCopyBufferInfo2KHR& copy_src);
4440     safe_VkCopyBufferInfo2KHR();
4441     ~safe_VkCopyBufferInfo2KHR();
4442     void initialize(const VkCopyBufferInfo2KHR* in_struct);
4443     void initialize(const safe_VkCopyBufferInfo2KHR* copy_src);
ptrsafe_VkCopyBufferInfo2KHR4444     VkCopyBufferInfo2KHR *ptr() { return reinterpret_cast<VkCopyBufferInfo2KHR *>(this); }
ptrsafe_VkCopyBufferInfo2KHR4445     VkCopyBufferInfo2KHR const *ptr() const { return reinterpret_cast<VkCopyBufferInfo2KHR const *>(this); }
4446 };
4447 
4448 struct safe_VkImageCopy2KHR {
4449     VkStructureType sType;
4450     const void* pNext;
4451     VkImageSubresourceLayers srcSubresource;
4452     VkOffset3D srcOffset;
4453     VkImageSubresourceLayers dstSubresource;
4454     VkOffset3D dstOffset;
4455     VkExtent3D extent;
4456     safe_VkImageCopy2KHR(const VkImageCopy2KHR* in_struct);
4457     safe_VkImageCopy2KHR(const safe_VkImageCopy2KHR& copy_src);
4458     safe_VkImageCopy2KHR& operator=(const safe_VkImageCopy2KHR& copy_src);
4459     safe_VkImageCopy2KHR();
4460     ~safe_VkImageCopy2KHR();
4461     void initialize(const VkImageCopy2KHR* in_struct);
4462     void initialize(const safe_VkImageCopy2KHR* copy_src);
ptrsafe_VkImageCopy2KHR4463     VkImageCopy2KHR *ptr() { return reinterpret_cast<VkImageCopy2KHR *>(this); }
ptrsafe_VkImageCopy2KHR4464     VkImageCopy2KHR const *ptr() const { return reinterpret_cast<VkImageCopy2KHR const *>(this); }
4465 };
4466 
4467 struct safe_VkCopyImageInfo2KHR {
4468     VkStructureType sType;
4469     const void* pNext;
4470     VkImage srcImage;
4471     VkImageLayout srcImageLayout;
4472     VkImage dstImage;
4473     VkImageLayout dstImageLayout;
4474     uint32_t regionCount;
4475     safe_VkImageCopy2KHR* pRegions;
4476     safe_VkCopyImageInfo2KHR(const VkCopyImageInfo2KHR* in_struct);
4477     safe_VkCopyImageInfo2KHR(const safe_VkCopyImageInfo2KHR& copy_src);
4478     safe_VkCopyImageInfo2KHR& operator=(const safe_VkCopyImageInfo2KHR& copy_src);
4479     safe_VkCopyImageInfo2KHR();
4480     ~safe_VkCopyImageInfo2KHR();
4481     void initialize(const VkCopyImageInfo2KHR* in_struct);
4482     void initialize(const safe_VkCopyImageInfo2KHR* copy_src);
ptrsafe_VkCopyImageInfo2KHR4483     VkCopyImageInfo2KHR *ptr() { return reinterpret_cast<VkCopyImageInfo2KHR *>(this); }
ptrsafe_VkCopyImageInfo2KHR4484     VkCopyImageInfo2KHR const *ptr() const { return reinterpret_cast<VkCopyImageInfo2KHR const *>(this); }
4485 };
4486 
4487 struct safe_VkBufferImageCopy2KHR {
4488     VkStructureType sType;
4489     const void* pNext;
4490     VkDeviceSize bufferOffset;
4491     uint32_t bufferRowLength;
4492     uint32_t bufferImageHeight;
4493     VkImageSubresourceLayers imageSubresource;
4494     VkOffset3D imageOffset;
4495     VkExtent3D imageExtent;
4496     safe_VkBufferImageCopy2KHR(const VkBufferImageCopy2KHR* in_struct);
4497     safe_VkBufferImageCopy2KHR(const safe_VkBufferImageCopy2KHR& copy_src);
4498     safe_VkBufferImageCopy2KHR& operator=(const safe_VkBufferImageCopy2KHR& copy_src);
4499     safe_VkBufferImageCopy2KHR();
4500     ~safe_VkBufferImageCopy2KHR();
4501     void initialize(const VkBufferImageCopy2KHR* in_struct);
4502     void initialize(const safe_VkBufferImageCopy2KHR* copy_src);
ptrsafe_VkBufferImageCopy2KHR4503     VkBufferImageCopy2KHR *ptr() { return reinterpret_cast<VkBufferImageCopy2KHR *>(this); }
ptrsafe_VkBufferImageCopy2KHR4504     VkBufferImageCopy2KHR const *ptr() const { return reinterpret_cast<VkBufferImageCopy2KHR const *>(this); }
4505 };
4506 
4507 struct safe_VkCopyBufferToImageInfo2KHR {
4508     VkStructureType sType;
4509     const void* pNext;
4510     VkBuffer srcBuffer;
4511     VkImage dstImage;
4512     VkImageLayout dstImageLayout;
4513     uint32_t regionCount;
4514     safe_VkBufferImageCopy2KHR* pRegions;
4515     safe_VkCopyBufferToImageInfo2KHR(const VkCopyBufferToImageInfo2KHR* in_struct);
4516     safe_VkCopyBufferToImageInfo2KHR(const safe_VkCopyBufferToImageInfo2KHR& copy_src);
4517     safe_VkCopyBufferToImageInfo2KHR& operator=(const safe_VkCopyBufferToImageInfo2KHR& copy_src);
4518     safe_VkCopyBufferToImageInfo2KHR();
4519     ~safe_VkCopyBufferToImageInfo2KHR();
4520     void initialize(const VkCopyBufferToImageInfo2KHR* in_struct);
4521     void initialize(const safe_VkCopyBufferToImageInfo2KHR* copy_src);
ptrsafe_VkCopyBufferToImageInfo2KHR4522     VkCopyBufferToImageInfo2KHR *ptr() { return reinterpret_cast<VkCopyBufferToImageInfo2KHR *>(this); }
ptrsafe_VkCopyBufferToImageInfo2KHR4523     VkCopyBufferToImageInfo2KHR const *ptr() const { return reinterpret_cast<VkCopyBufferToImageInfo2KHR const *>(this); }
4524 };
4525 
4526 struct safe_VkCopyImageToBufferInfo2KHR {
4527     VkStructureType sType;
4528     const void* pNext;
4529     VkImage srcImage;
4530     VkImageLayout srcImageLayout;
4531     VkBuffer dstBuffer;
4532     uint32_t regionCount;
4533     safe_VkBufferImageCopy2KHR* pRegions;
4534     safe_VkCopyImageToBufferInfo2KHR(const VkCopyImageToBufferInfo2KHR* in_struct);
4535     safe_VkCopyImageToBufferInfo2KHR(const safe_VkCopyImageToBufferInfo2KHR& copy_src);
4536     safe_VkCopyImageToBufferInfo2KHR& operator=(const safe_VkCopyImageToBufferInfo2KHR& copy_src);
4537     safe_VkCopyImageToBufferInfo2KHR();
4538     ~safe_VkCopyImageToBufferInfo2KHR();
4539     void initialize(const VkCopyImageToBufferInfo2KHR* in_struct);
4540     void initialize(const safe_VkCopyImageToBufferInfo2KHR* copy_src);
ptrsafe_VkCopyImageToBufferInfo2KHR4541     VkCopyImageToBufferInfo2KHR *ptr() { return reinterpret_cast<VkCopyImageToBufferInfo2KHR *>(this); }
ptrsafe_VkCopyImageToBufferInfo2KHR4542     VkCopyImageToBufferInfo2KHR const *ptr() const { return reinterpret_cast<VkCopyImageToBufferInfo2KHR const *>(this); }
4543 };
4544 
4545 struct safe_VkImageBlit2KHR {
4546     VkStructureType sType;
4547     const void* pNext;
4548     VkImageSubresourceLayers srcSubresource;
4549     VkOffset3D srcOffsets[2];
4550     VkImageSubresourceLayers dstSubresource;
4551     VkOffset3D dstOffsets[2];
4552     safe_VkImageBlit2KHR(const VkImageBlit2KHR* in_struct);
4553     safe_VkImageBlit2KHR(const safe_VkImageBlit2KHR& copy_src);
4554     safe_VkImageBlit2KHR& operator=(const safe_VkImageBlit2KHR& copy_src);
4555     safe_VkImageBlit2KHR();
4556     ~safe_VkImageBlit2KHR();
4557     void initialize(const VkImageBlit2KHR* in_struct);
4558     void initialize(const safe_VkImageBlit2KHR* copy_src);
ptrsafe_VkImageBlit2KHR4559     VkImageBlit2KHR *ptr() { return reinterpret_cast<VkImageBlit2KHR *>(this); }
ptrsafe_VkImageBlit2KHR4560     VkImageBlit2KHR const *ptr() const { return reinterpret_cast<VkImageBlit2KHR const *>(this); }
4561 };
4562 
4563 struct safe_VkBlitImageInfo2KHR {
4564     VkStructureType sType;
4565     const void* pNext;
4566     VkImage srcImage;
4567     VkImageLayout srcImageLayout;
4568     VkImage dstImage;
4569     VkImageLayout dstImageLayout;
4570     uint32_t regionCount;
4571     safe_VkImageBlit2KHR* pRegions;
4572     VkFilter filter;
4573     safe_VkBlitImageInfo2KHR(const VkBlitImageInfo2KHR* in_struct);
4574     safe_VkBlitImageInfo2KHR(const safe_VkBlitImageInfo2KHR& copy_src);
4575     safe_VkBlitImageInfo2KHR& operator=(const safe_VkBlitImageInfo2KHR& copy_src);
4576     safe_VkBlitImageInfo2KHR();
4577     ~safe_VkBlitImageInfo2KHR();
4578     void initialize(const VkBlitImageInfo2KHR* in_struct);
4579     void initialize(const safe_VkBlitImageInfo2KHR* copy_src);
ptrsafe_VkBlitImageInfo2KHR4580     VkBlitImageInfo2KHR *ptr() { return reinterpret_cast<VkBlitImageInfo2KHR *>(this); }
ptrsafe_VkBlitImageInfo2KHR4581     VkBlitImageInfo2KHR const *ptr() const { return reinterpret_cast<VkBlitImageInfo2KHR const *>(this); }
4582 };
4583 
4584 struct safe_VkImageResolve2KHR {
4585     VkStructureType sType;
4586     const void* pNext;
4587     VkImageSubresourceLayers srcSubresource;
4588     VkOffset3D srcOffset;
4589     VkImageSubresourceLayers dstSubresource;
4590     VkOffset3D dstOffset;
4591     VkExtent3D extent;
4592     safe_VkImageResolve2KHR(const VkImageResolve2KHR* in_struct);
4593     safe_VkImageResolve2KHR(const safe_VkImageResolve2KHR& copy_src);
4594     safe_VkImageResolve2KHR& operator=(const safe_VkImageResolve2KHR& copy_src);
4595     safe_VkImageResolve2KHR();
4596     ~safe_VkImageResolve2KHR();
4597     void initialize(const VkImageResolve2KHR* in_struct);
4598     void initialize(const safe_VkImageResolve2KHR* copy_src);
ptrsafe_VkImageResolve2KHR4599     VkImageResolve2KHR *ptr() { return reinterpret_cast<VkImageResolve2KHR *>(this); }
ptrsafe_VkImageResolve2KHR4600     VkImageResolve2KHR const *ptr() const { return reinterpret_cast<VkImageResolve2KHR const *>(this); }
4601 };
4602 
4603 struct safe_VkResolveImageInfo2KHR {
4604     VkStructureType sType;
4605     const void* pNext;
4606     VkImage srcImage;
4607     VkImageLayout srcImageLayout;
4608     VkImage dstImage;
4609     VkImageLayout dstImageLayout;
4610     uint32_t regionCount;
4611     safe_VkImageResolve2KHR* pRegions;
4612     safe_VkResolveImageInfo2KHR(const VkResolveImageInfo2KHR* in_struct);
4613     safe_VkResolveImageInfo2KHR(const safe_VkResolveImageInfo2KHR& copy_src);
4614     safe_VkResolveImageInfo2KHR& operator=(const safe_VkResolveImageInfo2KHR& copy_src);
4615     safe_VkResolveImageInfo2KHR();
4616     ~safe_VkResolveImageInfo2KHR();
4617     void initialize(const VkResolveImageInfo2KHR* in_struct);
4618     void initialize(const safe_VkResolveImageInfo2KHR* copy_src);
ptrsafe_VkResolveImageInfo2KHR4619     VkResolveImageInfo2KHR *ptr() { return reinterpret_cast<VkResolveImageInfo2KHR *>(this); }
ptrsafe_VkResolveImageInfo2KHR4620     VkResolveImageInfo2KHR const *ptr() const { return reinterpret_cast<VkResolveImageInfo2KHR const *>(this); }
4621 };
4622 
4623 struct safe_VkDebugReportCallbackCreateInfoEXT {
4624     VkStructureType sType;
4625     const void* pNext;
4626     VkDebugReportFlagsEXT flags;
4627     PFN_vkDebugReportCallbackEXT pfnCallback;
4628     void* pUserData;
4629     safe_VkDebugReportCallbackCreateInfoEXT(const VkDebugReportCallbackCreateInfoEXT* in_struct);
4630     safe_VkDebugReportCallbackCreateInfoEXT(const safe_VkDebugReportCallbackCreateInfoEXT& copy_src);
4631     safe_VkDebugReportCallbackCreateInfoEXT& operator=(const safe_VkDebugReportCallbackCreateInfoEXT& copy_src);
4632     safe_VkDebugReportCallbackCreateInfoEXT();
4633     ~safe_VkDebugReportCallbackCreateInfoEXT();
4634     void initialize(const VkDebugReportCallbackCreateInfoEXT* in_struct);
4635     void initialize(const safe_VkDebugReportCallbackCreateInfoEXT* copy_src);
ptrsafe_VkDebugReportCallbackCreateInfoEXT4636     VkDebugReportCallbackCreateInfoEXT *ptr() { return reinterpret_cast<VkDebugReportCallbackCreateInfoEXT *>(this); }
ptrsafe_VkDebugReportCallbackCreateInfoEXT4637     VkDebugReportCallbackCreateInfoEXT const *ptr() const { return reinterpret_cast<VkDebugReportCallbackCreateInfoEXT const *>(this); }
4638 };
4639 
4640 struct safe_VkPipelineRasterizationStateRasterizationOrderAMD {
4641     VkStructureType sType;
4642     const void* pNext;
4643     VkRasterizationOrderAMD rasterizationOrder;
4644     safe_VkPipelineRasterizationStateRasterizationOrderAMD(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct);
4645     safe_VkPipelineRasterizationStateRasterizationOrderAMD(const safe_VkPipelineRasterizationStateRasterizationOrderAMD& copy_src);
4646     safe_VkPipelineRasterizationStateRasterizationOrderAMD& operator=(const safe_VkPipelineRasterizationStateRasterizationOrderAMD& copy_src);
4647     safe_VkPipelineRasterizationStateRasterizationOrderAMD();
4648     ~safe_VkPipelineRasterizationStateRasterizationOrderAMD();
4649     void initialize(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct);
4650     void initialize(const safe_VkPipelineRasterizationStateRasterizationOrderAMD* copy_src);
ptrsafe_VkPipelineRasterizationStateRasterizationOrderAMD4651     VkPipelineRasterizationStateRasterizationOrderAMD *ptr() { return reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD *>(this); }
ptrsafe_VkPipelineRasterizationStateRasterizationOrderAMD4652     VkPipelineRasterizationStateRasterizationOrderAMD const *ptr() const { return reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD const *>(this); }
4653 };
4654 
4655 struct safe_VkDebugMarkerObjectNameInfoEXT {
4656     VkStructureType sType;
4657     const void* pNext;
4658     VkDebugReportObjectTypeEXT objectType;
4659     uint64_t object;
4660     const char* pObjectName;
4661     safe_VkDebugMarkerObjectNameInfoEXT(const VkDebugMarkerObjectNameInfoEXT* in_struct);
4662     safe_VkDebugMarkerObjectNameInfoEXT(const safe_VkDebugMarkerObjectNameInfoEXT& copy_src);
4663     safe_VkDebugMarkerObjectNameInfoEXT& operator=(const safe_VkDebugMarkerObjectNameInfoEXT& copy_src);
4664     safe_VkDebugMarkerObjectNameInfoEXT();
4665     ~safe_VkDebugMarkerObjectNameInfoEXT();
4666     void initialize(const VkDebugMarkerObjectNameInfoEXT* in_struct);
4667     void initialize(const safe_VkDebugMarkerObjectNameInfoEXT* copy_src);
ptrsafe_VkDebugMarkerObjectNameInfoEXT4668     VkDebugMarkerObjectNameInfoEXT *ptr() { return reinterpret_cast<VkDebugMarkerObjectNameInfoEXT *>(this); }
ptrsafe_VkDebugMarkerObjectNameInfoEXT4669     VkDebugMarkerObjectNameInfoEXT const *ptr() const { return reinterpret_cast<VkDebugMarkerObjectNameInfoEXT const *>(this); }
4670 };
4671 
4672 struct safe_VkDebugMarkerObjectTagInfoEXT {
4673     VkStructureType sType;
4674     const void* pNext;
4675     VkDebugReportObjectTypeEXT objectType;
4676     uint64_t object;
4677     uint64_t tagName;
4678     size_t tagSize;
4679     const void* pTag;
4680     safe_VkDebugMarkerObjectTagInfoEXT(const VkDebugMarkerObjectTagInfoEXT* in_struct);
4681     safe_VkDebugMarkerObjectTagInfoEXT(const safe_VkDebugMarkerObjectTagInfoEXT& copy_src);
4682     safe_VkDebugMarkerObjectTagInfoEXT& operator=(const safe_VkDebugMarkerObjectTagInfoEXT& copy_src);
4683     safe_VkDebugMarkerObjectTagInfoEXT();
4684     ~safe_VkDebugMarkerObjectTagInfoEXT();
4685     void initialize(const VkDebugMarkerObjectTagInfoEXT* in_struct);
4686     void initialize(const safe_VkDebugMarkerObjectTagInfoEXT* copy_src);
ptrsafe_VkDebugMarkerObjectTagInfoEXT4687     VkDebugMarkerObjectTagInfoEXT *ptr() { return reinterpret_cast<VkDebugMarkerObjectTagInfoEXT *>(this); }
ptrsafe_VkDebugMarkerObjectTagInfoEXT4688     VkDebugMarkerObjectTagInfoEXT const *ptr() const { return reinterpret_cast<VkDebugMarkerObjectTagInfoEXT const *>(this); }
4689 };
4690 
4691 struct safe_VkDebugMarkerMarkerInfoEXT {
4692     VkStructureType sType;
4693     const void* pNext;
4694     const char* pMarkerName;
4695     float color[4];
4696     safe_VkDebugMarkerMarkerInfoEXT(const VkDebugMarkerMarkerInfoEXT* in_struct);
4697     safe_VkDebugMarkerMarkerInfoEXT(const safe_VkDebugMarkerMarkerInfoEXT& copy_src);
4698     safe_VkDebugMarkerMarkerInfoEXT& operator=(const safe_VkDebugMarkerMarkerInfoEXT& copy_src);
4699     safe_VkDebugMarkerMarkerInfoEXT();
4700     ~safe_VkDebugMarkerMarkerInfoEXT();
4701     void initialize(const VkDebugMarkerMarkerInfoEXT* in_struct);
4702     void initialize(const safe_VkDebugMarkerMarkerInfoEXT* copy_src);
ptrsafe_VkDebugMarkerMarkerInfoEXT4703     VkDebugMarkerMarkerInfoEXT *ptr() { return reinterpret_cast<VkDebugMarkerMarkerInfoEXT *>(this); }
ptrsafe_VkDebugMarkerMarkerInfoEXT4704     VkDebugMarkerMarkerInfoEXT const *ptr() const { return reinterpret_cast<VkDebugMarkerMarkerInfoEXT const *>(this); }
4705 };
4706 
4707 struct safe_VkDedicatedAllocationImageCreateInfoNV {
4708     VkStructureType sType;
4709     const void* pNext;
4710     VkBool32 dedicatedAllocation;
4711     safe_VkDedicatedAllocationImageCreateInfoNV(const VkDedicatedAllocationImageCreateInfoNV* in_struct);
4712     safe_VkDedicatedAllocationImageCreateInfoNV(const safe_VkDedicatedAllocationImageCreateInfoNV& copy_src);
4713     safe_VkDedicatedAllocationImageCreateInfoNV& operator=(const safe_VkDedicatedAllocationImageCreateInfoNV& copy_src);
4714     safe_VkDedicatedAllocationImageCreateInfoNV();
4715     ~safe_VkDedicatedAllocationImageCreateInfoNV();
4716     void initialize(const VkDedicatedAllocationImageCreateInfoNV* in_struct);
4717     void initialize(const safe_VkDedicatedAllocationImageCreateInfoNV* copy_src);
ptrsafe_VkDedicatedAllocationImageCreateInfoNV4718     VkDedicatedAllocationImageCreateInfoNV *ptr() { return reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV *>(this); }
ptrsafe_VkDedicatedAllocationImageCreateInfoNV4719     VkDedicatedAllocationImageCreateInfoNV const *ptr() const { return reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV const *>(this); }
4720 };
4721 
4722 struct safe_VkDedicatedAllocationBufferCreateInfoNV {
4723     VkStructureType sType;
4724     const void* pNext;
4725     VkBool32 dedicatedAllocation;
4726     safe_VkDedicatedAllocationBufferCreateInfoNV(const VkDedicatedAllocationBufferCreateInfoNV* in_struct);
4727     safe_VkDedicatedAllocationBufferCreateInfoNV(const safe_VkDedicatedAllocationBufferCreateInfoNV& copy_src);
4728     safe_VkDedicatedAllocationBufferCreateInfoNV& operator=(const safe_VkDedicatedAllocationBufferCreateInfoNV& copy_src);
4729     safe_VkDedicatedAllocationBufferCreateInfoNV();
4730     ~safe_VkDedicatedAllocationBufferCreateInfoNV();
4731     void initialize(const VkDedicatedAllocationBufferCreateInfoNV* in_struct);
4732     void initialize(const safe_VkDedicatedAllocationBufferCreateInfoNV* copy_src);
ptrsafe_VkDedicatedAllocationBufferCreateInfoNV4733     VkDedicatedAllocationBufferCreateInfoNV *ptr() { return reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV *>(this); }
ptrsafe_VkDedicatedAllocationBufferCreateInfoNV4734     VkDedicatedAllocationBufferCreateInfoNV const *ptr() const { return reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV const *>(this); }
4735 };
4736 
4737 struct safe_VkDedicatedAllocationMemoryAllocateInfoNV {
4738     VkStructureType sType;
4739     const void* pNext;
4740     VkImage image;
4741     VkBuffer buffer;
4742     safe_VkDedicatedAllocationMemoryAllocateInfoNV(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct);
4743     safe_VkDedicatedAllocationMemoryAllocateInfoNV(const safe_VkDedicatedAllocationMemoryAllocateInfoNV& copy_src);
4744     safe_VkDedicatedAllocationMemoryAllocateInfoNV& operator=(const safe_VkDedicatedAllocationMemoryAllocateInfoNV& copy_src);
4745     safe_VkDedicatedAllocationMemoryAllocateInfoNV();
4746     ~safe_VkDedicatedAllocationMemoryAllocateInfoNV();
4747     void initialize(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct);
4748     void initialize(const safe_VkDedicatedAllocationMemoryAllocateInfoNV* copy_src);
ptrsafe_VkDedicatedAllocationMemoryAllocateInfoNV4749     VkDedicatedAllocationMemoryAllocateInfoNV *ptr() { return reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV *>(this); }
ptrsafe_VkDedicatedAllocationMemoryAllocateInfoNV4750     VkDedicatedAllocationMemoryAllocateInfoNV const *ptr() const { return reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV const *>(this); }
4751 };
4752 
4753 struct safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT {
4754     VkStructureType sType;
4755     void* pNext;
4756     VkBool32 transformFeedback;
4757     VkBool32 geometryStreams;
4758     safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct);
4759     safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& copy_src);
4760     safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& operator=(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& copy_src);
4761     safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT();
4762     ~safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT();
4763     void initialize(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct);
4764     void initialize(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceTransformFeedbackFeaturesEXT4765     VkPhysicalDeviceTransformFeedbackFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceTransformFeedbackFeaturesEXT4766     VkPhysicalDeviceTransformFeedbackFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT const *>(this); }
4767 };
4768 
4769 struct safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT {
4770     VkStructureType sType;
4771     void* pNext;
4772     uint32_t maxTransformFeedbackStreams;
4773     uint32_t maxTransformFeedbackBuffers;
4774     VkDeviceSize maxTransformFeedbackBufferSize;
4775     uint32_t maxTransformFeedbackStreamDataSize;
4776     uint32_t maxTransformFeedbackBufferDataSize;
4777     uint32_t maxTransformFeedbackBufferDataStride;
4778     VkBool32 transformFeedbackQueries;
4779     VkBool32 transformFeedbackStreamsLinesTriangles;
4780     VkBool32 transformFeedbackRasterizationStreamSelect;
4781     VkBool32 transformFeedbackDraw;
4782     safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct);
4783     safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& copy_src);
4784     safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& operator=(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& copy_src);
4785     safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT();
4786     ~safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT();
4787     void initialize(const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct);
4788     void initialize(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT* copy_src);
ptrsafe_VkPhysicalDeviceTransformFeedbackPropertiesEXT4789     VkPhysicalDeviceTransformFeedbackPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT *>(this); }
ptrsafe_VkPhysicalDeviceTransformFeedbackPropertiesEXT4790     VkPhysicalDeviceTransformFeedbackPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT const *>(this); }
4791 };
4792 
4793 struct safe_VkPipelineRasterizationStateStreamCreateInfoEXT {
4794     VkStructureType sType;
4795     const void* pNext;
4796     VkPipelineRasterizationStateStreamCreateFlagsEXT flags;
4797     uint32_t rasterizationStream;
4798     safe_VkPipelineRasterizationStateStreamCreateInfoEXT(const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct);
4799     safe_VkPipelineRasterizationStateStreamCreateInfoEXT(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& copy_src);
4800     safe_VkPipelineRasterizationStateStreamCreateInfoEXT& operator=(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& copy_src);
4801     safe_VkPipelineRasterizationStateStreamCreateInfoEXT();
4802     ~safe_VkPipelineRasterizationStateStreamCreateInfoEXT();
4803     void initialize(const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct);
4804     void initialize(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT* copy_src);
ptrsafe_VkPipelineRasterizationStateStreamCreateInfoEXT4805     VkPipelineRasterizationStateStreamCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT *>(this); }
ptrsafe_VkPipelineRasterizationStateStreamCreateInfoEXT4806     VkPipelineRasterizationStateStreamCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT const *>(this); }
4807 };
4808 
4809 struct safe_VkImageViewHandleInfoNVX {
4810     VkStructureType sType;
4811     const void* pNext;
4812     VkImageView imageView;
4813     VkDescriptorType descriptorType;
4814     VkSampler sampler;
4815     safe_VkImageViewHandleInfoNVX(const VkImageViewHandleInfoNVX* in_struct);
4816     safe_VkImageViewHandleInfoNVX(const safe_VkImageViewHandleInfoNVX& copy_src);
4817     safe_VkImageViewHandleInfoNVX& operator=(const safe_VkImageViewHandleInfoNVX& copy_src);
4818     safe_VkImageViewHandleInfoNVX();
4819     ~safe_VkImageViewHandleInfoNVX();
4820     void initialize(const VkImageViewHandleInfoNVX* in_struct);
4821     void initialize(const safe_VkImageViewHandleInfoNVX* copy_src);
ptrsafe_VkImageViewHandleInfoNVX4822     VkImageViewHandleInfoNVX *ptr() { return reinterpret_cast<VkImageViewHandleInfoNVX *>(this); }
ptrsafe_VkImageViewHandleInfoNVX4823     VkImageViewHandleInfoNVX const *ptr() const { return reinterpret_cast<VkImageViewHandleInfoNVX const *>(this); }
4824 };
4825 
4826 struct safe_VkImageViewAddressPropertiesNVX {
4827     VkStructureType sType;
4828     void* pNext;
4829     VkDeviceAddress deviceAddress;
4830     VkDeviceSize size;
4831     safe_VkImageViewAddressPropertiesNVX(const VkImageViewAddressPropertiesNVX* in_struct);
4832     safe_VkImageViewAddressPropertiesNVX(const safe_VkImageViewAddressPropertiesNVX& copy_src);
4833     safe_VkImageViewAddressPropertiesNVX& operator=(const safe_VkImageViewAddressPropertiesNVX& copy_src);
4834     safe_VkImageViewAddressPropertiesNVX();
4835     ~safe_VkImageViewAddressPropertiesNVX();
4836     void initialize(const VkImageViewAddressPropertiesNVX* in_struct);
4837     void initialize(const safe_VkImageViewAddressPropertiesNVX* copy_src);
ptrsafe_VkImageViewAddressPropertiesNVX4838     VkImageViewAddressPropertiesNVX *ptr() { return reinterpret_cast<VkImageViewAddressPropertiesNVX *>(this); }
ptrsafe_VkImageViewAddressPropertiesNVX4839     VkImageViewAddressPropertiesNVX const *ptr() const { return reinterpret_cast<VkImageViewAddressPropertiesNVX const *>(this); }
4840 };
4841 
4842 struct safe_VkTextureLODGatherFormatPropertiesAMD {
4843     VkStructureType sType;
4844     void* pNext;
4845     VkBool32 supportsTextureGatherLODBiasAMD;
4846     safe_VkTextureLODGatherFormatPropertiesAMD(const VkTextureLODGatherFormatPropertiesAMD* in_struct);
4847     safe_VkTextureLODGatherFormatPropertiesAMD(const safe_VkTextureLODGatherFormatPropertiesAMD& copy_src);
4848     safe_VkTextureLODGatherFormatPropertiesAMD& operator=(const safe_VkTextureLODGatherFormatPropertiesAMD& copy_src);
4849     safe_VkTextureLODGatherFormatPropertiesAMD();
4850     ~safe_VkTextureLODGatherFormatPropertiesAMD();
4851     void initialize(const VkTextureLODGatherFormatPropertiesAMD* in_struct);
4852     void initialize(const safe_VkTextureLODGatherFormatPropertiesAMD* copy_src);
ptrsafe_VkTextureLODGatherFormatPropertiesAMD4853     VkTextureLODGatherFormatPropertiesAMD *ptr() { return reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD *>(this); }
ptrsafe_VkTextureLODGatherFormatPropertiesAMD4854     VkTextureLODGatherFormatPropertiesAMD const *ptr() const { return reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD const *>(this); }
4855 };
4856 
4857 #ifdef VK_USE_PLATFORM_GGP
4858 struct safe_VkStreamDescriptorSurfaceCreateInfoGGP {
4859     VkStructureType sType;
4860     const void* pNext;
4861     VkStreamDescriptorSurfaceCreateFlagsGGP flags;
4862     GgpStreamDescriptor streamDescriptor;
4863     safe_VkStreamDescriptorSurfaceCreateInfoGGP(const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct);
4864     safe_VkStreamDescriptorSurfaceCreateInfoGGP(const safe_VkStreamDescriptorSurfaceCreateInfoGGP& copy_src);
4865     safe_VkStreamDescriptorSurfaceCreateInfoGGP& operator=(const safe_VkStreamDescriptorSurfaceCreateInfoGGP& copy_src);
4866     safe_VkStreamDescriptorSurfaceCreateInfoGGP();
4867     ~safe_VkStreamDescriptorSurfaceCreateInfoGGP();
4868     void initialize(const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct);
4869     void initialize(const safe_VkStreamDescriptorSurfaceCreateInfoGGP* copy_src);
ptrsafe_VkStreamDescriptorSurfaceCreateInfoGGP4870     VkStreamDescriptorSurfaceCreateInfoGGP *ptr() { return reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP *>(this); }
ptrsafe_VkStreamDescriptorSurfaceCreateInfoGGP4871     VkStreamDescriptorSurfaceCreateInfoGGP const *ptr() const { return reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP const *>(this); }
4872 };
4873 #endif // VK_USE_PLATFORM_GGP
4874 
4875 struct safe_VkPhysicalDeviceCornerSampledImageFeaturesNV {
4876     VkStructureType sType;
4877     void* pNext;
4878     VkBool32 cornerSampledImage;
4879     safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct);
4880     safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& copy_src);
4881     safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& operator=(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& copy_src);
4882     safe_VkPhysicalDeviceCornerSampledImageFeaturesNV();
4883     ~safe_VkPhysicalDeviceCornerSampledImageFeaturesNV();
4884     void initialize(const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct);
4885     void initialize(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV* copy_src);
ptrsafe_VkPhysicalDeviceCornerSampledImageFeaturesNV4886     VkPhysicalDeviceCornerSampledImageFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV *>(this); }
ptrsafe_VkPhysicalDeviceCornerSampledImageFeaturesNV4887     VkPhysicalDeviceCornerSampledImageFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV const *>(this); }
4888 };
4889 
4890 struct safe_VkExternalMemoryImageCreateInfoNV {
4891     VkStructureType sType;
4892     const void* pNext;
4893     VkExternalMemoryHandleTypeFlagsNV handleTypes;
4894     safe_VkExternalMemoryImageCreateInfoNV(const VkExternalMemoryImageCreateInfoNV* in_struct);
4895     safe_VkExternalMemoryImageCreateInfoNV(const safe_VkExternalMemoryImageCreateInfoNV& copy_src);
4896     safe_VkExternalMemoryImageCreateInfoNV& operator=(const safe_VkExternalMemoryImageCreateInfoNV& copy_src);
4897     safe_VkExternalMemoryImageCreateInfoNV();
4898     ~safe_VkExternalMemoryImageCreateInfoNV();
4899     void initialize(const VkExternalMemoryImageCreateInfoNV* in_struct);
4900     void initialize(const safe_VkExternalMemoryImageCreateInfoNV* copy_src);
ptrsafe_VkExternalMemoryImageCreateInfoNV4901     VkExternalMemoryImageCreateInfoNV *ptr() { return reinterpret_cast<VkExternalMemoryImageCreateInfoNV *>(this); }
ptrsafe_VkExternalMemoryImageCreateInfoNV4902     VkExternalMemoryImageCreateInfoNV const *ptr() const { return reinterpret_cast<VkExternalMemoryImageCreateInfoNV const *>(this); }
4903 };
4904 
4905 struct safe_VkExportMemoryAllocateInfoNV {
4906     VkStructureType sType;
4907     const void* pNext;
4908     VkExternalMemoryHandleTypeFlagsNV handleTypes;
4909     safe_VkExportMemoryAllocateInfoNV(const VkExportMemoryAllocateInfoNV* in_struct);
4910     safe_VkExportMemoryAllocateInfoNV(const safe_VkExportMemoryAllocateInfoNV& copy_src);
4911     safe_VkExportMemoryAllocateInfoNV& operator=(const safe_VkExportMemoryAllocateInfoNV& copy_src);
4912     safe_VkExportMemoryAllocateInfoNV();
4913     ~safe_VkExportMemoryAllocateInfoNV();
4914     void initialize(const VkExportMemoryAllocateInfoNV* in_struct);
4915     void initialize(const safe_VkExportMemoryAllocateInfoNV* copy_src);
ptrsafe_VkExportMemoryAllocateInfoNV4916     VkExportMemoryAllocateInfoNV *ptr() { return reinterpret_cast<VkExportMemoryAllocateInfoNV *>(this); }
ptrsafe_VkExportMemoryAllocateInfoNV4917     VkExportMemoryAllocateInfoNV const *ptr() const { return reinterpret_cast<VkExportMemoryAllocateInfoNV const *>(this); }
4918 };
4919 
4920 #ifdef VK_USE_PLATFORM_WIN32_KHR
4921 struct safe_VkImportMemoryWin32HandleInfoNV {
4922     VkStructureType sType;
4923     const void* pNext;
4924     VkExternalMemoryHandleTypeFlagsNV handleType;
4925     HANDLE handle;
4926     safe_VkImportMemoryWin32HandleInfoNV(const VkImportMemoryWin32HandleInfoNV* in_struct);
4927     safe_VkImportMemoryWin32HandleInfoNV(const safe_VkImportMemoryWin32HandleInfoNV& copy_src);
4928     safe_VkImportMemoryWin32HandleInfoNV& operator=(const safe_VkImportMemoryWin32HandleInfoNV& copy_src);
4929     safe_VkImportMemoryWin32HandleInfoNV();
4930     ~safe_VkImportMemoryWin32HandleInfoNV();
4931     void initialize(const VkImportMemoryWin32HandleInfoNV* in_struct);
4932     void initialize(const safe_VkImportMemoryWin32HandleInfoNV* copy_src);
ptrsafe_VkImportMemoryWin32HandleInfoNV4933     VkImportMemoryWin32HandleInfoNV *ptr() { return reinterpret_cast<VkImportMemoryWin32HandleInfoNV *>(this); }
ptrsafe_VkImportMemoryWin32HandleInfoNV4934     VkImportMemoryWin32HandleInfoNV const *ptr() const { return reinterpret_cast<VkImportMemoryWin32HandleInfoNV const *>(this); }
4935 };
4936 #endif // VK_USE_PLATFORM_WIN32_KHR
4937 
4938 #ifdef VK_USE_PLATFORM_WIN32_KHR
4939 struct safe_VkExportMemoryWin32HandleInfoNV {
4940     VkStructureType sType;
4941     const void* pNext;
4942     const SECURITY_ATTRIBUTES* pAttributes;
4943     DWORD dwAccess;
4944     safe_VkExportMemoryWin32HandleInfoNV(const VkExportMemoryWin32HandleInfoNV* in_struct);
4945     safe_VkExportMemoryWin32HandleInfoNV(const safe_VkExportMemoryWin32HandleInfoNV& copy_src);
4946     safe_VkExportMemoryWin32HandleInfoNV& operator=(const safe_VkExportMemoryWin32HandleInfoNV& copy_src);
4947     safe_VkExportMemoryWin32HandleInfoNV();
4948     ~safe_VkExportMemoryWin32HandleInfoNV();
4949     void initialize(const VkExportMemoryWin32HandleInfoNV* in_struct);
4950     void initialize(const safe_VkExportMemoryWin32HandleInfoNV* copy_src);
ptrsafe_VkExportMemoryWin32HandleInfoNV4951     VkExportMemoryWin32HandleInfoNV *ptr() { return reinterpret_cast<VkExportMemoryWin32HandleInfoNV *>(this); }
ptrsafe_VkExportMemoryWin32HandleInfoNV4952     VkExportMemoryWin32HandleInfoNV const *ptr() const { return reinterpret_cast<VkExportMemoryWin32HandleInfoNV const *>(this); }
4953 };
4954 #endif // VK_USE_PLATFORM_WIN32_KHR
4955 
4956 #ifdef VK_USE_PLATFORM_WIN32_KHR
4957 struct safe_VkWin32KeyedMutexAcquireReleaseInfoNV {
4958     VkStructureType sType;
4959     const void* pNext;
4960     uint32_t acquireCount;
4961     VkDeviceMemory* pAcquireSyncs;
4962     const uint64_t* pAcquireKeys;
4963     const uint32_t* pAcquireTimeoutMilliseconds;
4964     uint32_t releaseCount;
4965     VkDeviceMemory* pReleaseSyncs;
4966     const uint64_t* pReleaseKeys;
4967     safe_VkWin32KeyedMutexAcquireReleaseInfoNV(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct);
4968     safe_VkWin32KeyedMutexAcquireReleaseInfoNV(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& copy_src);
4969     safe_VkWin32KeyedMutexAcquireReleaseInfoNV& operator=(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& copy_src);
4970     safe_VkWin32KeyedMutexAcquireReleaseInfoNV();
4971     ~safe_VkWin32KeyedMutexAcquireReleaseInfoNV();
4972     void initialize(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct);
4973     void initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV* copy_src);
ptrsafe_VkWin32KeyedMutexAcquireReleaseInfoNV4974     VkWin32KeyedMutexAcquireReleaseInfoNV *ptr() { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV *>(this); }
ptrsafe_VkWin32KeyedMutexAcquireReleaseInfoNV4975     VkWin32KeyedMutexAcquireReleaseInfoNV const *ptr() const { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV const *>(this); }
4976 };
4977 #endif // VK_USE_PLATFORM_WIN32_KHR
4978 
4979 struct safe_VkValidationFlagsEXT {
4980     VkStructureType sType;
4981     const void* pNext;
4982     uint32_t disabledValidationCheckCount;
4983     const VkValidationCheckEXT* pDisabledValidationChecks;
4984     safe_VkValidationFlagsEXT(const VkValidationFlagsEXT* in_struct);
4985     safe_VkValidationFlagsEXT(const safe_VkValidationFlagsEXT& copy_src);
4986     safe_VkValidationFlagsEXT& operator=(const safe_VkValidationFlagsEXT& copy_src);
4987     safe_VkValidationFlagsEXT();
4988     ~safe_VkValidationFlagsEXT();
4989     void initialize(const VkValidationFlagsEXT* in_struct);
4990     void initialize(const safe_VkValidationFlagsEXT* copy_src);
ptrsafe_VkValidationFlagsEXT4991     VkValidationFlagsEXT *ptr() { return reinterpret_cast<VkValidationFlagsEXT *>(this); }
ptrsafe_VkValidationFlagsEXT4992     VkValidationFlagsEXT const *ptr() const { return reinterpret_cast<VkValidationFlagsEXT const *>(this); }
4993 };
4994 
4995 #ifdef VK_USE_PLATFORM_VI_NN
4996 struct safe_VkViSurfaceCreateInfoNN {
4997     VkStructureType sType;
4998     const void* pNext;
4999     VkViSurfaceCreateFlagsNN flags;
5000     void* window;
5001     safe_VkViSurfaceCreateInfoNN(const VkViSurfaceCreateInfoNN* in_struct);
5002     safe_VkViSurfaceCreateInfoNN(const safe_VkViSurfaceCreateInfoNN& copy_src);
5003     safe_VkViSurfaceCreateInfoNN& operator=(const safe_VkViSurfaceCreateInfoNN& copy_src);
5004     safe_VkViSurfaceCreateInfoNN();
5005     ~safe_VkViSurfaceCreateInfoNN();
5006     void initialize(const VkViSurfaceCreateInfoNN* in_struct);
5007     void initialize(const safe_VkViSurfaceCreateInfoNN* copy_src);
ptrsafe_VkViSurfaceCreateInfoNN5008     VkViSurfaceCreateInfoNN *ptr() { return reinterpret_cast<VkViSurfaceCreateInfoNN *>(this); }
ptrsafe_VkViSurfaceCreateInfoNN5009     VkViSurfaceCreateInfoNN const *ptr() const { return reinterpret_cast<VkViSurfaceCreateInfoNN const *>(this); }
5010 };
5011 #endif // VK_USE_PLATFORM_VI_NN
5012 
5013 struct safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
5014     VkStructureType sType;
5015     void* pNext;
5016     VkBool32 textureCompressionASTC_HDR;
5017     safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* in_struct);
5018     safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& copy_src);
5019     safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& operator=(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& copy_src);
5020     safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT();
5021     ~safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT();
5022     void initialize(const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* in_struct);
5023     void initialize(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT5024     VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT5025     VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const *>(this); }
5026 };
5027 
5028 struct safe_VkImageViewASTCDecodeModeEXT {
5029     VkStructureType sType;
5030     const void* pNext;
5031     VkFormat decodeMode;
5032     safe_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT* in_struct);
5033     safe_VkImageViewASTCDecodeModeEXT(const safe_VkImageViewASTCDecodeModeEXT& copy_src);
5034     safe_VkImageViewASTCDecodeModeEXT& operator=(const safe_VkImageViewASTCDecodeModeEXT& copy_src);
5035     safe_VkImageViewASTCDecodeModeEXT();
5036     ~safe_VkImageViewASTCDecodeModeEXT();
5037     void initialize(const VkImageViewASTCDecodeModeEXT* in_struct);
5038     void initialize(const safe_VkImageViewASTCDecodeModeEXT* copy_src);
ptrsafe_VkImageViewASTCDecodeModeEXT5039     VkImageViewASTCDecodeModeEXT *ptr() { return reinterpret_cast<VkImageViewASTCDecodeModeEXT *>(this); }
ptrsafe_VkImageViewASTCDecodeModeEXT5040     VkImageViewASTCDecodeModeEXT const *ptr() const { return reinterpret_cast<VkImageViewASTCDecodeModeEXT const *>(this); }
5041 };
5042 
5043 struct safe_VkPhysicalDeviceASTCDecodeFeaturesEXT {
5044     VkStructureType sType;
5045     void* pNext;
5046     VkBool32 decodeModeSharedExponent;
5047     safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct);
5048     safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& copy_src);
5049     safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& operator=(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& copy_src);
5050     safe_VkPhysicalDeviceASTCDecodeFeaturesEXT();
5051     ~safe_VkPhysicalDeviceASTCDecodeFeaturesEXT();
5052     void initialize(const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct);
5053     void initialize(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceASTCDecodeFeaturesEXT5054     VkPhysicalDeviceASTCDecodeFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceASTCDecodeFeaturesEXT5055     VkPhysicalDeviceASTCDecodeFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT const *>(this); }
5056 };
5057 
5058 struct safe_VkConditionalRenderingBeginInfoEXT {
5059     VkStructureType sType;
5060     const void* pNext;
5061     VkBuffer buffer;
5062     VkDeviceSize offset;
5063     VkConditionalRenderingFlagsEXT flags;
5064     safe_VkConditionalRenderingBeginInfoEXT(const VkConditionalRenderingBeginInfoEXT* in_struct);
5065     safe_VkConditionalRenderingBeginInfoEXT(const safe_VkConditionalRenderingBeginInfoEXT& copy_src);
5066     safe_VkConditionalRenderingBeginInfoEXT& operator=(const safe_VkConditionalRenderingBeginInfoEXT& copy_src);
5067     safe_VkConditionalRenderingBeginInfoEXT();
5068     ~safe_VkConditionalRenderingBeginInfoEXT();
5069     void initialize(const VkConditionalRenderingBeginInfoEXT* in_struct);
5070     void initialize(const safe_VkConditionalRenderingBeginInfoEXT* copy_src);
ptrsafe_VkConditionalRenderingBeginInfoEXT5071     VkConditionalRenderingBeginInfoEXT *ptr() { return reinterpret_cast<VkConditionalRenderingBeginInfoEXT *>(this); }
ptrsafe_VkConditionalRenderingBeginInfoEXT5072     VkConditionalRenderingBeginInfoEXT const *ptr() const { return reinterpret_cast<VkConditionalRenderingBeginInfoEXT const *>(this); }
5073 };
5074 
5075 struct safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT {
5076     VkStructureType sType;
5077     void* pNext;
5078     VkBool32 conditionalRendering;
5079     VkBool32 inheritedConditionalRendering;
5080     safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct);
5081     safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& copy_src);
5082     safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& operator=(const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& copy_src);
5083     safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT();
5084     ~safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT();
5085     void initialize(const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct);
5086     void initialize(const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceConditionalRenderingFeaturesEXT5087     VkPhysicalDeviceConditionalRenderingFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceConditionalRenderingFeaturesEXT5088     VkPhysicalDeviceConditionalRenderingFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT const *>(this); }
5089 };
5090 
5091 struct safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT {
5092     VkStructureType sType;
5093     const void* pNext;
5094     VkBool32 conditionalRenderingEnable;
5095     safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct);
5096     safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& copy_src);
5097     safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& operator=(const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& copy_src);
5098     safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT();
5099     ~safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT();
5100     void initialize(const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct);
5101     void initialize(const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT* copy_src);
ptrsafe_VkCommandBufferInheritanceConditionalRenderingInfoEXT5102     VkCommandBufferInheritanceConditionalRenderingInfoEXT *ptr() { return reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT *>(this); }
ptrsafe_VkCommandBufferInheritanceConditionalRenderingInfoEXT5103     VkCommandBufferInheritanceConditionalRenderingInfoEXT const *ptr() const { return reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT const *>(this); }
5104 };
5105 
5106 struct safe_VkPipelineViewportWScalingStateCreateInfoNV {
5107     VkStructureType sType;
5108     const void* pNext;
5109     VkBool32 viewportWScalingEnable;
5110     uint32_t viewportCount;
5111     const VkViewportWScalingNV* pViewportWScalings;
5112     safe_VkPipelineViewportWScalingStateCreateInfoNV(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct);
5113     safe_VkPipelineViewportWScalingStateCreateInfoNV(const safe_VkPipelineViewportWScalingStateCreateInfoNV& copy_src);
5114     safe_VkPipelineViewportWScalingStateCreateInfoNV& operator=(const safe_VkPipelineViewportWScalingStateCreateInfoNV& copy_src);
5115     safe_VkPipelineViewportWScalingStateCreateInfoNV();
5116     ~safe_VkPipelineViewportWScalingStateCreateInfoNV();
5117     void initialize(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct);
5118     void initialize(const safe_VkPipelineViewportWScalingStateCreateInfoNV* copy_src);
ptrsafe_VkPipelineViewportWScalingStateCreateInfoNV5119     VkPipelineViewportWScalingStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV *>(this); }
ptrsafe_VkPipelineViewportWScalingStateCreateInfoNV5120     VkPipelineViewportWScalingStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV const *>(this); }
5121 };
5122 
5123 struct safe_VkSurfaceCapabilities2EXT {
5124     VkStructureType sType;
5125     void* pNext;
5126     uint32_t minImageCount;
5127     uint32_t maxImageCount;
5128     VkExtent2D currentExtent;
5129     VkExtent2D minImageExtent;
5130     VkExtent2D maxImageExtent;
5131     uint32_t maxImageArrayLayers;
5132     VkSurfaceTransformFlagsKHR supportedTransforms;
5133     VkSurfaceTransformFlagBitsKHR currentTransform;
5134     VkCompositeAlphaFlagsKHR supportedCompositeAlpha;
5135     VkImageUsageFlags supportedUsageFlags;
5136     VkSurfaceCounterFlagsEXT supportedSurfaceCounters;
5137     safe_VkSurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT* in_struct);
5138     safe_VkSurfaceCapabilities2EXT(const safe_VkSurfaceCapabilities2EXT& copy_src);
5139     safe_VkSurfaceCapabilities2EXT& operator=(const safe_VkSurfaceCapabilities2EXT& copy_src);
5140     safe_VkSurfaceCapabilities2EXT();
5141     ~safe_VkSurfaceCapabilities2EXT();
5142     void initialize(const VkSurfaceCapabilities2EXT* in_struct);
5143     void initialize(const safe_VkSurfaceCapabilities2EXT* copy_src);
ptrsafe_VkSurfaceCapabilities2EXT5144     VkSurfaceCapabilities2EXT *ptr() { return reinterpret_cast<VkSurfaceCapabilities2EXT *>(this); }
ptrsafe_VkSurfaceCapabilities2EXT5145     VkSurfaceCapabilities2EXT const *ptr() const { return reinterpret_cast<VkSurfaceCapabilities2EXT const *>(this); }
5146 };
5147 
5148 struct safe_VkDisplayPowerInfoEXT {
5149     VkStructureType sType;
5150     const void* pNext;
5151     VkDisplayPowerStateEXT powerState;
5152     safe_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT* in_struct);
5153     safe_VkDisplayPowerInfoEXT(const safe_VkDisplayPowerInfoEXT& copy_src);
5154     safe_VkDisplayPowerInfoEXT& operator=(const safe_VkDisplayPowerInfoEXT& copy_src);
5155     safe_VkDisplayPowerInfoEXT();
5156     ~safe_VkDisplayPowerInfoEXT();
5157     void initialize(const VkDisplayPowerInfoEXT* in_struct);
5158     void initialize(const safe_VkDisplayPowerInfoEXT* copy_src);
ptrsafe_VkDisplayPowerInfoEXT5159     VkDisplayPowerInfoEXT *ptr() { return reinterpret_cast<VkDisplayPowerInfoEXT *>(this); }
ptrsafe_VkDisplayPowerInfoEXT5160     VkDisplayPowerInfoEXT const *ptr() const { return reinterpret_cast<VkDisplayPowerInfoEXT const *>(this); }
5161 };
5162 
5163 struct safe_VkDeviceEventInfoEXT {
5164     VkStructureType sType;
5165     const void* pNext;
5166     VkDeviceEventTypeEXT deviceEvent;
5167     safe_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT* in_struct);
5168     safe_VkDeviceEventInfoEXT(const safe_VkDeviceEventInfoEXT& copy_src);
5169     safe_VkDeviceEventInfoEXT& operator=(const safe_VkDeviceEventInfoEXT& copy_src);
5170     safe_VkDeviceEventInfoEXT();
5171     ~safe_VkDeviceEventInfoEXT();
5172     void initialize(const VkDeviceEventInfoEXT* in_struct);
5173     void initialize(const safe_VkDeviceEventInfoEXT* copy_src);
ptrsafe_VkDeviceEventInfoEXT5174     VkDeviceEventInfoEXT *ptr() { return reinterpret_cast<VkDeviceEventInfoEXT *>(this); }
ptrsafe_VkDeviceEventInfoEXT5175     VkDeviceEventInfoEXT const *ptr() const { return reinterpret_cast<VkDeviceEventInfoEXT const *>(this); }
5176 };
5177 
5178 struct safe_VkDisplayEventInfoEXT {
5179     VkStructureType sType;
5180     const void* pNext;
5181     VkDisplayEventTypeEXT displayEvent;
5182     safe_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT* in_struct);
5183     safe_VkDisplayEventInfoEXT(const safe_VkDisplayEventInfoEXT& copy_src);
5184     safe_VkDisplayEventInfoEXT& operator=(const safe_VkDisplayEventInfoEXT& copy_src);
5185     safe_VkDisplayEventInfoEXT();
5186     ~safe_VkDisplayEventInfoEXT();
5187     void initialize(const VkDisplayEventInfoEXT* in_struct);
5188     void initialize(const safe_VkDisplayEventInfoEXT* copy_src);
ptrsafe_VkDisplayEventInfoEXT5189     VkDisplayEventInfoEXT *ptr() { return reinterpret_cast<VkDisplayEventInfoEXT *>(this); }
ptrsafe_VkDisplayEventInfoEXT5190     VkDisplayEventInfoEXT const *ptr() const { return reinterpret_cast<VkDisplayEventInfoEXT const *>(this); }
5191 };
5192 
5193 struct safe_VkSwapchainCounterCreateInfoEXT {
5194     VkStructureType sType;
5195     const void* pNext;
5196     VkSurfaceCounterFlagsEXT surfaceCounters;
5197     safe_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT* in_struct);
5198     safe_VkSwapchainCounterCreateInfoEXT(const safe_VkSwapchainCounterCreateInfoEXT& copy_src);
5199     safe_VkSwapchainCounterCreateInfoEXT& operator=(const safe_VkSwapchainCounterCreateInfoEXT& copy_src);
5200     safe_VkSwapchainCounterCreateInfoEXT();
5201     ~safe_VkSwapchainCounterCreateInfoEXT();
5202     void initialize(const VkSwapchainCounterCreateInfoEXT* in_struct);
5203     void initialize(const safe_VkSwapchainCounterCreateInfoEXT* copy_src);
ptrsafe_VkSwapchainCounterCreateInfoEXT5204     VkSwapchainCounterCreateInfoEXT *ptr() { return reinterpret_cast<VkSwapchainCounterCreateInfoEXT *>(this); }
ptrsafe_VkSwapchainCounterCreateInfoEXT5205     VkSwapchainCounterCreateInfoEXT const *ptr() const { return reinterpret_cast<VkSwapchainCounterCreateInfoEXT const *>(this); }
5206 };
5207 
5208 struct safe_VkPresentTimesInfoGOOGLE {
5209     VkStructureType sType;
5210     const void* pNext;
5211     uint32_t swapchainCount;
5212     const VkPresentTimeGOOGLE* pTimes;
5213     safe_VkPresentTimesInfoGOOGLE(const VkPresentTimesInfoGOOGLE* in_struct);
5214     safe_VkPresentTimesInfoGOOGLE(const safe_VkPresentTimesInfoGOOGLE& copy_src);
5215     safe_VkPresentTimesInfoGOOGLE& operator=(const safe_VkPresentTimesInfoGOOGLE& copy_src);
5216     safe_VkPresentTimesInfoGOOGLE();
5217     ~safe_VkPresentTimesInfoGOOGLE();
5218     void initialize(const VkPresentTimesInfoGOOGLE* in_struct);
5219     void initialize(const safe_VkPresentTimesInfoGOOGLE* copy_src);
ptrsafe_VkPresentTimesInfoGOOGLE5220     VkPresentTimesInfoGOOGLE *ptr() { return reinterpret_cast<VkPresentTimesInfoGOOGLE *>(this); }
ptrsafe_VkPresentTimesInfoGOOGLE5221     VkPresentTimesInfoGOOGLE const *ptr() const { return reinterpret_cast<VkPresentTimesInfoGOOGLE const *>(this); }
5222 };
5223 
5224 struct safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
5225     VkStructureType sType;
5226     void* pNext;
5227     VkBool32 perViewPositionAllComponents;
5228     safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct);
5229     safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& copy_src);
5230     safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& operator=(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& copy_src);
5231     safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX();
5232     ~safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX();
5233     void initialize(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct);
5234     void initialize(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* copy_src);
ptrsafe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX5235     VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *ptr() { return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>(this); }
ptrsafe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX5236     VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const *>(this); }
5237 };
5238 
5239 struct safe_VkPipelineViewportSwizzleStateCreateInfoNV {
5240     VkStructureType sType;
5241     const void* pNext;
5242     VkPipelineViewportSwizzleStateCreateFlagsNV flags;
5243     uint32_t viewportCount;
5244     const VkViewportSwizzleNV* pViewportSwizzles;
5245     safe_VkPipelineViewportSwizzleStateCreateInfoNV(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct);
5246     safe_VkPipelineViewportSwizzleStateCreateInfoNV(const safe_VkPipelineViewportSwizzleStateCreateInfoNV& copy_src);
5247     safe_VkPipelineViewportSwizzleStateCreateInfoNV& operator=(const safe_VkPipelineViewportSwizzleStateCreateInfoNV& copy_src);
5248     safe_VkPipelineViewportSwizzleStateCreateInfoNV();
5249     ~safe_VkPipelineViewportSwizzleStateCreateInfoNV();
5250     void initialize(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct);
5251     void initialize(const safe_VkPipelineViewportSwizzleStateCreateInfoNV* copy_src);
ptrsafe_VkPipelineViewportSwizzleStateCreateInfoNV5252     VkPipelineViewportSwizzleStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV *>(this); }
ptrsafe_VkPipelineViewportSwizzleStateCreateInfoNV5253     VkPipelineViewportSwizzleStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV const *>(this); }
5254 };
5255 
5256 struct safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT {
5257     VkStructureType sType;
5258     void* pNext;
5259     uint32_t maxDiscardRectangles;
5260     safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct);
5261     safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& copy_src);
5262     safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& operator=(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& copy_src);
5263     safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT();
5264     ~safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT();
5265     void initialize(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct);
5266     void initialize(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT* copy_src);
ptrsafe_VkPhysicalDeviceDiscardRectanglePropertiesEXT5267     VkPhysicalDeviceDiscardRectanglePropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT *>(this); }
ptrsafe_VkPhysicalDeviceDiscardRectanglePropertiesEXT5268     VkPhysicalDeviceDiscardRectanglePropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT const *>(this); }
5269 };
5270 
5271 struct safe_VkPipelineDiscardRectangleStateCreateInfoEXT {
5272     VkStructureType sType;
5273     const void* pNext;
5274     VkPipelineDiscardRectangleStateCreateFlagsEXT flags;
5275     VkDiscardRectangleModeEXT discardRectangleMode;
5276     uint32_t discardRectangleCount;
5277     const VkRect2D* pDiscardRectangles;
5278     safe_VkPipelineDiscardRectangleStateCreateInfoEXT(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct);
5279     safe_VkPipelineDiscardRectangleStateCreateInfoEXT(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT& copy_src);
5280     safe_VkPipelineDiscardRectangleStateCreateInfoEXT& operator=(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT& copy_src);
5281     safe_VkPipelineDiscardRectangleStateCreateInfoEXT();
5282     ~safe_VkPipelineDiscardRectangleStateCreateInfoEXT();
5283     void initialize(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct);
5284     void initialize(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT* copy_src);
ptrsafe_VkPipelineDiscardRectangleStateCreateInfoEXT5285     VkPipelineDiscardRectangleStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT *>(this); }
ptrsafe_VkPipelineDiscardRectangleStateCreateInfoEXT5286     VkPipelineDiscardRectangleStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT const *>(this); }
5287 };
5288 
5289 struct safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT {
5290     VkStructureType sType;
5291     void* pNext;
5292     float primitiveOverestimationSize;
5293     float maxExtraPrimitiveOverestimationSize;
5294     float extraPrimitiveOverestimationSizeGranularity;
5295     VkBool32 primitiveUnderestimation;
5296     VkBool32 conservativePointAndLineRasterization;
5297     VkBool32 degenerateTrianglesRasterized;
5298     VkBool32 degenerateLinesRasterized;
5299     VkBool32 fullyCoveredFragmentShaderInputVariable;
5300     VkBool32 conservativeRasterizationPostDepthCoverage;
5301     safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct);
5302     safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& copy_src);
5303     safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& operator=(const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& copy_src);
5304     safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT();
5305     ~safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT();
5306     void initialize(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct);
5307     void initialize(const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT* copy_src);
ptrsafe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT5308     VkPhysicalDeviceConservativeRasterizationPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>(this); }
ptrsafe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT5309     VkPhysicalDeviceConservativeRasterizationPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT const *>(this); }
5310 };
5311 
5312 struct safe_VkPipelineRasterizationConservativeStateCreateInfoEXT {
5313     VkStructureType sType;
5314     const void* pNext;
5315     VkPipelineRasterizationConservativeStateCreateFlagsEXT flags;
5316     VkConservativeRasterizationModeEXT conservativeRasterizationMode;
5317     float extraPrimitiveOverestimationSize;
5318     safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct);
5319     safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& copy_src);
5320     safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& operator=(const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& copy_src);
5321     safe_VkPipelineRasterizationConservativeStateCreateInfoEXT();
5322     ~safe_VkPipelineRasterizationConservativeStateCreateInfoEXT();
5323     void initialize(const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct);
5324     void initialize(const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT* copy_src);
ptrsafe_VkPipelineRasterizationConservativeStateCreateInfoEXT5325     VkPipelineRasterizationConservativeStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT *>(this); }
ptrsafe_VkPipelineRasterizationConservativeStateCreateInfoEXT5326     VkPipelineRasterizationConservativeStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT const *>(this); }
5327 };
5328 
5329 struct safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT {
5330     VkStructureType sType;
5331     void* pNext;
5332     VkBool32 depthClipEnable;
5333     safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct);
5334     safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& copy_src);
5335     safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& operator=(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& copy_src);
5336     safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT();
5337     ~safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT();
5338     void initialize(const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct);
5339     void initialize(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceDepthClipEnableFeaturesEXT5340     VkPhysicalDeviceDepthClipEnableFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceDepthClipEnableFeaturesEXT5341     VkPhysicalDeviceDepthClipEnableFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT const *>(this); }
5342 };
5343 
5344 struct safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT {
5345     VkStructureType sType;
5346     const void* pNext;
5347     VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags;
5348     VkBool32 depthClipEnable;
5349     safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct);
5350     safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& copy_src);
5351     safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& operator=(const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& copy_src);
5352     safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT();
5353     ~safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT();
5354     void initialize(const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct);
5355     void initialize(const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT* copy_src);
ptrsafe_VkPipelineRasterizationDepthClipStateCreateInfoEXT5356     VkPipelineRasterizationDepthClipStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT *>(this); }
ptrsafe_VkPipelineRasterizationDepthClipStateCreateInfoEXT5357     VkPipelineRasterizationDepthClipStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT const *>(this); }
5358 };
5359 
5360 struct safe_VkHdrMetadataEXT {
5361     VkStructureType sType;
5362     const void* pNext;
5363     VkXYColorEXT displayPrimaryRed;
5364     VkXYColorEXT displayPrimaryGreen;
5365     VkXYColorEXT displayPrimaryBlue;
5366     VkXYColorEXT whitePoint;
5367     float maxLuminance;
5368     float minLuminance;
5369     float maxContentLightLevel;
5370     float maxFrameAverageLightLevel;
5371     safe_VkHdrMetadataEXT(const VkHdrMetadataEXT* in_struct);
5372     safe_VkHdrMetadataEXT(const safe_VkHdrMetadataEXT& copy_src);
5373     safe_VkHdrMetadataEXT& operator=(const safe_VkHdrMetadataEXT& copy_src);
5374     safe_VkHdrMetadataEXT();
5375     ~safe_VkHdrMetadataEXT();
5376     void initialize(const VkHdrMetadataEXT* in_struct);
5377     void initialize(const safe_VkHdrMetadataEXT* copy_src);
ptrsafe_VkHdrMetadataEXT5378     VkHdrMetadataEXT *ptr() { return reinterpret_cast<VkHdrMetadataEXT *>(this); }
ptrsafe_VkHdrMetadataEXT5379     VkHdrMetadataEXT const *ptr() const { return reinterpret_cast<VkHdrMetadataEXT const *>(this); }
5380 };
5381 
5382 #ifdef VK_USE_PLATFORM_IOS_MVK
5383 struct safe_VkIOSSurfaceCreateInfoMVK {
5384     VkStructureType sType;
5385     const void* pNext;
5386     VkIOSSurfaceCreateFlagsMVK flags;
5387     const void* pView;
5388     safe_VkIOSSurfaceCreateInfoMVK(const VkIOSSurfaceCreateInfoMVK* in_struct);
5389     safe_VkIOSSurfaceCreateInfoMVK(const safe_VkIOSSurfaceCreateInfoMVK& copy_src);
5390     safe_VkIOSSurfaceCreateInfoMVK& operator=(const safe_VkIOSSurfaceCreateInfoMVK& copy_src);
5391     safe_VkIOSSurfaceCreateInfoMVK();
5392     ~safe_VkIOSSurfaceCreateInfoMVK();
5393     void initialize(const VkIOSSurfaceCreateInfoMVK* in_struct);
5394     void initialize(const safe_VkIOSSurfaceCreateInfoMVK* copy_src);
ptrsafe_VkIOSSurfaceCreateInfoMVK5395     VkIOSSurfaceCreateInfoMVK *ptr() { return reinterpret_cast<VkIOSSurfaceCreateInfoMVK *>(this); }
ptrsafe_VkIOSSurfaceCreateInfoMVK5396     VkIOSSurfaceCreateInfoMVK const *ptr() const { return reinterpret_cast<VkIOSSurfaceCreateInfoMVK const *>(this); }
5397 };
5398 #endif // VK_USE_PLATFORM_IOS_MVK
5399 
5400 #ifdef VK_USE_PLATFORM_MACOS_MVK
5401 struct safe_VkMacOSSurfaceCreateInfoMVK {
5402     VkStructureType sType;
5403     const void* pNext;
5404     VkMacOSSurfaceCreateFlagsMVK flags;
5405     const void* pView;
5406     safe_VkMacOSSurfaceCreateInfoMVK(const VkMacOSSurfaceCreateInfoMVK* in_struct);
5407     safe_VkMacOSSurfaceCreateInfoMVK(const safe_VkMacOSSurfaceCreateInfoMVK& copy_src);
5408     safe_VkMacOSSurfaceCreateInfoMVK& operator=(const safe_VkMacOSSurfaceCreateInfoMVK& copy_src);
5409     safe_VkMacOSSurfaceCreateInfoMVK();
5410     ~safe_VkMacOSSurfaceCreateInfoMVK();
5411     void initialize(const VkMacOSSurfaceCreateInfoMVK* in_struct);
5412     void initialize(const safe_VkMacOSSurfaceCreateInfoMVK* copy_src);
ptrsafe_VkMacOSSurfaceCreateInfoMVK5413     VkMacOSSurfaceCreateInfoMVK *ptr() { return reinterpret_cast<VkMacOSSurfaceCreateInfoMVK *>(this); }
ptrsafe_VkMacOSSurfaceCreateInfoMVK5414     VkMacOSSurfaceCreateInfoMVK const *ptr() const { return reinterpret_cast<VkMacOSSurfaceCreateInfoMVK const *>(this); }
5415 };
5416 #endif // VK_USE_PLATFORM_MACOS_MVK
5417 
5418 struct safe_VkDebugUtilsLabelEXT {
5419     VkStructureType sType;
5420     const void* pNext;
5421     const char* pLabelName;
5422     float color[4];
5423     safe_VkDebugUtilsLabelEXT(const VkDebugUtilsLabelEXT* in_struct);
5424     safe_VkDebugUtilsLabelEXT(const safe_VkDebugUtilsLabelEXT& copy_src);
5425     safe_VkDebugUtilsLabelEXT& operator=(const safe_VkDebugUtilsLabelEXT& copy_src);
5426     safe_VkDebugUtilsLabelEXT();
5427     ~safe_VkDebugUtilsLabelEXT();
5428     void initialize(const VkDebugUtilsLabelEXT* in_struct);
5429     void initialize(const safe_VkDebugUtilsLabelEXT* copy_src);
ptrsafe_VkDebugUtilsLabelEXT5430     VkDebugUtilsLabelEXT *ptr() { return reinterpret_cast<VkDebugUtilsLabelEXT *>(this); }
ptrsafe_VkDebugUtilsLabelEXT5431     VkDebugUtilsLabelEXT const *ptr() const { return reinterpret_cast<VkDebugUtilsLabelEXT const *>(this); }
5432 };
5433 
5434 struct safe_VkDebugUtilsObjectNameInfoEXT {
5435     VkStructureType sType;
5436     const void* pNext;
5437     VkObjectType objectType;
5438     uint64_t objectHandle;
5439     const char* pObjectName;
5440     safe_VkDebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT* in_struct);
5441     safe_VkDebugUtilsObjectNameInfoEXT(const safe_VkDebugUtilsObjectNameInfoEXT& copy_src);
5442     safe_VkDebugUtilsObjectNameInfoEXT& operator=(const safe_VkDebugUtilsObjectNameInfoEXT& copy_src);
5443     safe_VkDebugUtilsObjectNameInfoEXT();
5444     ~safe_VkDebugUtilsObjectNameInfoEXT();
5445     void initialize(const VkDebugUtilsObjectNameInfoEXT* in_struct);
5446     void initialize(const safe_VkDebugUtilsObjectNameInfoEXT* copy_src);
ptrsafe_VkDebugUtilsObjectNameInfoEXT5447     VkDebugUtilsObjectNameInfoEXT *ptr() { return reinterpret_cast<VkDebugUtilsObjectNameInfoEXT *>(this); }
ptrsafe_VkDebugUtilsObjectNameInfoEXT5448     VkDebugUtilsObjectNameInfoEXT const *ptr() const { return reinterpret_cast<VkDebugUtilsObjectNameInfoEXT const *>(this); }
5449 };
5450 
5451 struct safe_VkDebugUtilsMessengerCallbackDataEXT {
5452     VkStructureType sType;
5453     const void* pNext;
5454     VkDebugUtilsMessengerCallbackDataFlagsEXT flags;
5455     const char* pMessageIdName;
5456     int32_t messageIdNumber;
5457     const char* pMessage;
5458     uint32_t queueLabelCount;
5459     safe_VkDebugUtilsLabelEXT* pQueueLabels;
5460     uint32_t cmdBufLabelCount;
5461     safe_VkDebugUtilsLabelEXT* pCmdBufLabels;
5462     uint32_t objectCount;
5463     safe_VkDebugUtilsObjectNameInfoEXT* pObjects;
5464     safe_VkDebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessengerCallbackDataEXT* in_struct);
5465     safe_VkDebugUtilsMessengerCallbackDataEXT(const safe_VkDebugUtilsMessengerCallbackDataEXT& copy_src);
5466     safe_VkDebugUtilsMessengerCallbackDataEXT& operator=(const safe_VkDebugUtilsMessengerCallbackDataEXT& copy_src);
5467     safe_VkDebugUtilsMessengerCallbackDataEXT();
5468     ~safe_VkDebugUtilsMessengerCallbackDataEXT();
5469     void initialize(const VkDebugUtilsMessengerCallbackDataEXT* in_struct);
5470     void initialize(const safe_VkDebugUtilsMessengerCallbackDataEXT* copy_src);
ptrsafe_VkDebugUtilsMessengerCallbackDataEXT5471     VkDebugUtilsMessengerCallbackDataEXT *ptr() { return reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT *>(this); }
ptrsafe_VkDebugUtilsMessengerCallbackDataEXT5472     VkDebugUtilsMessengerCallbackDataEXT const *ptr() const { return reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT const *>(this); }
5473 };
5474 
5475 struct safe_VkDebugUtilsMessengerCreateInfoEXT {
5476     VkStructureType sType;
5477     const void* pNext;
5478     VkDebugUtilsMessengerCreateFlagsEXT flags;
5479     VkDebugUtilsMessageSeverityFlagsEXT messageSeverity;
5480     VkDebugUtilsMessageTypeFlagsEXT messageType;
5481     PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback;
5482     void* pUserData;
5483     safe_VkDebugUtilsMessengerCreateInfoEXT(const VkDebugUtilsMessengerCreateInfoEXT* in_struct);
5484     safe_VkDebugUtilsMessengerCreateInfoEXT(const safe_VkDebugUtilsMessengerCreateInfoEXT& copy_src);
5485     safe_VkDebugUtilsMessengerCreateInfoEXT& operator=(const safe_VkDebugUtilsMessengerCreateInfoEXT& copy_src);
5486     safe_VkDebugUtilsMessengerCreateInfoEXT();
5487     ~safe_VkDebugUtilsMessengerCreateInfoEXT();
5488     void initialize(const VkDebugUtilsMessengerCreateInfoEXT* in_struct);
5489     void initialize(const safe_VkDebugUtilsMessengerCreateInfoEXT* copy_src);
ptrsafe_VkDebugUtilsMessengerCreateInfoEXT5490     VkDebugUtilsMessengerCreateInfoEXT *ptr() { return reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT *>(this); }
ptrsafe_VkDebugUtilsMessengerCreateInfoEXT5491     VkDebugUtilsMessengerCreateInfoEXT const *ptr() const { return reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT const *>(this); }
5492 };
5493 
5494 struct safe_VkDebugUtilsObjectTagInfoEXT {
5495     VkStructureType sType;
5496     const void* pNext;
5497     VkObjectType objectType;
5498     uint64_t objectHandle;
5499     uint64_t tagName;
5500     size_t tagSize;
5501     const void* pTag;
5502     safe_VkDebugUtilsObjectTagInfoEXT(const VkDebugUtilsObjectTagInfoEXT* in_struct);
5503     safe_VkDebugUtilsObjectTagInfoEXT(const safe_VkDebugUtilsObjectTagInfoEXT& copy_src);
5504     safe_VkDebugUtilsObjectTagInfoEXT& operator=(const safe_VkDebugUtilsObjectTagInfoEXT& copy_src);
5505     safe_VkDebugUtilsObjectTagInfoEXT();
5506     ~safe_VkDebugUtilsObjectTagInfoEXT();
5507     void initialize(const VkDebugUtilsObjectTagInfoEXT* in_struct);
5508     void initialize(const safe_VkDebugUtilsObjectTagInfoEXT* copy_src);
ptrsafe_VkDebugUtilsObjectTagInfoEXT5509     VkDebugUtilsObjectTagInfoEXT *ptr() { return reinterpret_cast<VkDebugUtilsObjectTagInfoEXT *>(this); }
ptrsafe_VkDebugUtilsObjectTagInfoEXT5510     VkDebugUtilsObjectTagInfoEXT const *ptr() const { return reinterpret_cast<VkDebugUtilsObjectTagInfoEXT const *>(this); }
5511 };
5512 
5513 #ifdef VK_USE_PLATFORM_ANDROID_KHR
5514 struct safe_VkAndroidHardwareBufferUsageANDROID {
5515     VkStructureType sType;
5516     void* pNext;
5517     uint64_t androidHardwareBufferUsage;
5518     safe_VkAndroidHardwareBufferUsageANDROID(const VkAndroidHardwareBufferUsageANDROID* in_struct);
5519     safe_VkAndroidHardwareBufferUsageANDROID(const safe_VkAndroidHardwareBufferUsageANDROID& copy_src);
5520     safe_VkAndroidHardwareBufferUsageANDROID& operator=(const safe_VkAndroidHardwareBufferUsageANDROID& copy_src);
5521     safe_VkAndroidHardwareBufferUsageANDROID();
5522     ~safe_VkAndroidHardwareBufferUsageANDROID();
5523     void initialize(const VkAndroidHardwareBufferUsageANDROID* in_struct);
5524     void initialize(const safe_VkAndroidHardwareBufferUsageANDROID* copy_src);
ptrsafe_VkAndroidHardwareBufferUsageANDROID5525     VkAndroidHardwareBufferUsageANDROID *ptr() { return reinterpret_cast<VkAndroidHardwareBufferUsageANDROID *>(this); }
ptrsafe_VkAndroidHardwareBufferUsageANDROID5526     VkAndroidHardwareBufferUsageANDROID const *ptr() const { return reinterpret_cast<VkAndroidHardwareBufferUsageANDROID const *>(this); }
5527 };
5528 #endif // VK_USE_PLATFORM_ANDROID_KHR
5529 
5530 #ifdef VK_USE_PLATFORM_ANDROID_KHR
5531 struct safe_VkAndroidHardwareBufferPropertiesANDROID {
5532     VkStructureType sType;
5533     void* pNext;
5534     VkDeviceSize allocationSize;
5535     uint32_t memoryTypeBits;
5536     safe_VkAndroidHardwareBufferPropertiesANDROID(const VkAndroidHardwareBufferPropertiesANDROID* in_struct);
5537     safe_VkAndroidHardwareBufferPropertiesANDROID(const safe_VkAndroidHardwareBufferPropertiesANDROID& copy_src);
5538     safe_VkAndroidHardwareBufferPropertiesANDROID& operator=(const safe_VkAndroidHardwareBufferPropertiesANDROID& copy_src);
5539     safe_VkAndroidHardwareBufferPropertiesANDROID();
5540     ~safe_VkAndroidHardwareBufferPropertiesANDROID();
5541     void initialize(const VkAndroidHardwareBufferPropertiesANDROID* in_struct);
5542     void initialize(const safe_VkAndroidHardwareBufferPropertiesANDROID* copy_src);
ptrsafe_VkAndroidHardwareBufferPropertiesANDROID5543     VkAndroidHardwareBufferPropertiesANDROID *ptr() { return reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>(this); }
ptrsafe_VkAndroidHardwareBufferPropertiesANDROID5544     VkAndroidHardwareBufferPropertiesANDROID const *ptr() const { return reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID const *>(this); }
5545 };
5546 #endif // VK_USE_PLATFORM_ANDROID_KHR
5547 
5548 #ifdef VK_USE_PLATFORM_ANDROID_KHR
5549 struct safe_VkAndroidHardwareBufferFormatPropertiesANDROID {
5550     VkStructureType sType;
5551     void* pNext;
5552     VkFormat format;
5553     uint64_t externalFormat;
5554     VkFormatFeatureFlags formatFeatures;
5555     VkComponentMapping samplerYcbcrConversionComponents;
5556     VkSamplerYcbcrModelConversion suggestedYcbcrModel;
5557     VkSamplerYcbcrRange suggestedYcbcrRange;
5558     VkChromaLocation suggestedXChromaOffset;
5559     VkChromaLocation suggestedYChromaOffset;
5560     safe_VkAndroidHardwareBufferFormatPropertiesANDROID(const VkAndroidHardwareBufferFormatPropertiesANDROID* in_struct);
5561     safe_VkAndroidHardwareBufferFormatPropertiesANDROID(const safe_VkAndroidHardwareBufferFormatPropertiesANDROID& copy_src);
5562     safe_VkAndroidHardwareBufferFormatPropertiesANDROID& operator=(const safe_VkAndroidHardwareBufferFormatPropertiesANDROID& copy_src);
5563     safe_VkAndroidHardwareBufferFormatPropertiesANDROID();
5564     ~safe_VkAndroidHardwareBufferFormatPropertiesANDROID();
5565     void initialize(const VkAndroidHardwareBufferFormatPropertiesANDROID* in_struct);
5566     void initialize(const safe_VkAndroidHardwareBufferFormatPropertiesANDROID* copy_src);
ptrsafe_VkAndroidHardwareBufferFormatPropertiesANDROID5567     VkAndroidHardwareBufferFormatPropertiesANDROID *ptr() { return reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID *>(this); }
ptrsafe_VkAndroidHardwareBufferFormatPropertiesANDROID5568     VkAndroidHardwareBufferFormatPropertiesANDROID const *ptr() const { return reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID const *>(this); }
5569 };
5570 #endif // VK_USE_PLATFORM_ANDROID_KHR
5571 
5572 #ifdef VK_USE_PLATFORM_ANDROID_KHR
5573 struct safe_VkImportAndroidHardwareBufferInfoANDROID {
5574     VkStructureType sType;
5575     const void* pNext;
5576     struct AHardwareBuffer* buffer;
5577     safe_VkImportAndroidHardwareBufferInfoANDROID(const VkImportAndroidHardwareBufferInfoANDROID* in_struct);
5578     safe_VkImportAndroidHardwareBufferInfoANDROID(const safe_VkImportAndroidHardwareBufferInfoANDROID& copy_src);
5579     safe_VkImportAndroidHardwareBufferInfoANDROID& operator=(const safe_VkImportAndroidHardwareBufferInfoANDROID& copy_src);
5580     safe_VkImportAndroidHardwareBufferInfoANDROID();
5581     ~safe_VkImportAndroidHardwareBufferInfoANDROID();
5582     void initialize(const VkImportAndroidHardwareBufferInfoANDROID* in_struct);
5583     void initialize(const safe_VkImportAndroidHardwareBufferInfoANDROID* copy_src);
ptrsafe_VkImportAndroidHardwareBufferInfoANDROID5584     VkImportAndroidHardwareBufferInfoANDROID *ptr() { return reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID *>(this); }
ptrsafe_VkImportAndroidHardwareBufferInfoANDROID5585     VkImportAndroidHardwareBufferInfoANDROID const *ptr() const { return reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID const *>(this); }
5586 };
5587 #endif // VK_USE_PLATFORM_ANDROID_KHR
5588 
5589 #ifdef VK_USE_PLATFORM_ANDROID_KHR
5590 struct safe_VkMemoryGetAndroidHardwareBufferInfoANDROID {
5591     VkStructureType sType;
5592     const void* pNext;
5593     VkDeviceMemory memory;
5594     safe_VkMemoryGetAndroidHardwareBufferInfoANDROID(const VkMemoryGetAndroidHardwareBufferInfoANDROID* in_struct);
5595     safe_VkMemoryGetAndroidHardwareBufferInfoANDROID(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& copy_src);
5596     safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& operator=(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& copy_src);
5597     safe_VkMemoryGetAndroidHardwareBufferInfoANDROID();
5598     ~safe_VkMemoryGetAndroidHardwareBufferInfoANDROID();
5599     void initialize(const VkMemoryGetAndroidHardwareBufferInfoANDROID* in_struct);
5600     void initialize(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID* copy_src);
ptrsafe_VkMemoryGetAndroidHardwareBufferInfoANDROID5601     VkMemoryGetAndroidHardwareBufferInfoANDROID *ptr() { return reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID *>(this); }
ptrsafe_VkMemoryGetAndroidHardwareBufferInfoANDROID5602     VkMemoryGetAndroidHardwareBufferInfoANDROID const *ptr() const { return reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID const *>(this); }
5603 };
5604 #endif // VK_USE_PLATFORM_ANDROID_KHR
5605 
5606 #ifdef VK_USE_PLATFORM_ANDROID_KHR
5607 struct safe_VkExternalFormatANDROID {
5608     VkStructureType sType;
5609     void* pNext;
5610     uint64_t externalFormat;
5611     safe_VkExternalFormatANDROID(const VkExternalFormatANDROID* in_struct);
5612     safe_VkExternalFormatANDROID(const safe_VkExternalFormatANDROID& copy_src);
5613     safe_VkExternalFormatANDROID& operator=(const safe_VkExternalFormatANDROID& copy_src);
5614     safe_VkExternalFormatANDROID();
5615     ~safe_VkExternalFormatANDROID();
5616     void initialize(const VkExternalFormatANDROID* in_struct);
5617     void initialize(const safe_VkExternalFormatANDROID* copy_src);
ptrsafe_VkExternalFormatANDROID5618     VkExternalFormatANDROID *ptr() { return reinterpret_cast<VkExternalFormatANDROID *>(this); }
ptrsafe_VkExternalFormatANDROID5619     VkExternalFormatANDROID const *ptr() const { return reinterpret_cast<VkExternalFormatANDROID const *>(this); }
5620 };
5621 #endif // VK_USE_PLATFORM_ANDROID_KHR
5622 
5623 struct safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT {
5624     VkStructureType sType;
5625     void* pNext;
5626     VkBool32 inlineUniformBlock;
5627     VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
5628     safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* in_struct);
5629     safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(const safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT& copy_src);
5630     safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT& operator=(const safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT& copy_src);
5631     safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT();
5632     ~safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT();
5633     void initialize(const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* in_struct);
5634     void initialize(const safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT5635     VkPhysicalDeviceInlineUniformBlockFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT5636     VkPhysicalDeviceInlineUniformBlockFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT const *>(this); }
5637 };
5638 
5639 struct safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT {
5640     VkStructureType sType;
5641     void* pNext;
5642     uint32_t maxInlineUniformBlockSize;
5643     uint32_t maxPerStageDescriptorInlineUniformBlocks;
5644     uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
5645     uint32_t maxDescriptorSetInlineUniformBlocks;
5646     uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
5647     safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* in_struct);
5648     safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(const safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT& copy_src);
5649     safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT& operator=(const safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT& copy_src);
5650     safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT();
5651     ~safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT();
5652     void initialize(const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* in_struct);
5653     void initialize(const safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT* copy_src);
ptrsafe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT5654     VkPhysicalDeviceInlineUniformBlockPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT *>(this); }
ptrsafe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT5655     VkPhysicalDeviceInlineUniformBlockPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT const *>(this); }
5656 };
5657 
5658 struct safe_VkWriteDescriptorSetInlineUniformBlockEXT {
5659     VkStructureType sType;
5660     const void* pNext;
5661     uint32_t dataSize;
5662     const void* pData;
5663     safe_VkWriteDescriptorSetInlineUniformBlockEXT(const VkWriteDescriptorSetInlineUniformBlockEXT* in_struct);
5664     safe_VkWriteDescriptorSetInlineUniformBlockEXT(const safe_VkWriteDescriptorSetInlineUniformBlockEXT& copy_src);
5665     safe_VkWriteDescriptorSetInlineUniformBlockEXT& operator=(const safe_VkWriteDescriptorSetInlineUniformBlockEXT& copy_src);
5666     safe_VkWriteDescriptorSetInlineUniformBlockEXT();
5667     ~safe_VkWriteDescriptorSetInlineUniformBlockEXT();
5668     void initialize(const VkWriteDescriptorSetInlineUniformBlockEXT* in_struct);
5669     void initialize(const safe_VkWriteDescriptorSetInlineUniformBlockEXT* copy_src);
ptrsafe_VkWriteDescriptorSetInlineUniformBlockEXT5670     VkWriteDescriptorSetInlineUniformBlockEXT *ptr() { return reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT *>(this); }
ptrsafe_VkWriteDescriptorSetInlineUniformBlockEXT5671     VkWriteDescriptorSetInlineUniformBlockEXT const *ptr() const { return reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT const *>(this); }
5672 };
5673 
5674 struct safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT {
5675     VkStructureType sType;
5676     const void* pNext;
5677     uint32_t maxInlineUniformBlockBindings;
5678     safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* in_struct);
5679     safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(const safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT& copy_src);
5680     safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT& operator=(const safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT& copy_src);
5681     safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT();
5682     ~safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT();
5683     void initialize(const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* in_struct);
5684     void initialize(const safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT* copy_src);
ptrsafe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT5685     VkDescriptorPoolInlineUniformBlockCreateInfoEXT *ptr() { return reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT *>(this); }
ptrsafe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT5686     VkDescriptorPoolInlineUniformBlockCreateInfoEXT const *ptr() const { return reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT const *>(this); }
5687 };
5688 
5689 struct safe_VkSampleLocationsInfoEXT {
5690     VkStructureType sType;
5691     const void* pNext;
5692     VkSampleCountFlagBits sampleLocationsPerPixel;
5693     VkExtent2D sampleLocationGridSize;
5694     uint32_t sampleLocationsCount;
5695     const VkSampleLocationEXT* pSampleLocations;
5696     safe_VkSampleLocationsInfoEXT(const VkSampleLocationsInfoEXT* in_struct);
5697     safe_VkSampleLocationsInfoEXT(const safe_VkSampleLocationsInfoEXT& copy_src);
5698     safe_VkSampleLocationsInfoEXT& operator=(const safe_VkSampleLocationsInfoEXT& copy_src);
5699     safe_VkSampleLocationsInfoEXT();
5700     ~safe_VkSampleLocationsInfoEXT();
5701     void initialize(const VkSampleLocationsInfoEXT* in_struct);
5702     void initialize(const safe_VkSampleLocationsInfoEXT* copy_src);
ptrsafe_VkSampleLocationsInfoEXT5703     VkSampleLocationsInfoEXT *ptr() { return reinterpret_cast<VkSampleLocationsInfoEXT *>(this); }
ptrsafe_VkSampleLocationsInfoEXT5704     VkSampleLocationsInfoEXT const *ptr() const { return reinterpret_cast<VkSampleLocationsInfoEXT const *>(this); }
5705 };
5706 
5707 struct safe_VkRenderPassSampleLocationsBeginInfoEXT {
5708     VkStructureType sType;
5709     const void* pNext;
5710     uint32_t attachmentInitialSampleLocationsCount;
5711     const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations;
5712     uint32_t postSubpassSampleLocationsCount;
5713     const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations;
5714     safe_VkRenderPassSampleLocationsBeginInfoEXT(const VkRenderPassSampleLocationsBeginInfoEXT* in_struct);
5715     safe_VkRenderPassSampleLocationsBeginInfoEXT(const safe_VkRenderPassSampleLocationsBeginInfoEXT& copy_src);
5716     safe_VkRenderPassSampleLocationsBeginInfoEXT& operator=(const safe_VkRenderPassSampleLocationsBeginInfoEXT& copy_src);
5717     safe_VkRenderPassSampleLocationsBeginInfoEXT();
5718     ~safe_VkRenderPassSampleLocationsBeginInfoEXT();
5719     void initialize(const VkRenderPassSampleLocationsBeginInfoEXT* in_struct);
5720     void initialize(const safe_VkRenderPassSampleLocationsBeginInfoEXT* copy_src);
ptrsafe_VkRenderPassSampleLocationsBeginInfoEXT5721     VkRenderPassSampleLocationsBeginInfoEXT *ptr() { return reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT *>(this); }
ptrsafe_VkRenderPassSampleLocationsBeginInfoEXT5722     VkRenderPassSampleLocationsBeginInfoEXT const *ptr() const { return reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT const *>(this); }
5723 };
5724 
5725 struct safe_VkPipelineSampleLocationsStateCreateInfoEXT {
5726     VkStructureType sType;
5727     const void* pNext;
5728     VkBool32 sampleLocationsEnable;
5729     safe_VkSampleLocationsInfoEXT sampleLocationsInfo;
5730     safe_VkPipelineSampleLocationsStateCreateInfoEXT(const VkPipelineSampleLocationsStateCreateInfoEXT* in_struct);
5731     safe_VkPipelineSampleLocationsStateCreateInfoEXT(const safe_VkPipelineSampleLocationsStateCreateInfoEXT& copy_src);
5732     safe_VkPipelineSampleLocationsStateCreateInfoEXT& operator=(const safe_VkPipelineSampleLocationsStateCreateInfoEXT& copy_src);
5733     safe_VkPipelineSampleLocationsStateCreateInfoEXT();
5734     ~safe_VkPipelineSampleLocationsStateCreateInfoEXT();
5735     void initialize(const VkPipelineSampleLocationsStateCreateInfoEXT* in_struct);
5736     void initialize(const safe_VkPipelineSampleLocationsStateCreateInfoEXT* copy_src);
ptrsafe_VkPipelineSampleLocationsStateCreateInfoEXT5737     VkPipelineSampleLocationsStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT *>(this); }
ptrsafe_VkPipelineSampleLocationsStateCreateInfoEXT5738     VkPipelineSampleLocationsStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT const *>(this); }
5739 };
5740 
5741 struct safe_VkPhysicalDeviceSampleLocationsPropertiesEXT {
5742     VkStructureType sType;
5743     void* pNext;
5744     VkSampleCountFlags sampleLocationSampleCounts;
5745     VkExtent2D maxSampleLocationGridSize;
5746     float sampleLocationCoordinateRange[2];
5747     uint32_t sampleLocationSubPixelBits;
5748     VkBool32 variableSampleLocations;
5749     safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(const VkPhysicalDeviceSampleLocationsPropertiesEXT* in_struct);
5750     safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& copy_src);
5751     safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& operator=(const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& copy_src);
5752     safe_VkPhysicalDeviceSampleLocationsPropertiesEXT();
5753     ~safe_VkPhysicalDeviceSampleLocationsPropertiesEXT();
5754     void initialize(const VkPhysicalDeviceSampleLocationsPropertiesEXT* in_struct);
5755     void initialize(const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT* copy_src);
ptrsafe_VkPhysicalDeviceSampleLocationsPropertiesEXT5756     VkPhysicalDeviceSampleLocationsPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT *>(this); }
ptrsafe_VkPhysicalDeviceSampleLocationsPropertiesEXT5757     VkPhysicalDeviceSampleLocationsPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT const *>(this); }
5758 };
5759 
5760 struct safe_VkMultisamplePropertiesEXT {
5761     VkStructureType sType;
5762     void* pNext;
5763     VkExtent2D maxSampleLocationGridSize;
5764     safe_VkMultisamplePropertiesEXT(const VkMultisamplePropertiesEXT* in_struct);
5765     safe_VkMultisamplePropertiesEXT(const safe_VkMultisamplePropertiesEXT& copy_src);
5766     safe_VkMultisamplePropertiesEXT& operator=(const safe_VkMultisamplePropertiesEXT& copy_src);
5767     safe_VkMultisamplePropertiesEXT();
5768     ~safe_VkMultisamplePropertiesEXT();
5769     void initialize(const VkMultisamplePropertiesEXT* in_struct);
5770     void initialize(const safe_VkMultisamplePropertiesEXT* copy_src);
ptrsafe_VkMultisamplePropertiesEXT5771     VkMultisamplePropertiesEXT *ptr() { return reinterpret_cast<VkMultisamplePropertiesEXT *>(this); }
ptrsafe_VkMultisamplePropertiesEXT5772     VkMultisamplePropertiesEXT const *ptr() const { return reinterpret_cast<VkMultisamplePropertiesEXT const *>(this); }
5773 };
5774 
5775 struct safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
5776     VkStructureType sType;
5777     void* pNext;
5778     VkBool32 advancedBlendCoherentOperations;
5779     safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct);
5780     safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& copy_src);
5781     safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& copy_src);
5782     safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT();
5783     ~safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT();
5784     void initialize(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct);
5785     void initialize(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT5786     VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT5787     VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const *>(this); }
5788 };
5789 
5790 struct safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
5791     VkStructureType sType;
5792     void* pNext;
5793     uint32_t advancedBlendMaxColorAttachments;
5794     VkBool32 advancedBlendIndependentBlend;
5795     VkBool32 advancedBlendNonPremultipliedSrcColor;
5796     VkBool32 advancedBlendNonPremultipliedDstColor;
5797     VkBool32 advancedBlendCorrelatedOverlap;
5798     VkBool32 advancedBlendAllOperations;
5799     safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct);
5800     safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& copy_src);
5801     safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& operator=(const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& copy_src);
5802     safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT();
5803     ~safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT();
5804     void initialize(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct);
5805     void initialize(const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* copy_src);
ptrsafe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT5806     VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>(this); }
ptrsafe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT5807     VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const *>(this); }
5808 };
5809 
5810 struct safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT {
5811     VkStructureType sType;
5812     const void* pNext;
5813     VkBool32 srcPremultiplied;
5814     VkBool32 dstPremultiplied;
5815     VkBlendOverlapEXT blendOverlap;
5816     safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct);
5817     safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& copy_src);
5818     safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& operator=(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& copy_src);
5819     safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT();
5820     ~safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT();
5821     void initialize(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct);
5822     void initialize(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT* copy_src);
ptrsafe_VkPipelineColorBlendAdvancedStateCreateInfoEXT5823     VkPipelineColorBlendAdvancedStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT *>(this); }
ptrsafe_VkPipelineColorBlendAdvancedStateCreateInfoEXT5824     VkPipelineColorBlendAdvancedStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT const *>(this); }
5825 };
5826 
5827 struct safe_VkPipelineCoverageToColorStateCreateInfoNV {
5828     VkStructureType sType;
5829     const void* pNext;
5830     VkPipelineCoverageToColorStateCreateFlagsNV flags;
5831     VkBool32 coverageToColorEnable;
5832     uint32_t coverageToColorLocation;
5833     safe_VkPipelineCoverageToColorStateCreateInfoNV(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct);
5834     safe_VkPipelineCoverageToColorStateCreateInfoNV(const safe_VkPipelineCoverageToColorStateCreateInfoNV& copy_src);
5835     safe_VkPipelineCoverageToColorStateCreateInfoNV& operator=(const safe_VkPipelineCoverageToColorStateCreateInfoNV& copy_src);
5836     safe_VkPipelineCoverageToColorStateCreateInfoNV();
5837     ~safe_VkPipelineCoverageToColorStateCreateInfoNV();
5838     void initialize(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct);
5839     void initialize(const safe_VkPipelineCoverageToColorStateCreateInfoNV* copy_src);
ptrsafe_VkPipelineCoverageToColorStateCreateInfoNV5840     VkPipelineCoverageToColorStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV *>(this); }
ptrsafe_VkPipelineCoverageToColorStateCreateInfoNV5841     VkPipelineCoverageToColorStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV const *>(this); }
5842 };
5843 
5844 struct safe_VkPipelineCoverageModulationStateCreateInfoNV {
5845     VkStructureType sType;
5846     const void* pNext;
5847     VkPipelineCoverageModulationStateCreateFlagsNV flags;
5848     VkCoverageModulationModeNV coverageModulationMode;
5849     VkBool32 coverageModulationTableEnable;
5850     uint32_t coverageModulationTableCount;
5851     const float* pCoverageModulationTable;
5852     safe_VkPipelineCoverageModulationStateCreateInfoNV(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct);
5853     safe_VkPipelineCoverageModulationStateCreateInfoNV(const safe_VkPipelineCoverageModulationStateCreateInfoNV& copy_src);
5854     safe_VkPipelineCoverageModulationStateCreateInfoNV& operator=(const safe_VkPipelineCoverageModulationStateCreateInfoNV& copy_src);
5855     safe_VkPipelineCoverageModulationStateCreateInfoNV();
5856     ~safe_VkPipelineCoverageModulationStateCreateInfoNV();
5857     void initialize(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct);
5858     void initialize(const safe_VkPipelineCoverageModulationStateCreateInfoNV* copy_src);
ptrsafe_VkPipelineCoverageModulationStateCreateInfoNV5859     VkPipelineCoverageModulationStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV *>(this); }
ptrsafe_VkPipelineCoverageModulationStateCreateInfoNV5860     VkPipelineCoverageModulationStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV const *>(this); }
5861 };
5862 
5863 struct safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV {
5864     VkStructureType sType;
5865     void* pNext;
5866     uint32_t shaderSMCount;
5867     uint32_t shaderWarpsPerSM;
5868     safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* in_struct);
5869     safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& copy_src);
5870     safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& operator=(const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& copy_src);
5871     safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV();
5872     ~safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV();
5873     void initialize(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* in_struct);
5874     void initialize(const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* copy_src);
ptrsafe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV5875     VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *>(this); }
ptrsafe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV5876     VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const *>(this); }
5877 };
5878 
5879 struct safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV {
5880     VkStructureType sType;
5881     void* pNext;
5882     VkBool32 shaderSMBuiltins;
5883     safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* in_struct);
5884     safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& copy_src);
5885     safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& operator=(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& copy_src);
5886     safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV();
5887     ~safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV();
5888     void initialize(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* in_struct);
5889     void initialize(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* copy_src);
ptrsafe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV5890     VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>(this); }
ptrsafe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV5891     VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const *>(this); }
5892 };
5893 
5894 struct safe_VkDrmFormatModifierPropertiesListEXT {
5895     VkStructureType sType;
5896     void* pNext;
5897     uint32_t drmFormatModifierCount;
5898     VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties;
5899     safe_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT* in_struct);
5900     safe_VkDrmFormatModifierPropertiesListEXT(const safe_VkDrmFormatModifierPropertiesListEXT& copy_src);
5901     safe_VkDrmFormatModifierPropertiesListEXT& operator=(const safe_VkDrmFormatModifierPropertiesListEXT& copy_src);
5902     safe_VkDrmFormatModifierPropertiesListEXT();
5903     ~safe_VkDrmFormatModifierPropertiesListEXT();
5904     void initialize(const VkDrmFormatModifierPropertiesListEXT* in_struct);
5905     void initialize(const safe_VkDrmFormatModifierPropertiesListEXT* copy_src);
ptrsafe_VkDrmFormatModifierPropertiesListEXT5906     VkDrmFormatModifierPropertiesListEXT *ptr() { return reinterpret_cast<VkDrmFormatModifierPropertiesListEXT *>(this); }
ptrsafe_VkDrmFormatModifierPropertiesListEXT5907     VkDrmFormatModifierPropertiesListEXT const *ptr() const { return reinterpret_cast<VkDrmFormatModifierPropertiesListEXT const *>(this); }
5908 };
5909 
5910 struct safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT {
5911     VkStructureType sType;
5912     const void* pNext;
5913     uint64_t drmFormatModifier;
5914     VkSharingMode sharingMode;
5915     uint32_t queueFamilyIndexCount;
5916     const uint32_t* pQueueFamilyIndices;
5917     safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* in_struct);
5918     safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& copy_src);
5919     safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& operator=(const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& copy_src);
5920     safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT();
5921     ~safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT();
5922     void initialize(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* in_struct);
5923     void initialize(const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT* copy_src);
ptrsafe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT5924     VkPhysicalDeviceImageDrmFormatModifierInfoEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT *>(this); }
ptrsafe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT5925     VkPhysicalDeviceImageDrmFormatModifierInfoEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT const *>(this); }
5926 };
5927 
5928 struct safe_VkImageDrmFormatModifierListCreateInfoEXT {
5929     VkStructureType sType;
5930     const void* pNext;
5931     uint32_t drmFormatModifierCount;
5932     const uint64_t* pDrmFormatModifiers;
5933     safe_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT* in_struct);
5934     safe_VkImageDrmFormatModifierListCreateInfoEXT(const safe_VkImageDrmFormatModifierListCreateInfoEXT& copy_src);
5935     safe_VkImageDrmFormatModifierListCreateInfoEXT& operator=(const safe_VkImageDrmFormatModifierListCreateInfoEXT& copy_src);
5936     safe_VkImageDrmFormatModifierListCreateInfoEXT();
5937     ~safe_VkImageDrmFormatModifierListCreateInfoEXT();
5938     void initialize(const VkImageDrmFormatModifierListCreateInfoEXT* in_struct);
5939     void initialize(const safe_VkImageDrmFormatModifierListCreateInfoEXT* copy_src);
ptrsafe_VkImageDrmFormatModifierListCreateInfoEXT5940     VkImageDrmFormatModifierListCreateInfoEXT *ptr() { return reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT *>(this); }
ptrsafe_VkImageDrmFormatModifierListCreateInfoEXT5941     VkImageDrmFormatModifierListCreateInfoEXT const *ptr() const { return reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT const *>(this); }
5942 };
5943 
5944 struct safe_VkImageDrmFormatModifierExplicitCreateInfoEXT {
5945     VkStructureType sType;
5946     const void* pNext;
5947     uint64_t drmFormatModifier;
5948     uint32_t drmFormatModifierPlaneCount;
5949     const VkSubresourceLayout* pPlaneLayouts;
5950     safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT* in_struct);
5951     safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& copy_src);
5952     safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& operator=(const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& copy_src);
5953     safe_VkImageDrmFormatModifierExplicitCreateInfoEXT();
5954     ~safe_VkImageDrmFormatModifierExplicitCreateInfoEXT();
5955     void initialize(const VkImageDrmFormatModifierExplicitCreateInfoEXT* in_struct);
5956     void initialize(const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT* copy_src);
ptrsafe_VkImageDrmFormatModifierExplicitCreateInfoEXT5957     VkImageDrmFormatModifierExplicitCreateInfoEXT *ptr() { return reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT *>(this); }
ptrsafe_VkImageDrmFormatModifierExplicitCreateInfoEXT5958     VkImageDrmFormatModifierExplicitCreateInfoEXT const *ptr() const { return reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT const *>(this); }
5959 };
5960 
5961 struct safe_VkImageDrmFormatModifierPropertiesEXT {
5962     VkStructureType sType;
5963     void* pNext;
5964     uint64_t drmFormatModifier;
5965     safe_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT* in_struct);
5966     safe_VkImageDrmFormatModifierPropertiesEXT(const safe_VkImageDrmFormatModifierPropertiesEXT& copy_src);
5967     safe_VkImageDrmFormatModifierPropertiesEXT& operator=(const safe_VkImageDrmFormatModifierPropertiesEXT& copy_src);
5968     safe_VkImageDrmFormatModifierPropertiesEXT();
5969     ~safe_VkImageDrmFormatModifierPropertiesEXT();
5970     void initialize(const VkImageDrmFormatModifierPropertiesEXT* in_struct);
5971     void initialize(const safe_VkImageDrmFormatModifierPropertiesEXT* copy_src);
ptrsafe_VkImageDrmFormatModifierPropertiesEXT5972     VkImageDrmFormatModifierPropertiesEXT *ptr() { return reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>(this); }
ptrsafe_VkImageDrmFormatModifierPropertiesEXT5973     VkImageDrmFormatModifierPropertiesEXT const *ptr() const { return reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT const *>(this); }
5974 };
5975 
5976 struct safe_VkValidationCacheCreateInfoEXT {
5977     VkStructureType sType;
5978     const void* pNext;
5979     VkValidationCacheCreateFlagsEXT flags;
5980     size_t initialDataSize;
5981     const void* pInitialData;
5982     safe_VkValidationCacheCreateInfoEXT(const VkValidationCacheCreateInfoEXT* in_struct);
5983     safe_VkValidationCacheCreateInfoEXT(const safe_VkValidationCacheCreateInfoEXT& copy_src);
5984     safe_VkValidationCacheCreateInfoEXT& operator=(const safe_VkValidationCacheCreateInfoEXT& copy_src);
5985     safe_VkValidationCacheCreateInfoEXT();
5986     ~safe_VkValidationCacheCreateInfoEXT();
5987     void initialize(const VkValidationCacheCreateInfoEXT* in_struct);
5988     void initialize(const safe_VkValidationCacheCreateInfoEXT* copy_src);
ptrsafe_VkValidationCacheCreateInfoEXT5989     VkValidationCacheCreateInfoEXT *ptr() { return reinterpret_cast<VkValidationCacheCreateInfoEXT *>(this); }
ptrsafe_VkValidationCacheCreateInfoEXT5990     VkValidationCacheCreateInfoEXT const *ptr() const { return reinterpret_cast<VkValidationCacheCreateInfoEXT const *>(this); }
5991 };
5992 
5993 struct safe_VkShaderModuleValidationCacheCreateInfoEXT {
5994     VkStructureType sType;
5995     const void* pNext;
5996     VkValidationCacheEXT validationCache;
5997     safe_VkShaderModuleValidationCacheCreateInfoEXT(const VkShaderModuleValidationCacheCreateInfoEXT* in_struct);
5998     safe_VkShaderModuleValidationCacheCreateInfoEXT(const safe_VkShaderModuleValidationCacheCreateInfoEXT& copy_src);
5999     safe_VkShaderModuleValidationCacheCreateInfoEXT& operator=(const safe_VkShaderModuleValidationCacheCreateInfoEXT& copy_src);
6000     safe_VkShaderModuleValidationCacheCreateInfoEXT();
6001     ~safe_VkShaderModuleValidationCacheCreateInfoEXT();
6002     void initialize(const VkShaderModuleValidationCacheCreateInfoEXT* in_struct);
6003     void initialize(const safe_VkShaderModuleValidationCacheCreateInfoEXT* copy_src);
ptrsafe_VkShaderModuleValidationCacheCreateInfoEXT6004     VkShaderModuleValidationCacheCreateInfoEXT *ptr() { return reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT *>(this); }
ptrsafe_VkShaderModuleValidationCacheCreateInfoEXT6005     VkShaderModuleValidationCacheCreateInfoEXT const *ptr() const { return reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT const *>(this); }
6006 };
6007 
6008 struct safe_VkShadingRatePaletteNV {
6009     uint32_t shadingRatePaletteEntryCount;
6010     const VkShadingRatePaletteEntryNV* pShadingRatePaletteEntries;
6011     safe_VkShadingRatePaletteNV(const VkShadingRatePaletteNV* in_struct);
6012     safe_VkShadingRatePaletteNV(const safe_VkShadingRatePaletteNV& copy_src);
6013     safe_VkShadingRatePaletteNV& operator=(const safe_VkShadingRatePaletteNV& copy_src);
6014     safe_VkShadingRatePaletteNV();
6015     ~safe_VkShadingRatePaletteNV();
6016     void initialize(const VkShadingRatePaletteNV* in_struct);
6017     void initialize(const safe_VkShadingRatePaletteNV* copy_src);
ptrsafe_VkShadingRatePaletteNV6018     VkShadingRatePaletteNV *ptr() { return reinterpret_cast<VkShadingRatePaletteNV *>(this); }
ptrsafe_VkShadingRatePaletteNV6019     VkShadingRatePaletteNV const *ptr() const { return reinterpret_cast<VkShadingRatePaletteNV const *>(this); }
6020 };
6021 
6022 struct safe_VkPipelineViewportShadingRateImageStateCreateInfoNV {
6023     VkStructureType sType;
6024     const void* pNext;
6025     VkBool32 shadingRateImageEnable;
6026     uint32_t viewportCount;
6027     safe_VkShadingRatePaletteNV* pShadingRatePalettes;
6028     safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(const VkPipelineViewportShadingRateImageStateCreateInfoNV* in_struct);
6029     safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& copy_src);
6030     safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& operator=(const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& copy_src);
6031     safe_VkPipelineViewportShadingRateImageStateCreateInfoNV();
6032     ~safe_VkPipelineViewportShadingRateImageStateCreateInfoNV();
6033     void initialize(const VkPipelineViewportShadingRateImageStateCreateInfoNV* in_struct);
6034     void initialize(const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV* copy_src);
ptrsafe_VkPipelineViewportShadingRateImageStateCreateInfoNV6035     VkPipelineViewportShadingRateImageStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV *>(this); }
ptrsafe_VkPipelineViewportShadingRateImageStateCreateInfoNV6036     VkPipelineViewportShadingRateImageStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV const *>(this); }
6037 };
6038 
6039 struct safe_VkPhysicalDeviceShadingRateImageFeaturesNV {
6040     VkStructureType sType;
6041     void* pNext;
6042     VkBool32 shadingRateImage;
6043     VkBool32 shadingRateCoarseSampleOrder;
6044     safe_VkPhysicalDeviceShadingRateImageFeaturesNV(const VkPhysicalDeviceShadingRateImageFeaturesNV* in_struct);
6045     safe_VkPhysicalDeviceShadingRateImageFeaturesNV(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV& copy_src);
6046     safe_VkPhysicalDeviceShadingRateImageFeaturesNV& operator=(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV& copy_src);
6047     safe_VkPhysicalDeviceShadingRateImageFeaturesNV();
6048     ~safe_VkPhysicalDeviceShadingRateImageFeaturesNV();
6049     void initialize(const VkPhysicalDeviceShadingRateImageFeaturesNV* in_struct);
6050     void initialize(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV* copy_src);
ptrsafe_VkPhysicalDeviceShadingRateImageFeaturesNV6051     VkPhysicalDeviceShadingRateImageFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV *>(this); }
ptrsafe_VkPhysicalDeviceShadingRateImageFeaturesNV6052     VkPhysicalDeviceShadingRateImageFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV const *>(this); }
6053 };
6054 
6055 struct safe_VkPhysicalDeviceShadingRateImagePropertiesNV {
6056     VkStructureType sType;
6057     void* pNext;
6058     VkExtent2D shadingRateTexelSize;
6059     uint32_t shadingRatePaletteSize;
6060     uint32_t shadingRateMaxCoarseSamples;
6061     safe_VkPhysicalDeviceShadingRateImagePropertiesNV(const VkPhysicalDeviceShadingRateImagePropertiesNV* in_struct);
6062     safe_VkPhysicalDeviceShadingRateImagePropertiesNV(const safe_VkPhysicalDeviceShadingRateImagePropertiesNV& copy_src);
6063     safe_VkPhysicalDeviceShadingRateImagePropertiesNV& operator=(const safe_VkPhysicalDeviceShadingRateImagePropertiesNV& copy_src);
6064     safe_VkPhysicalDeviceShadingRateImagePropertiesNV();
6065     ~safe_VkPhysicalDeviceShadingRateImagePropertiesNV();
6066     void initialize(const VkPhysicalDeviceShadingRateImagePropertiesNV* in_struct);
6067     void initialize(const safe_VkPhysicalDeviceShadingRateImagePropertiesNV* copy_src);
ptrsafe_VkPhysicalDeviceShadingRateImagePropertiesNV6068     VkPhysicalDeviceShadingRateImagePropertiesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV *>(this); }
ptrsafe_VkPhysicalDeviceShadingRateImagePropertiesNV6069     VkPhysicalDeviceShadingRateImagePropertiesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV const *>(this); }
6070 };
6071 
6072 struct safe_VkCoarseSampleOrderCustomNV {
6073     VkShadingRatePaletteEntryNV shadingRate;
6074     uint32_t sampleCount;
6075     uint32_t sampleLocationCount;
6076     const VkCoarseSampleLocationNV* pSampleLocations;
6077     safe_VkCoarseSampleOrderCustomNV(const VkCoarseSampleOrderCustomNV* in_struct);
6078     safe_VkCoarseSampleOrderCustomNV(const safe_VkCoarseSampleOrderCustomNV& copy_src);
6079     safe_VkCoarseSampleOrderCustomNV& operator=(const safe_VkCoarseSampleOrderCustomNV& copy_src);
6080     safe_VkCoarseSampleOrderCustomNV();
6081     ~safe_VkCoarseSampleOrderCustomNV();
6082     void initialize(const VkCoarseSampleOrderCustomNV* in_struct);
6083     void initialize(const safe_VkCoarseSampleOrderCustomNV* copy_src);
ptrsafe_VkCoarseSampleOrderCustomNV6084     VkCoarseSampleOrderCustomNV *ptr() { return reinterpret_cast<VkCoarseSampleOrderCustomNV *>(this); }
ptrsafe_VkCoarseSampleOrderCustomNV6085     VkCoarseSampleOrderCustomNV const *ptr() const { return reinterpret_cast<VkCoarseSampleOrderCustomNV const *>(this); }
6086 };
6087 
6088 struct safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV {
6089     VkStructureType sType;
6090     const void* pNext;
6091     VkCoarseSampleOrderTypeNV sampleOrderType;
6092     uint32_t customSampleOrderCount;
6093     safe_VkCoarseSampleOrderCustomNV* pCustomSampleOrders;
6094     safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* in_struct);
6095     safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& copy_src);
6096     safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=(const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& copy_src);
6097     safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV();
6098     ~safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV();
6099     void initialize(const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* in_struct);
6100     void initialize(const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* copy_src);
ptrsafe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV6101     VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(this); }
ptrsafe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV6102     VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const *>(this); }
6103 };
6104 
6105 struct safe_VkRayTracingShaderGroupCreateInfoNV {
6106     VkStructureType sType;
6107     const void* pNext;
6108     VkRayTracingShaderGroupTypeKHR type;
6109     uint32_t generalShader;
6110     uint32_t closestHitShader;
6111     uint32_t anyHitShader;
6112     uint32_t intersectionShader;
6113     safe_VkRayTracingShaderGroupCreateInfoNV(const VkRayTracingShaderGroupCreateInfoNV* in_struct);
6114     safe_VkRayTracingShaderGroupCreateInfoNV(const safe_VkRayTracingShaderGroupCreateInfoNV& copy_src);
6115     safe_VkRayTracingShaderGroupCreateInfoNV& operator=(const safe_VkRayTracingShaderGroupCreateInfoNV& copy_src);
6116     safe_VkRayTracingShaderGroupCreateInfoNV();
6117     ~safe_VkRayTracingShaderGroupCreateInfoNV();
6118     void initialize(const VkRayTracingShaderGroupCreateInfoNV* in_struct);
6119     void initialize(const safe_VkRayTracingShaderGroupCreateInfoNV* copy_src);
ptrsafe_VkRayTracingShaderGroupCreateInfoNV6120     VkRayTracingShaderGroupCreateInfoNV *ptr() { return reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV *>(this); }
ptrsafe_VkRayTracingShaderGroupCreateInfoNV6121     VkRayTracingShaderGroupCreateInfoNV const *ptr() const { return reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV const *>(this); }
6122 };
6123 
6124 struct safe_VkRayTracingPipelineCreateInfoNV {
6125     VkStructureType sType;
6126     const void* pNext;
6127     VkPipelineCreateFlags flags;
6128     uint32_t stageCount;
6129     safe_VkPipelineShaderStageCreateInfo* pStages;
6130     uint32_t groupCount;
6131     safe_VkRayTracingShaderGroupCreateInfoNV* pGroups;
6132     uint32_t maxRecursionDepth;
6133     VkPipelineLayout layout;
6134     VkPipeline basePipelineHandle;
6135     int32_t basePipelineIndex;
6136     safe_VkRayTracingPipelineCreateInfoNV(const VkRayTracingPipelineCreateInfoNV* in_struct);
6137     safe_VkRayTracingPipelineCreateInfoNV(const safe_VkRayTracingPipelineCreateInfoNV& copy_src);
6138     safe_VkRayTracingPipelineCreateInfoNV& operator=(const safe_VkRayTracingPipelineCreateInfoNV& copy_src);
6139     safe_VkRayTracingPipelineCreateInfoNV();
6140     ~safe_VkRayTracingPipelineCreateInfoNV();
6141     void initialize(const VkRayTracingPipelineCreateInfoNV* in_struct);
6142     void initialize(const safe_VkRayTracingPipelineCreateInfoNV* copy_src);
ptrsafe_VkRayTracingPipelineCreateInfoNV6143     VkRayTracingPipelineCreateInfoNV *ptr() { return reinterpret_cast<VkRayTracingPipelineCreateInfoNV *>(this); }
ptrsafe_VkRayTracingPipelineCreateInfoNV6144     VkRayTracingPipelineCreateInfoNV const *ptr() const { return reinterpret_cast<VkRayTracingPipelineCreateInfoNV const *>(this); }
6145 };
6146 
6147 struct safe_VkGeometryTrianglesNV {
6148     VkStructureType sType;
6149     const void* pNext;
6150     VkBuffer vertexData;
6151     VkDeviceSize vertexOffset;
6152     uint32_t vertexCount;
6153     VkDeviceSize vertexStride;
6154     VkFormat vertexFormat;
6155     VkBuffer indexData;
6156     VkDeviceSize indexOffset;
6157     uint32_t indexCount;
6158     VkIndexType indexType;
6159     VkBuffer transformData;
6160     VkDeviceSize transformOffset;
6161     safe_VkGeometryTrianglesNV(const VkGeometryTrianglesNV* in_struct);
6162     safe_VkGeometryTrianglesNV(const safe_VkGeometryTrianglesNV& copy_src);
6163     safe_VkGeometryTrianglesNV& operator=(const safe_VkGeometryTrianglesNV& copy_src);
6164     safe_VkGeometryTrianglesNV();
6165     ~safe_VkGeometryTrianglesNV();
6166     void initialize(const VkGeometryTrianglesNV* in_struct);
6167     void initialize(const safe_VkGeometryTrianglesNV* copy_src);
ptrsafe_VkGeometryTrianglesNV6168     VkGeometryTrianglesNV *ptr() { return reinterpret_cast<VkGeometryTrianglesNV *>(this); }
ptrsafe_VkGeometryTrianglesNV6169     VkGeometryTrianglesNV const *ptr() const { return reinterpret_cast<VkGeometryTrianglesNV const *>(this); }
6170 };
6171 
6172 struct safe_VkGeometryAABBNV {
6173     VkStructureType sType;
6174     const void* pNext;
6175     VkBuffer aabbData;
6176     uint32_t numAABBs;
6177     uint32_t stride;
6178     VkDeviceSize offset;
6179     safe_VkGeometryAABBNV(const VkGeometryAABBNV* in_struct);
6180     safe_VkGeometryAABBNV(const safe_VkGeometryAABBNV& copy_src);
6181     safe_VkGeometryAABBNV& operator=(const safe_VkGeometryAABBNV& copy_src);
6182     safe_VkGeometryAABBNV();
6183     ~safe_VkGeometryAABBNV();
6184     void initialize(const VkGeometryAABBNV* in_struct);
6185     void initialize(const safe_VkGeometryAABBNV* copy_src);
ptrsafe_VkGeometryAABBNV6186     VkGeometryAABBNV *ptr() { return reinterpret_cast<VkGeometryAABBNV *>(this); }
ptrsafe_VkGeometryAABBNV6187     VkGeometryAABBNV const *ptr() const { return reinterpret_cast<VkGeometryAABBNV const *>(this); }
6188 };
6189 
6190 struct safe_VkGeometryNV {
6191     VkStructureType sType;
6192     const void* pNext;
6193     VkGeometryTypeKHR geometryType;
6194     VkGeometryDataNV geometry;
6195     VkGeometryFlagsKHR flags;
6196     safe_VkGeometryNV(const VkGeometryNV* in_struct);
6197     safe_VkGeometryNV(const safe_VkGeometryNV& copy_src);
6198     safe_VkGeometryNV& operator=(const safe_VkGeometryNV& copy_src);
6199     safe_VkGeometryNV();
6200     ~safe_VkGeometryNV();
6201     void initialize(const VkGeometryNV* in_struct);
6202     void initialize(const safe_VkGeometryNV* copy_src);
ptrsafe_VkGeometryNV6203     VkGeometryNV *ptr() { return reinterpret_cast<VkGeometryNV *>(this); }
ptrsafe_VkGeometryNV6204     VkGeometryNV const *ptr() const { return reinterpret_cast<VkGeometryNV const *>(this); }
6205 };
6206 
6207 struct safe_VkAccelerationStructureInfoNV {
6208     VkStructureType sType;
6209     const void* pNext;
6210     VkAccelerationStructureTypeNV type;
6211     VkBuildAccelerationStructureFlagsNV flags;
6212     uint32_t instanceCount;
6213     uint32_t geometryCount;
6214     safe_VkGeometryNV* pGeometries;
6215     safe_VkAccelerationStructureInfoNV(const VkAccelerationStructureInfoNV* in_struct);
6216     safe_VkAccelerationStructureInfoNV(const safe_VkAccelerationStructureInfoNV& copy_src);
6217     safe_VkAccelerationStructureInfoNV& operator=(const safe_VkAccelerationStructureInfoNV& copy_src);
6218     safe_VkAccelerationStructureInfoNV();
6219     ~safe_VkAccelerationStructureInfoNV();
6220     void initialize(const VkAccelerationStructureInfoNV* in_struct);
6221     void initialize(const safe_VkAccelerationStructureInfoNV* copy_src);
ptrsafe_VkAccelerationStructureInfoNV6222     VkAccelerationStructureInfoNV *ptr() { return reinterpret_cast<VkAccelerationStructureInfoNV *>(this); }
ptrsafe_VkAccelerationStructureInfoNV6223     VkAccelerationStructureInfoNV const *ptr() const { return reinterpret_cast<VkAccelerationStructureInfoNV const *>(this); }
6224 };
6225 
6226 struct safe_VkAccelerationStructureCreateInfoNV {
6227     VkStructureType sType;
6228     const void* pNext;
6229     VkDeviceSize compactedSize;
6230     safe_VkAccelerationStructureInfoNV info;
6231     safe_VkAccelerationStructureCreateInfoNV(const VkAccelerationStructureCreateInfoNV* in_struct);
6232     safe_VkAccelerationStructureCreateInfoNV(const safe_VkAccelerationStructureCreateInfoNV& copy_src);
6233     safe_VkAccelerationStructureCreateInfoNV& operator=(const safe_VkAccelerationStructureCreateInfoNV& copy_src);
6234     safe_VkAccelerationStructureCreateInfoNV();
6235     ~safe_VkAccelerationStructureCreateInfoNV();
6236     void initialize(const VkAccelerationStructureCreateInfoNV* in_struct);
6237     void initialize(const safe_VkAccelerationStructureCreateInfoNV* copy_src);
ptrsafe_VkAccelerationStructureCreateInfoNV6238     VkAccelerationStructureCreateInfoNV *ptr() { return reinterpret_cast<VkAccelerationStructureCreateInfoNV *>(this); }
ptrsafe_VkAccelerationStructureCreateInfoNV6239     VkAccelerationStructureCreateInfoNV const *ptr() const { return reinterpret_cast<VkAccelerationStructureCreateInfoNV const *>(this); }
6240 };
6241 
6242 struct safe_VkBindAccelerationStructureMemoryInfoKHR {
6243     VkStructureType sType;
6244     const void* pNext;
6245     VkAccelerationStructureKHR accelerationStructure;
6246     VkDeviceMemory memory;
6247     VkDeviceSize memoryOffset;
6248     uint32_t deviceIndexCount;
6249     const uint32_t* pDeviceIndices;
6250     safe_VkBindAccelerationStructureMemoryInfoKHR(const VkBindAccelerationStructureMemoryInfoKHR* in_struct);
6251     safe_VkBindAccelerationStructureMemoryInfoKHR(const safe_VkBindAccelerationStructureMemoryInfoKHR& copy_src);
6252     safe_VkBindAccelerationStructureMemoryInfoKHR& operator=(const safe_VkBindAccelerationStructureMemoryInfoKHR& copy_src);
6253     safe_VkBindAccelerationStructureMemoryInfoKHR();
6254     ~safe_VkBindAccelerationStructureMemoryInfoKHR();
6255     void initialize(const VkBindAccelerationStructureMemoryInfoKHR* in_struct);
6256     void initialize(const safe_VkBindAccelerationStructureMemoryInfoKHR* copy_src);
ptrsafe_VkBindAccelerationStructureMemoryInfoKHR6257     VkBindAccelerationStructureMemoryInfoKHR *ptr() { return reinterpret_cast<VkBindAccelerationStructureMemoryInfoKHR *>(this); }
ptrsafe_VkBindAccelerationStructureMemoryInfoKHR6258     VkBindAccelerationStructureMemoryInfoKHR const *ptr() const { return reinterpret_cast<VkBindAccelerationStructureMemoryInfoKHR const *>(this); }
6259 };
6260 
6261 struct safe_VkWriteDescriptorSetAccelerationStructureKHR {
6262     VkStructureType sType;
6263     const void* pNext;
6264     uint32_t accelerationStructureCount;
6265     VkAccelerationStructureKHR* pAccelerationStructures;
6266     safe_VkWriteDescriptorSetAccelerationStructureKHR(const VkWriteDescriptorSetAccelerationStructureKHR* in_struct);
6267     safe_VkWriteDescriptorSetAccelerationStructureKHR(const safe_VkWriteDescriptorSetAccelerationStructureKHR& copy_src);
6268     safe_VkWriteDescriptorSetAccelerationStructureKHR& operator=(const safe_VkWriteDescriptorSetAccelerationStructureKHR& copy_src);
6269     safe_VkWriteDescriptorSetAccelerationStructureKHR();
6270     ~safe_VkWriteDescriptorSetAccelerationStructureKHR();
6271     void initialize(const VkWriteDescriptorSetAccelerationStructureKHR* in_struct);
6272     void initialize(const safe_VkWriteDescriptorSetAccelerationStructureKHR* copy_src);
ptrsafe_VkWriteDescriptorSetAccelerationStructureKHR6273     VkWriteDescriptorSetAccelerationStructureKHR *ptr() { return reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR *>(this); }
ptrsafe_VkWriteDescriptorSetAccelerationStructureKHR6274     VkWriteDescriptorSetAccelerationStructureKHR const *ptr() const { return reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR const *>(this); }
6275 };
6276 
6277 struct safe_VkAccelerationStructureMemoryRequirementsInfoNV {
6278     VkStructureType sType;
6279     const void* pNext;
6280     VkAccelerationStructureMemoryRequirementsTypeNV type;
6281     VkAccelerationStructureNV accelerationStructure;
6282     safe_VkAccelerationStructureMemoryRequirementsInfoNV(const VkAccelerationStructureMemoryRequirementsInfoNV* in_struct);
6283     safe_VkAccelerationStructureMemoryRequirementsInfoNV(const safe_VkAccelerationStructureMemoryRequirementsInfoNV& copy_src);
6284     safe_VkAccelerationStructureMemoryRequirementsInfoNV& operator=(const safe_VkAccelerationStructureMemoryRequirementsInfoNV& copy_src);
6285     safe_VkAccelerationStructureMemoryRequirementsInfoNV();
6286     ~safe_VkAccelerationStructureMemoryRequirementsInfoNV();
6287     void initialize(const VkAccelerationStructureMemoryRequirementsInfoNV* in_struct);
6288     void initialize(const safe_VkAccelerationStructureMemoryRequirementsInfoNV* copy_src);
ptrsafe_VkAccelerationStructureMemoryRequirementsInfoNV6289     VkAccelerationStructureMemoryRequirementsInfoNV *ptr() { return reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV *>(this); }
ptrsafe_VkAccelerationStructureMemoryRequirementsInfoNV6290     VkAccelerationStructureMemoryRequirementsInfoNV const *ptr() const { return reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV const *>(this); }
6291 };
6292 
6293 struct safe_VkPhysicalDeviceRayTracingPropertiesNV {
6294     VkStructureType sType;
6295     void* pNext;
6296     uint32_t shaderGroupHandleSize;
6297     uint32_t maxRecursionDepth;
6298     uint32_t maxShaderGroupStride;
6299     uint32_t shaderGroupBaseAlignment;
6300     uint64_t maxGeometryCount;
6301     uint64_t maxInstanceCount;
6302     uint64_t maxTriangleCount;
6303     uint32_t maxDescriptorSetAccelerationStructures;
6304     safe_VkPhysicalDeviceRayTracingPropertiesNV(const VkPhysicalDeviceRayTracingPropertiesNV* in_struct);
6305     safe_VkPhysicalDeviceRayTracingPropertiesNV(const safe_VkPhysicalDeviceRayTracingPropertiesNV& copy_src);
6306     safe_VkPhysicalDeviceRayTracingPropertiesNV& operator=(const safe_VkPhysicalDeviceRayTracingPropertiesNV& copy_src);
6307     safe_VkPhysicalDeviceRayTracingPropertiesNV();
6308     ~safe_VkPhysicalDeviceRayTracingPropertiesNV();
6309     void initialize(const VkPhysicalDeviceRayTracingPropertiesNV* in_struct);
6310     void initialize(const safe_VkPhysicalDeviceRayTracingPropertiesNV* copy_src);
ptrsafe_VkPhysicalDeviceRayTracingPropertiesNV6311     VkPhysicalDeviceRayTracingPropertiesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV *>(this); }
ptrsafe_VkPhysicalDeviceRayTracingPropertiesNV6312     VkPhysicalDeviceRayTracingPropertiesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV const *>(this); }
6313 };
6314 
6315 struct safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
6316     VkStructureType sType;
6317     void* pNext;
6318     VkBool32 representativeFragmentTest;
6319     safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* in_struct);
6320     safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& copy_src);
6321     safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=(const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& copy_src);
6322     safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV();
6323     ~safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV();
6324     void initialize(const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* in_struct);
6325     void initialize(const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* copy_src);
ptrsafe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV6326     VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>(this); }
ptrsafe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV6327     VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const *>(this); }
6328 };
6329 
6330 struct safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV {
6331     VkStructureType sType;
6332     const void* pNext;
6333     VkBool32 representativeFragmentTestEnable;
6334     safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* in_struct);
6335     safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& copy_src);
6336     safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& operator=(const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& copy_src);
6337     safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV();
6338     ~safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV();
6339     void initialize(const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* in_struct);
6340     void initialize(const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV* copy_src);
ptrsafe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV6341     VkPipelineRepresentativeFragmentTestStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV *>(this); }
ptrsafe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV6342     VkPipelineRepresentativeFragmentTestStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV const *>(this); }
6343 };
6344 
6345 struct safe_VkPhysicalDeviceImageViewImageFormatInfoEXT {
6346     VkStructureType sType;
6347     void* pNext;
6348     VkImageViewType imageViewType;
6349     safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(const VkPhysicalDeviceImageViewImageFormatInfoEXT* in_struct);
6350     safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& copy_src);
6351     safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& operator=(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& copy_src);
6352     safe_VkPhysicalDeviceImageViewImageFormatInfoEXT();
6353     ~safe_VkPhysicalDeviceImageViewImageFormatInfoEXT();
6354     void initialize(const VkPhysicalDeviceImageViewImageFormatInfoEXT* in_struct);
6355     void initialize(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT* copy_src);
ptrsafe_VkPhysicalDeviceImageViewImageFormatInfoEXT6356     VkPhysicalDeviceImageViewImageFormatInfoEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT *>(this); }
ptrsafe_VkPhysicalDeviceImageViewImageFormatInfoEXT6357     VkPhysicalDeviceImageViewImageFormatInfoEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT const *>(this); }
6358 };
6359 
6360 struct safe_VkFilterCubicImageViewImageFormatPropertiesEXT {
6361     VkStructureType sType;
6362     void* pNext;
6363     VkBool32 filterCubic;
6364     VkBool32 filterCubicMinmax;
6365     safe_VkFilterCubicImageViewImageFormatPropertiesEXT(const VkFilterCubicImageViewImageFormatPropertiesEXT* in_struct);
6366     safe_VkFilterCubicImageViewImageFormatPropertiesEXT(const safe_VkFilterCubicImageViewImageFormatPropertiesEXT& copy_src);
6367     safe_VkFilterCubicImageViewImageFormatPropertiesEXT& operator=(const safe_VkFilterCubicImageViewImageFormatPropertiesEXT& copy_src);
6368     safe_VkFilterCubicImageViewImageFormatPropertiesEXT();
6369     ~safe_VkFilterCubicImageViewImageFormatPropertiesEXT();
6370     void initialize(const VkFilterCubicImageViewImageFormatPropertiesEXT* in_struct);
6371     void initialize(const safe_VkFilterCubicImageViewImageFormatPropertiesEXT* copy_src);
ptrsafe_VkFilterCubicImageViewImageFormatPropertiesEXT6372     VkFilterCubicImageViewImageFormatPropertiesEXT *ptr() { return reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT *>(this); }
ptrsafe_VkFilterCubicImageViewImageFormatPropertiesEXT6373     VkFilterCubicImageViewImageFormatPropertiesEXT const *ptr() const { return reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT const *>(this); }
6374 };
6375 
6376 struct safe_VkDeviceQueueGlobalPriorityCreateInfoEXT {
6377     VkStructureType sType;
6378     const void* pNext;
6379     VkQueueGlobalPriorityEXT globalPriority;
6380     safe_VkDeviceQueueGlobalPriorityCreateInfoEXT(const VkDeviceQueueGlobalPriorityCreateInfoEXT* in_struct);
6381     safe_VkDeviceQueueGlobalPriorityCreateInfoEXT(const safe_VkDeviceQueueGlobalPriorityCreateInfoEXT& copy_src);
6382     safe_VkDeviceQueueGlobalPriorityCreateInfoEXT& operator=(const safe_VkDeviceQueueGlobalPriorityCreateInfoEXT& copy_src);
6383     safe_VkDeviceQueueGlobalPriorityCreateInfoEXT();
6384     ~safe_VkDeviceQueueGlobalPriorityCreateInfoEXT();
6385     void initialize(const VkDeviceQueueGlobalPriorityCreateInfoEXT* in_struct);
6386     void initialize(const safe_VkDeviceQueueGlobalPriorityCreateInfoEXT* copy_src);
ptrsafe_VkDeviceQueueGlobalPriorityCreateInfoEXT6387     VkDeviceQueueGlobalPriorityCreateInfoEXT *ptr() { return reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT *>(this); }
ptrsafe_VkDeviceQueueGlobalPriorityCreateInfoEXT6388     VkDeviceQueueGlobalPriorityCreateInfoEXT const *ptr() const { return reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT const *>(this); }
6389 };
6390 
6391 struct safe_VkImportMemoryHostPointerInfoEXT {
6392     VkStructureType sType;
6393     const void* pNext;
6394     VkExternalMemoryHandleTypeFlagBits handleType;
6395     void* pHostPointer;
6396     safe_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT* in_struct);
6397     safe_VkImportMemoryHostPointerInfoEXT(const safe_VkImportMemoryHostPointerInfoEXT& copy_src);
6398     safe_VkImportMemoryHostPointerInfoEXT& operator=(const safe_VkImportMemoryHostPointerInfoEXT& copy_src);
6399     safe_VkImportMemoryHostPointerInfoEXT();
6400     ~safe_VkImportMemoryHostPointerInfoEXT();
6401     void initialize(const VkImportMemoryHostPointerInfoEXT* in_struct);
6402     void initialize(const safe_VkImportMemoryHostPointerInfoEXT* copy_src);
ptrsafe_VkImportMemoryHostPointerInfoEXT6403     VkImportMemoryHostPointerInfoEXT *ptr() { return reinterpret_cast<VkImportMemoryHostPointerInfoEXT *>(this); }
ptrsafe_VkImportMemoryHostPointerInfoEXT6404     VkImportMemoryHostPointerInfoEXT const *ptr() const { return reinterpret_cast<VkImportMemoryHostPointerInfoEXT const *>(this); }
6405 };
6406 
6407 struct safe_VkMemoryHostPointerPropertiesEXT {
6408     VkStructureType sType;
6409     void* pNext;
6410     uint32_t memoryTypeBits;
6411     safe_VkMemoryHostPointerPropertiesEXT(const VkMemoryHostPointerPropertiesEXT* in_struct);
6412     safe_VkMemoryHostPointerPropertiesEXT(const safe_VkMemoryHostPointerPropertiesEXT& copy_src);
6413     safe_VkMemoryHostPointerPropertiesEXT& operator=(const safe_VkMemoryHostPointerPropertiesEXT& copy_src);
6414     safe_VkMemoryHostPointerPropertiesEXT();
6415     ~safe_VkMemoryHostPointerPropertiesEXT();
6416     void initialize(const VkMemoryHostPointerPropertiesEXT* in_struct);
6417     void initialize(const safe_VkMemoryHostPointerPropertiesEXT* copy_src);
ptrsafe_VkMemoryHostPointerPropertiesEXT6418     VkMemoryHostPointerPropertiesEXT *ptr() { return reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>(this); }
ptrsafe_VkMemoryHostPointerPropertiesEXT6419     VkMemoryHostPointerPropertiesEXT const *ptr() const { return reinterpret_cast<VkMemoryHostPointerPropertiesEXT const *>(this); }
6420 };
6421 
6422 struct safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT {
6423     VkStructureType sType;
6424     void* pNext;
6425     VkDeviceSize minImportedHostPointerAlignment;
6426     safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* in_struct);
6427     safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& copy_src);
6428     safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& operator=(const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& copy_src);
6429     safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT();
6430     ~safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT();
6431     void initialize(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* in_struct);
6432     void initialize(const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT* copy_src);
ptrsafe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT6433     VkPhysicalDeviceExternalMemoryHostPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT *>(this); }
ptrsafe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT6434     VkPhysicalDeviceExternalMemoryHostPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT const *>(this); }
6435 };
6436 
6437 struct safe_VkPipelineCompilerControlCreateInfoAMD {
6438     VkStructureType sType;
6439     const void* pNext;
6440     VkPipelineCompilerControlFlagsAMD compilerControlFlags;
6441     safe_VkPipelineCompilerControlCreateInfoAMD(const VkPipelineCompilerControlCreateInfoAMD* in_struct);
6442     safe_VkPipelineCompilerControlCreateInfoAMD(const safe_VkPipelineCompilerControlCreateInfoAMD& copy_src);
6443     safe_VkPipelineCompilerControlCreateInfoAMD& operator=(const safe_VkPipelineCompilerControlCreateInfoAMD& copy_src);
6444     safe_VkPipelineCompilerControlCreateInfoAMD();
6445     ~safe_VkPipelineCompilerControlCreateInfoAMD();
6446     void initialize(const VkPipelineCompilerControlCreateInfoAMD* in_struct);
6447     void initialize(const safe_VkPipelineCompilerControlCreateInfoAMD* copy_src);
ptrsafe_VkPipelineCompilerControlCreateInfoAMD6448     VkPipelineCompilerControlCreateInfoAMD *ptr() { return reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD *>(this); }
ptrsafe_VkPipelineCompilerControlCreateInfoAMD6449     VkPipelineCompilerControlCreateInfoAMD const *ptr() const { return reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD const *>(this); }
6450 };
6451 
6452 struct safe_VkCalibratedTimestampInfoEXT {
6453     VkStructureType sType;
6454     const void* pNext;
6455     VkTimeDomainEXT timeDomain;
6456     safe_VkCalibratedTimestampInfoEXT(const VkCalibratedTimestampInfoEXT* in_struct);
6457     safe_VkCalibratedTimestampInfoEXT(const safe_VkCalibratedTimestampInfoEXT& copy_src);
6458     safe_VkCalibratedTimestampInfoEXT& operator=(const safe_VkCalibratedTimestampInfoEXT& copy_src);
6459     safe_VkCalibratedTimestampInfoEXT();
6460     ~safe_VkCalibratedTimestampInfoEXT();
6461     void initialize(const VkCalibratedTimestampInfoEXT* in_struct);
6462     void initialize(const safe_VkCalibratedTimestampInfoEXT* copy_src);
ptrsafe_VkCalibratedTimestampInfoEXT6463     VkCalibratedTimestampInfoEXT *ptr() { return reinterpret_cast<VkCalibratedTimestampInfoEXT *>(this); }
ptrsafe_VkCalibratedTimestampInfoEXT6464     VkCalibratedTimestampInfoEXT const *ptr() const { return reinterpret_cast<VkCalibratedTimestampInfoEXT const *>(this); }
6465 };
6466 
6467 struct safe_VkPhysicalDeviceShaderCorePropertiesAMD {
6468     VkStructureType sType;
6469     void* pNext;
6470     uint32_t shaderEngineCount;
6471     uint32_t shaderArraysPerEngineCount;
6472     uint32_t computeUnitsPerShaderArray;
6473     uint32_t simdPerComputeUnit;
6474     uint32_t wavefrontsPerSimd;
6475     uint32_t wavefrontSize;
6476     uint32_t sgprsPerSimd;
6477     uint32_t minSgprAllocation;
6478     uint32_t maxSgprAllocation;
6479     uint32_t sgprAllocationGranularity;
6480     uint32_t vgprsPerSimd;
6481     uint32_t minVgprAllocation;
6482     uint32_t maxVgprAllocation;
6483     uint32_t vgprAllocationGranularity;
6484     safe_VkPhysicalDeviceShaderCorePropertiesAMD(const VkPhysicalDeviceShaderCorePropertiesAMD* in_struct);
6485     safe_VkPhysicalDeviceShaderCorePropertiesAMD(const safe_VkPhysicalDeviceShaderCorePropertiesAMD& copy_src);
6486     safe_VkPhysicalDeviceShaderCorePropertiesAMD& operator=(const safe_VkPhysicalDeviceShaderCorePropertiesAMD& copy_src);
6487     safe_VkPhysicalDeviceShaderCorePropertiesAMD();
6488     ~safe_VkPhysicalDeviceShaderCorePropertiesAMD();
6489     void initialize(const VkPhysicalDeviceShaderCorePropertiesAMD* in_struct);
6490     void initialize(const safe_VkPhysicalDeviceShaderCorePropertiesAMD* copy_src);
ptrsafe_VkPhysicalDeviceShaderCorePropertiesAMD6491     VkPhysicalDeviceShaderCorePropertiesAMD *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD *>(this); }
ptrsafe_VkPhysicalDeviceShaderCorePropertiesAMD6492     VkPhysicalDeviceShaderCorePropertiesAMD const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD const *>(this); }
6493 };
6494 
6495 struct safe_VkDeviceMemoryOverallocationCreateInfoAMD {
6496     VkStructureType sType;
6497     const void* pNext;
6498     VkMemoryOverallocationBehaviorAMD overallocationBehavior;
6499     safe_VkDeviceMemoryOverallocationCreateInfoAMD(const VkDeviceMemoryOverallocationCreateInfoAMD* in_struct);
6500     safe_VkDeviceMemoryOverallocationCreateInfoAMD(const safe_VkDeviceMemoryOverallocationCreateInfoAMD& copy_src);
6501     safe_VkDeviceMemoryOverallocationCreateInfoAMD& operator=(const safe_VkDeviceMemoryOverallocationCreateInfoAMD& copy_src);
6502     safe_VkDeviceMemoryOverallocationCreateInfoAMD();
6503     ~safe_VkDeviceMemoryOverallocationCreateInfoAMD();
6504     void initialize(const VkDeviceMemoryOverallocationCreateInfoAMD* in_struct);
6505     void initialize(const safe_VkDeviceMemoryOverallocationCreateInfoAMD* copy_src);
ptrsafe_VkDeviceMemoryOverallocationCreateInfoAMD6506     VkDeviceMemoryOverallocationCreateInfoAMD *ptr() { return reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD *>(this); }
ptrsafe_VkDeviceMemoryOverallocationCreateInfoAMD6507     VkDeviceMemoryOverallocationCreateInfoAMD const *ptr() const { return reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD const *>(this); }
6508 };
6509 
6510 struct safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
6511     VkStructureType sType;
6512     void* pNext;
6513     uint32_t maxVertexAttribDivisor;
6514     safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* in_struct);
6515     safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& copy_src);
6516     safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& operator=(const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& copy_src);
6517     safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT();
6518     ~safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT();
6519     void initialize(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* in_struct);
6520     void initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* copy_src);
ptrsafe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT6521     VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *>(this); }
ptrsafe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT6522     VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const *>(this); }
6523 };
6524 
6525 struct safe_VkPipelineVertexInputDivisorStateCreateInfoEXT {
6526     VkStructureType sType;
6527     const void* pNext;
6528     uint32_t vertexBindingDivisorCount;
6529     const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors;
6530     safe_VkPipelineVertexInputDivisorStateCreateInfoEXT(const VkPipelineVertexInputDivisorStateCreateInfoEXT* in_struct);
6531     safe_VkPipelineVertexInputDivisorStateCreateInfoEXT(const safe_VkPipelineVertexInputDivisorStateCreateInfoEXT& copy_src);
6532     safe_VkPipelineVertexInputDivisorStateCreateInfoEXT& operator=(const safe_VkPipelineVertexInputDivisorStateCreateInfoEXT& copy_src);
6533     safe_VkPipelineVertexInputDivisorStateCreateInfoEXT();
6534     ~safe_VkPipelineVertexInputDivisorStateCreateInfoEXT();
6535     void initialize(const VkPipelineVertexInputDivisorStateCreateInfoEXT* in_struct);
6536     void initialize(const safe_VkPipelineVertexInputDivisorStateCreateInfoEXT* copy_src);
ptrsafe_VkPipelineVertexInputDivisorStateCreateInfoEXT6537     VkPipelineVertexInputDivisorStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT *>(this); }
ptrsafe_VkPipelineVertexInputDivisorStateCreateInfoEXT6538     VkPipelineVertexInputDivisorStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT const *>(this); }
6539 };
6540 
6541 struct safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT {
6542     VkStructureType sType;
6543     void* pNext;
6544     VkBool32 vertexAttributeInstanceRateDivisor;
6545     VkBool32 vertexAttributeInstanceRateZeroDivisor;
6546     safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* in_struct);
6547     safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& copy_src);
6548     safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& operator=(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& copy_src);
6549     safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT();
6550     ~safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT();
6551     void initialize(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* in_struct);
6552     void initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT6553     VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT6554     VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const *>(this); }
6555 };
6556 
6557 #ifdef VK_USE_PLATFORM_GGP
6558 struct safe_VkPresentFrameTokenGGP {
6559     VkStructureType sType;
6560     const void* pNext;
6561     GgpFrameToken frameToken;
6562     safe_VkPresentFrameTokenGGP(const VkPresentFrameTokenGGP* in_struct);
6563     safe_VkPresentFrameTokenGGP(const safe_VkPresentFrameTokenGGP& copy_src);
6564     safe_VkPresentFrameTokenGGP& operator=(const safe_VkPresentFrameTokenGGP& copy_src);
6565     safe_VkPresentFrameTokenGGP();
6566     ~safe_VkPresentFrameTokenGGP();
6567     void initialize(const VkPresentFrameTokenGGP* in_struct);
6568     void initialize(const safe_VkPresentFrameTokenGGP* copy_src);
ptrsafe_VkPresentFrameTokenGGP6569     VkPresentFrameTokenGGP *ptr() { return reinterpret_cast<VkPresentFrameTokenGGP *>(this); }
ptrsafe_VkPresentFrameTokenGGP6570     VkPresentFrameTokenGGP const *ptr() const { return reinterpret_cast<VkPresentFrameTokenGGP const *>(this); }
6571 };
6572 #endif // VK_USE_PLATFORM_GGP
6573 
6574 struct safe_VkPipelineCreationFeedbackCreateInfoEXT {
6575     VkStructureType sType;
6576     const void* pNext;
6577     VkPipelineCreationFeedbackEXT* pPipelineCreationFeedback;
6578     uint32_t pipelineStageCreationFeedbackCount;
6579     VkPipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks;
6580     safe_VkPipelineCreationFeedbackCreateInfoEXT(const VkPipelineCreationFeedbackCreateInfoEXT* in_struct);
6581     safe_VkPipelineCreationFeedbackCreateInfoEXT(const safe_VkPipelineCreationFeedbackCreateInfoEXT& copy_src);
6582     safe_VkPipelineCreationFeedbackCreateInfoEXT& operator=(const safe_VkPipelineCreationFeedbackCreateInfoEXT& copy_src);
6583     safe_VkPipelineCreationFeedbackCreateInfoEXT();
6584     ~safe_VkPipelineCreationFeedbackCreateInfoEXT();
6585     void initialize(const VkPipelineCreationFeedbackCreateInfoEXT* in_struct);
6586     void initialize(const safe_VkPipelineCreationFeedbackCreateInfoEXT* copy_src);
ptrsafe_VkPipelineCreationFeedbackCreateInfoEXT6587     VkPipelineCreationFeedbackCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT *>(this); }
ptrsafe_VkPipelineCreationFeedbackCreateInfoEXT6588     VkPipelineCreationFeedbackCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT const *>(this); }
6589 };
6590 
6591 struct safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV {
6592     VkStructureType sType;
6593     void* pNext;
6594     VkBool32 computeDerivativeGroupQuads;
6595     VkBool32 computeDerivativeGroupLinear;
6596     safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct);
6597     safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& copy_src);
6598     safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=(const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& copy_src);
6599     safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV();
6600     ~safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV();
6601     void initialize(const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct);
6602     void initialize(const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* copy_src);
ptrsafe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV6603     VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>(this); }
ptrsafe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV6604     VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const *>(this); }
6605 };
6606 
6607 struct safe_VkPhysicalDeviceMeshShaderFeaturesNV {
6608     VkStructureType sType;
6609     void* pNext;
6610     VkBool32 taskShader;
6611     VkBool32 meshShader;
6612     safe_VkPhysicalDeviceMeshShaderFeaturesNV(const VkPhysicalDeviceMeshShaderFeaturesNV* in_struct);
6613     safe_VkPhysicalDeviceMeshShaderFeaturesNV(const safe_VkPhysicalDeviceMeshShaderFeaturesNV& copy_src);
6614     safe_VkPhysicalDeviceMeshShaderFeaturesNV& operator=(const safe_VkPhysicalDeviceMeshShaderFeaturesNV& copy_src);
6615     safe_VkPhysicalDeviceMeshShaderFeaturesNV();
6616     ~safe_VkPhysicalDeviceMeshShaderFeaturesNV();
6617     void initialize(const VkPhysicalDeviceMeshShaderFeaturesNV* in_struct);
6618     void initialize(const safe_VkPhysicalDeviceMeshShaderFeaturesNV* copy_src);
ptrsafe_VkPhysicalDeviceMeshShaderFeaturesNV6619     VkPhysicalDeviceMeshShaderFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV *>(this); }
ptrsafe_VkPhysicalDeviceMeshShaderFeaturesNV6620     VkPhysicalDeviceMeshShaderFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV const *>(this); }
6621 };
6622 
6623 struct safe_VkPhysicalDeviceMeshShaderPropertiesNV {
6624     VkStructureType sType;
6625     void* pNext;
6626     uint32_t maxDrawMeshTasksCount;
6627     uint32_t maxTaskWorkGroupInvocations;
6628     uint32_t maxTaskWorkGroupSize[3];
6629     uint32_t maxTaskTotalMemorySize;
6630     uint32_t maxTaskOutputCount;
6631     uint32_t maxMeshWorkGroupInvocations;
6632     uint32_t maxMeshWorkGroupSize[3];
6633     uint32_t maxMeshTotalMemorySize;
6634     uint32_t maxMeshOutputVertices;
6635     uint32_t maxMeshOutputPrimitives;
6636     uint32_t maxMeshMultiviewViewCount;
6637     uint32_t meshOutputPerVertexGranularity;
6638     uint32_t meshOutputPerPrimitiveGranularity;
6639     safe_VkPhysicalDeviceMeshShaderPropertiesNV(const VkPhysicalDeviceMeshShaderPropertiesNV* in_struct);
6640     safe_VkPhysicalDeviceMeshShaderPropertiesNV(const safe_VkPhysicalDeviceMeshShaderPropertiesNV& copy_src);
6641     safe_VkPhysicalDeviceMeshShaderPropertiesNV& operator=(const safe_VkPhysicalDeviceMeshShaderPropertiesNV& copy_src);
6642     safe_VkPhysicalDeviceMeshShaderPropertiesNV();
6643     ~safe_VkPhysicalDeviceMeshShaderPropertiesNV();
6644     void initialize(const VkPhysicalDeviceMeshShaderPropertiesNV* in_struct);
6645     void initialize(const safe_VkPhysicalDeviceMeshShaderPropertiesNV* copy_src);
ptrsafe_VkPhysicalDeviceMeshShaderPropertiesNV6646     VkPhysicalDeviceMeshShaderPropertiesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV *>(this); }
ptrsafe_VkPhysicalDeviceMeshShaderPropertiesNV6647     VkPhysicalDeviceMeshShaderPropertiesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV const *>(this); }
6648 };
6649 
6650 struct safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV {
6651     VkStructureType sType;
6652     void* pNext;
6653     VkBool32 fragmentShaderBarycentric;
6654     safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* in_struct);
6655     safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV& copy_src);
6656     safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV& operator=(const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV& copy_src);
6657     safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV();
6658     ~safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV();
6659     void initialize(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* in_struct);
6660     void initialize(const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* copy_src);
ptrsafe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV6661     VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *>(this); }
ptrsafe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV6662     VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const *>(this); }
6663 };
6664 
6665 struct safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV {
6666     VkStructureType sType;
6667     void* pNext;
6668     VkBool32 imageFootprint;
6669     safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(const VkPhysicalDeviceShaderImageFootprintFeaturesNV* in_struct);
6670     safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& copy_src);
6671     safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& operator=(const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& copy_src);
6672     safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV();
6673     ~safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV();
6674     void initialize(const VkPhysicalDeviceShaderImageFootprintFeaturesNV* in_struct);
6675     void initialize(const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV* copy_src);
ptrsafe_VkPhysicalDeviceShaderImageFootprintFeaturesNV6676     VkPhysicalDeviceShaderImageFootprintFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV *>(this); }
ptrsafe_VkPhysicalDeviceShaderImageFootprintFeaturesNV6677     VkPhysicalDeviceShaderImageFootprintFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV const *>(this); }
6678 };
6679 
6680 struct safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV {
6681     VkStructureType sType;
6682     const void* pNext;
6683     uint32_t exclusiveScissorCount;
6684     const VkRect2D* pExclusiveScissors;
6685     safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(const VkPipelineViewportExclusiveScissorStateCreateInfoNV* in_struct);
6686     safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& copy_src);
6687     safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& operator=(const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& copy_src);
6688     safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV();
6689     ~safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV();
6690     void initialize(const VkPipelineViewportExclusiveScissorStateCreateInfoNV* in_struct);
6691     void initialize(const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV* copy_src);
ptrsafe_VkPipelineViewportExclusiveScissorStateCreateInfoNV6692     VkPipelineViewportExclusiveScissorStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV *>(this); }
ptrsafe_VkPipelineViewportExclusiveScissorStateCreateInfoNV6693     VkPipelineViewportExclusiveScissorStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV const *>(this); }
6694 };
6695 
6696 struct safe_VkPhysicalDeviceExclusiveScissorFeaturesNV {
6697     VkStructureType sType;
6698     void* pNext;
6699     VkBool32 exclusiveScissor;
6700     safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(const VkPhysicalDeviceExclusiveScissorFeaturesNV* in_struct);
6701     safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& copy_src);
6702     safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& operator=(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& copy_src);
6703     safe_VkPhysicalDeviceExclusiveScissorFeaturesNV();
6704     ~safe_VkPhysicalDeviceExclusiveScissorFeaturesNV();
6705     void initialize(const VkPhysicalDeviceExclusiveScissorFeaturesNV* in_struct);
6706     void initialize(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV* copy_src);
ptrsafe_VkPhysicalDeviceExclusiveScissorFeaturesNV6707     VkPhysicalDeviceExclusiveScissorFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV *>(this); }
ptrsafe_VkPhysicalDeviceExclusiveScissorFeaturesNV6708     VkPhysicalDeviceExclusiveScissorFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV const *>(this); }
6709 };
6710 
6711 struct safe_VkQueueFamilyCheckpointPropertiesNV {
6712     VkStructureType sType;
6713     void* pNext;
6714     VkPipelineStageFlags checkpointExecutionStageMask;
6715     safe_VkQueueFamilyCheckpointPropertiesNV(const VkQueueFamilyCheckpointPropertiesNV* in_struct);
6716     safe_VkQueueFamilyCheckpointPropertiesNV(const safe_VkQueueFamilyCheckpointPropertiesNV& copy_src);
6717     safe_VkQueueFamilyCheckpointPropertiesNV& operator=(const safe_VkQueueFamilyCheckpointPropertiesNV& copy_src);
6718     safe_VkQueueFamilyCheckpointPropertiesNV();
6719     ~safe_VkQueueFamilyCheckpointPropertiesNV();
6720     void initialize(const VkQueueFamilyCheckpointPropertiesNV* in_struct);
6721     void initialize(const safe_VkQueueFamilyCheckpointPropertiesNV* copy_src);
ptrsafe_VkQueueFamilyCheckpointPropertiesNV6722     VkQueueFamilyCheckpointPropertiesNV *ptr() { return reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV *>(this); }
ptrsafe_VkQueueFamilyCheckpointPropertiesNV6723     VkQueueFamilyCheckpointPropertiesNV const *ptr() const { return reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV const *>(this); }
6724 };
6725 
6726 struct safe_VkCheckpointDataNV {
6727     VkStructureType sType;
6728     void* pNext;
6729     VkPipelineStageFlagBits stage;
6730     void* pCheckpointMarker;
6731     safe_VkCheckpointDataNV(const VkCheckpointDataNV* in_struct);
6732     safe_VkCheckpointDataNV(const safe_VkCheckpointDataNV& copy_src);
6733     safe_VkCheckpointDataNV& operator=(const safe_VkCheckpointDataNV& copy_src);
6734     safe_VkCheckpointDataNV();
6735     ~safe_VkCheckpointDataNV();
6736     void initialize(const VkCheckpointDataNV* in_struct);
6737     void initialize(const safe_VkCheckpointDataNV* copy_src);
ptrsafe_VkCheckpointDataNV6738     VkCheckpointDataNV *ptr() { return reinterpret_cast<VkCheckpointDataNV *>(this); }
ptrsafe_VkCheckpointDataNV6739     VkCheckpointDataNV const *ptr() const { return reinterpret_cast<VkCheckpointDataNV const *>(this); }
6740 };
6741 
6742 struct safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
6743     VkStructureType sType;
6744     void* pNext;
6745     VkBool32 shaderIntegerFunctions2;
6746     safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct);
6747     safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& copy_src);
6748     safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& operator=(const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& copy_src);
6749     safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL();
6750     ~safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL();
6751     void initialize(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct);
6752     void initialize(const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* copy_src);
ptrsafe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL6753     VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>(this); }
ptrsafe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL6754     VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const *>(this); }
6755 };
6756 
6757 union safe_VkPerformanceValueDataINTEL {
6758     uint32_t value32;
6759     uint64_t value64;
6760     float valueFloat;
6761     VkBool32 valueBool;
6762     const char* valueString;
6763     safe_VkPerformanceValueDataINTEL(const VkPerformanceValueDataINTEL* in_struct);
6764     safe_VkPerformanceValueDataINTEL(const safe_VkPerformanceValueDataINTEL& copy_src);
6765     safe_VkPerformanceValueDataINTEL& operator=(const safe_VkPerformanceValueDataINTEL& copy_src);
6766     safe_VkPerformanceValueDataINTEL();
6767     ~safe_VkPerformanceValueDataINTEL();
6768     void initialize(const VkPerformanceValueDataINTEL* in_struct);
6769     void initialize(const safe_VkPerformanceValueDataINTEL* copy_src);
ptr()6770     VkPerformanceValueDataINTEL *ptr() { return reinterpret_cast<VkPerformanceValueDataINTEL *>(this); }
ptr()6771     VkPerformanceValueDataINTEL const *ptr() const { return reinterpret_cast<VkPerformanceValueDataINTEL const *>(this); }
6772 };
6773 
6774 struct safe_VkInitializePerformanceApiInfoINTEL {
6775     VkStructureType sType;
6776     const void* pNext;
6777     void* pUserData;
6778     safe_VkInitializePerformanceApiInfoINTEL(const VkInitializePerformanceApiInfoINTEL* in_struct);
6779     safe_VkInitializePerformanceApiInfoINTEL(const safe_VkInitializePerformanceApiInfoINTEL& copy_src);
6780     safe_VkInitializePerformanceApiInfoINTEL& operator=(const safe_VkInitializePerformanceApiInfoINTEL& copy_src);
6781     safe_VkInitializePerformanceApiInfoINTEL();
6782     ~safe_VkInitializePerformanceApiInfoINTEL();
6783     void initialize(const VkInitializePerformanceApiInfoINTEL* in_struct);
6784     void initialize(const safe_VkInitializePerformanceApiInfoINTEL* copy_src);
ptrsafe_VkInitializePerformanceApiInfoINTEL6785     VkInitializePerformanceApiInfoINTEL *ptr() { return reinterpret_cast<VkInitializePerformanceApiInfoINTEL *>(this); }
ptrsafe_VkInitializePerformanceApiInfoINTEL6786     VkInitializePerformanceApiInfoINTEL const *ptr() const { return reinterpret_cast<VkInitializePerformanceApiInfoINTEL const *>(this); }
6787 };
6788 
6789 struct safe_VkQueryPoolPerformanceQueryCreateInfoINTEL {
6790     VkStructureType sType;
6791     const void* pNext;
6792     VkQueryPoolSamplingModeINTEL performanceCountersSampling;
6793     safe_VkQueryPoolPerformanceQueryCreateInfoINTEL(const VkQueryPoolPerformanceQueryCreateInfoINTEL* in_struct);
6794     safe_VkQueryPoolPerformanceQueryCreateInfoINTEL(const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL& copy_src);
6795     safe_VkQueryPoolPerformanceQueryCreateInfoINTEL& operator=(const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL& copy_src);
6796     safe_VkQueryPoolPerformanceQueryCreateInfoINTEL();
6797     ~safe_VkQueryPoolPerformanceQueryCreateInfoINTEL();
6798     void initialize(const VkQueryPoolPerformanceQueryCreateInfoINTEL* in_struct);
6799     void initialize(const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL* copy_src);
ptrsafe_VkQueryPoolPerformanceQueryCreateInfoINTEL6800     VkQueryPoolPerformanceQueryCreateInfoINTEL *ptr() { return reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL *>(this); }
ptrsafe_VkQueryPoolPerformanceQueryCreateInfoINTEL6801     VkQueryPoolPerformanceQueryCreateInfoINTEL const *ptr() const { return reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL const *>(this); }
6802 };
6803 
6804 struct safe_VkPerformanceMarkerInfoINTEL {
6805     VkStructureType sType;
6806     const void* pNext;
6807     uint64_t marker;
6808     safe_VkPerformanceMarkerInfoINTEL(const VkPerformanceMarkerInfoINTEL* in_struct);
6809     safe_VkPerformanceMarkerInfoINTEL(const safe_VkPerformanceMarkerInfoINTEL& copy_src);
6810     safe_VkPerformanceMarkerInfoINTEL& operator=(const safe_VkPerformanceMarkerInfoINTEL& copy_src);
6811     safe_VkPerformanceMarkerInfoINTEL();
6812     ~safe_VkPerformanceMarkerInfoINTEL();
6813     void initialize(const VkPerformanceMarkerInfoINTEL* in_struct);
6814     void initialize(const safe_VkPerformanceMarkerInfoINTEL* copy_src);
ptrsafe_VkPerformanceMarkerInfoINTEL6815     VkPerformanceMarkerInfoINTEL *ptr() { return reinterpret_cast<VkPerformanceMarkerInfoINTEL *>(this); }
ptrsafe_VkPerformanceMarkerInfoINTEL6816     VkPerformanceMarkerInfoINTEL const *ptr() const { return reinterpret_cast<VkPerformanceMarkerInfoINTEL const *>(this); }
6817 };
6818 
6819 struct safe_VkPerformanceStreamMarkerInfoINTEL {
6820     VkStructureType sType;
6821     const void* pNext;
6822     uint32_t marker;
6823     safe_VkPerformanceStreamMarkerInfoINTEL(const VkPerformanceStreamMarkerInfoINTEL* in_struct);
6824     safe_VkPerformanceStreamMarkerInfoINTEL(const safe_VkPerformanceStreamMarkerInfoINTEL& copy_src);
6825     safe_VkPerformanceStreamMarkerInfoINTEL& operator=(const safe_VkPerformanceStreamMarkerInfoINTEL& copy_src);
6826     safe_VkPerformanceStreamMarkerInfoINTEL();
6827     ~safe_VkPerformanceStreamMarkerInfoINTEL();
6828     void initialize(const VkPerformanceStreamMarkerInfoINTEL* in_struct);
6829     void initialize(const safe_VkPerformanceStreamMarkerInfoINTEL* copy_src);
ptrsafe_VkPerformanceStreamMarkerInfoINTEL6830     VkPerformanceStreamMarkerInfoINTEL *ptr() { return reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL *>(this); }
ptrsafe_VkPerformanceStreamMarkerInfoINTEL6831     VkPerformanceStreamMarkerInfoINTEL const *ptr() const { return reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL const *>(this); }
6832 };
6833 
6834 struct safe_VkPerformanceOverrideInfoINTEL {
6835     VkStructureType sType;
6836     const void* pNext;
6837     VkPerformanceOverrideTypeINTEL type;
6838     VkBool32 enable;
6839     uint64_t parameter;
6840     safe_VkPerformanceOverrideInfoINTEL(const VkPerformanceOverrideInfoINTEL* in_struct);
6841     safe_VkPerformanceOverrideInfoINTEL(const safe_VkPerformanceOverrideInfoINTEL& copy_src);
6842     safe_VkPerformanceOverrideInfoINTEL& operator=(const safe_VkPerformanceOverrideInfoINTEL& copy_src);
6843     safe_VkPerformanceOverrideInfoINTEL();
6844     ~safe_VkPerformanceOverrideInfoINTEL();
6845     void initialize(const VkPerformanceOverrideInfoINTEL* in_struct);
6846     void initialize(const safe_VkPerformanceOverrideInfoINTEL* copy_src);
ptrsafe_VkPerformanceOverrideInfoINTEL6847     VkPerformanceOverrideInfoINTEL *ptr() { return reinterpret_cast<VkPerformanceOverrideInfoINTEL *>(this); }
ptrsafe_VkPerformanceOverrideInfoINTEL6848     VkPerformanceOverrideInfoINTEL const *ptr() const { return reinterpret_cast<VkPerformanceOverrideInfoINTEL const *>(this); }
6849 };
6850 
6851 struct safe_VkPerformanceConfigurationAcquireInfoINTEL {
6852     VkStructureType sType;
6853     const void* pNext;
6854     VkPerformanceConfigurationTypeINTEL type;
6855     safe_VkPerformanceConfigurationAcquireInfoINTEL(const VkPerformanceConfigurationAcquireInfoINTEL* in_struct);
6856     safe_VkPerformanceConfigurationAcquireInfoINTEL(const safe_VkPerformanceConfigurationAcquireInfoINTEL& copy_src);
6857     safe_VkPerformanceConfigurationAcquireInfoINTEL& operator=(const safe_VkPerformanceConfigurationAcquireInfoINTEL& copy_src);
6858     safe_VkPerformanceConfigurationAcquireInfoINTEL();
6859     ~safe_VkPerformanceConfigurationAcquireInfoINTEL();
6860     void initialize(const VkPerformanceConfigurationAcquireInfoINTEL* in_struct);
6861     void initialize(const safe_VkPerformanceConfigurationAcquireInfoINTEL* copy_src);
ptrsafe_VkPerformanceConfigurationAcquireInfoINTEL6862     VkPerformanceConfigurationAcquireInfoINTEL *ptr() { return reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL *>(this); }
ptrsafe_VkPerformanceConfigurationAcquireInfoINTEL6863     VkPerformanceConfigurationAcquireInfoINTEL const *ptr() const { return reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL const *>(this); }
6864 };
6865 
6866 struct safe_VkPhysicalDevicePCIBusInfoPropertiesEXT {
6867     VkStructureType sType;
6868     void* pNext;
6869     uint32_t pciDomain;
6870     uint32_t pciBus;
6871     uint32_t pciDevice;
6872     uint32_t pciFunction;
6873     safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(const VkPhysicalDevicePCIBusInfoPropertiesEXT* in_struct);
6874     safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& copy_src);
6875     safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& operator=(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& copy_src);
6876     safe_VkPhysicalDevicePCIBusInfoPropertiesEXT();
6877     ~safe_VkPhysicalDevicePCIBusInfoPropertiesEXT();
6878     void initialize(const VkPhysicalDevicePCIBusInfoPropertiesEXT* in_struct);
6879     void initialize(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT* copy_src);
ptrsafe_VkPhysicalDevicePCIBusInfoPropertiesEXT6880     VkPhysicalDevicePCIBusInfoPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT *>(this); }
ptrsafe_VkPhysicalDevicePCIBusInfoPropertiesEXT6881     VkPhysicalDevicePCIBusInfoPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT const *>(this); }
6882 };
6883 
6884 struct safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD {
6885     VkStructureType sType;
6886     void* pNext;
6887     VkBool32 localDimmingSupport;
6888     safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(const VkDisplayNativeHdrSurfaceCapabilitiesAMD* in_struct);
6889     safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& copy_src);
6890     safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& operator=(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& copy_src);
6891     safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD();
6892     ~safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD();
6893     void initialize(const VkDisplayNativeHdrSurfaceCapabilitiesAMD* in_struct);
6894     void initialize(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD* copy_src);
ptrsafe_VkDisplayNativeHdrSurfaceCapabilitiesAMD6895     VkDisplayNativeHdrSurfaceCapabilitiesAMD *ptr() { return reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD *>(this); }
ptrsafe_VkDisplayNativeHdrSurfaceCapabilitiesAMD6896     VkDisplayNativeHdrSurfaceCapabilitiesAMD const *ptr() const { return reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD const *>(this); }
6897 };
6898 
6899 struct safe_VkSwapchainDisplayNativeHdrCreateInfoAMD {
6900     VkStructureType sType;
6901     const void* pNext;
6902     VkBool32 localDimmingEnable;
6903     safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(const VkSwapchainDisplayNativeHdrCreateInfoAMD* in_struct);
6904     safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& copy_src);
6905     safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& operator=(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& copy_src);
6906     safe_VkSwapchainDisplayNativeHdrCreateInfoAMD();
6907     ~safe_VkSwapchainDisplayNativeHdrCreateInfoAMD();
6908     void initialize(const VkSwapchainDisplayNativeHdrCreateInfoAMD* in_struct);
6909     void initialize(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD* copy_src);
ptrsafe_VkSwapchainDisplayNativeHdrCreateInfoAMD6910     VkSwapchainDisplayNativeHdrCreateInfoAMD *ptr() { return reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD *>(this); }
ptrsafe_VkSwapchainDisplayNativeHdrCreateInfoAMD6911     VkSwapchainDisplayNativeHdrCreateInfoAMD const *ptr() const { return reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD const *>(this); }
6912 };
6913 
6914 #ifdef VK_USE_PLATFORM_FUCHSIA
6915 struct safe_VkImagePipeSurfaceCreateInfoFUCHSIA {
6916     VkStructureType sType;
6917     const void* pNext;
6918     VkImagePipeSurfaceCreateFlagsFUCHSIA flags;
6919     zx_handle_t imagePipeHandle;
6920     safe_VkImagePipeSurfaceCreateInfoFUCHSIA(const VkImagePipeSurfaceCreateInfoFUCHSIA* in_struct);
6921     safe_VkImagePipeSurfaceCreateInfoFUCHSIA(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA& copy_src);
6922     safe_VkImagePipeSurfaceCreateInfoFUCHSIA& operator=(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA& copy_src);
6923     safe_VkImagePipeSurfaceCreateInfoFUCHSIA();
6924     ~safe_VkImagePipeSurfaceCreateInfoFUCHSIA();
6925     void initialize(const VkImagePipeSurfaceCreateInfoFUCHSIA* in_struct);
6926     void initialize(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA* copy_src);
ptrsafe_VkImagePipeSurfaceCreateInfoFUCHSIA6927     VkImagePipeSurfaceCreateInfoFUCHSIA *ptr() { return reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA *>(this); }
ptrsafe_VkImagePipeSurfaceCreateInfoFUCHSIA6928     VkImagePipeSurfaceCreateInfoFUCHSIA const *ptr() const { return reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA const *>(this); }
6929 };
6930 #endif // VK_USE_PLATFORM_FUCHSIA
6931 
6932 #ifdef VK_USE_PLATFORM_METAL_EXT
6933 struct safe_VkMetalSurfaceCreateInfoEXT {
6934     VkStructureType sType;
6935     const void* pNext;
6936     VkMetalSurfaceCreateFlagsEXT flags;
6937     const CAMetalLayer* pLayer;
6938     safe_VkMetalSurfaceCreateInfoEXT(const VkMetalSurfaceCreateInfoEXT* in_struct);
6939     safe_VkMetalSurfaceCreateInfoEXT(const safe_VkMetalSurfaceCreateInfoEXT& copy_src);
6940     safe_VkMetalSurfaceCreateInfoEXT& operator=(const safe_VkMetalSurfaceCreateInfoEXT& copy_src);
6941     safe_VkMetalSurfaceCreateInfoEXT();
6942     ~safe_VkMetalSurfaceCreateInfoEXT();
6943     void initialize(const VkMetalSurfaceCreateInfoEXT* in_struct);
6944     void initialize(const safe_VkMetalSurfaceCreateInfoEXT* copy_src);
ptrsafe_VkMetalSurfaceCreateInfoEXT6945     VkMetalSurfaceCreateInfoEXT *ptr() { return reinterpret_cast<VkMetalSurfaceCreateInfoEXT *>(this); }
ptrsafe_VkMetalSurfaceCreateInfoEXT6946     VkMetalSurfaceCreateInfoEXT const *ptr() const { return reinterpret_cast<VkMetalSurfaceCreateInfoEXT const *>(this); }
6947 };
6948 #endif // VK_USE_PLATFORM_METAL_EXT
6949 
6950 struct safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT {
6951     VkStructureType sType;
6952     void* pNext;
6953     VkBool32 fragmentDensityMap;
6954     VkBool32 fragmentDensityMapDynamic;
6955     VkBool32 fragmentDensityMapNonSubsampledImages;
6956     safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* in_struct);
6957     safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& copy_src);
6958     safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& operator=(const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& copy_src);
6959     safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT();
6960     ~safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT();
6961     void initialize(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* in_struct);
6962     void initialize(const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT6963     VkPhysicalDeviceFragmentDensityMapFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT6964     VkPhysicalDeviceFragmentDensityMapFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT const *>(this); }
6965 };
6966 
6967 struct safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT {
6968     VkStructureType sType;
6969     void* pNext;
6970     VkExtent2D minFragmentDensityTexelSize;
6971     VkExtent2D maxFragmentDensityTexelSize;
6972     VkBool32 fragmentDensityInvocations;
6973     safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* in_struct);
6974     safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& copy_src);
6975     safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& operator=(const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& copy_src);
6976     safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT();
6977     ~safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT();
6978     void initialize(const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* in_struct);
6979     void initialize(const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT* copy_src);
ptrsafe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT6980     VkPhysicalDeviceFragmentDensityMapPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT *>(this); }
ptrsafe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT6981     VkPhysicalDeviceFragmentDensityMapPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT const *>(this); }
6982 };
6983 
6984 struct safe_VkRenderPassFragmentDensityMapCreateInfoEXT {
6985     VkStructureType sType;
6986     const void* pNext;
6987     VkAttachmentReference fragmentDensityMapAttachment;
6988     safe_VkRenderPassFragmentDensityMapCreateInfoEXT(const VkRenderPassFragmentDensityMapCreateInfoEXT* in_struct);
6989     safe_VkRenderPassFragmentDensityMapCreateInfoEXT(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT& copy_src);
6990     safe_VkRenderPassFragmentDensityMapCreateInfoEXT& operator=(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT& copy_src);
6991     safe_VkRenderPassFragmentDensityMapCreateInfoEXT();
6992     ~safe_VkRenderPassFragmentDensityMapCreateInfoEXT();
6993     void initialize(const VkRenderPassFragmentDensityMapCreateInfoEXT* in_struct);
6994     void initialize(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT* copy_src);
ptrsafe_VkRenderPassFragmentDensityMapCreateInfoEXT6995     VkRenderPassFragmentDensityMapCreateInfoEXT *ptr() { return reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT *>(this); }
ptrsafe_VkRenderPassFragmentDensityMapCreateInfoEXT6996     VkRenderPassFragmentDensityMapCreateInfoEXT const *ptr() const { return reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT const *>(this); }
6997 };
6998 
6999 struct safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT {
7000     VkStructureType sType;
7001     void* pNext;
7002     VkBool32 subgroupSizeControl;
7003     VkBool32 computeFullSubgroups;
7004     safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* in_struct);
7005     safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(const safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& copy_src);
7006     safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& operator=(const safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& copy_src);
7007     safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT();
7008     ~safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT();
7009     void initialize(const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* in_struct);
7010     void initialize(const safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT7011     VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT7012     VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const *>(this); }
7013 };
7014 
7015 struct safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT {
7016     VkStructureType sType;
7017     void* pNext;
7018     uint32_t minSubgroupSize;
7019     uint32_t maxSubgroupSize;
7020     uint32_t maxComputeWorkgroupSubgroups;
7021     VkShaderStageFlags requiredSubgroupSizeStages;
7022     safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* in_struct);
7023     safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(const safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT& copy_src);
7024     safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT& operator=(const safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT& copy_src);
7025     safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT();
7026     ~safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT();
7027     void initialize(const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* in_struct);
7028     void initialize(const safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* copy_src);
ptrsafe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT7029     VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *>(this); }
ptrsafe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT7030     VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const *>(this); }
7031 };
7032 
7033 struct safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
7034     VkStructureType sType;
7035     void* pNext;
7036     uint32_t requiredSubgroupSize;
7037     safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* in_struct);
7038     safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& copy_src);
7039     safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& operator=(const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& copy_src);
7040     safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT();
7041     ~safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT();
7042     void initialize(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* in_struct);
7043     void initialize(const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* copy_src);
ptrsafe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT7044     VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *>(this); }
ptrsafe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT7045     VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const *>(this); }
7046 };
7047 
7048 struct safe_VkPhysicalDeviceShaderCoreProperties2AMD {
7049     VkStructureType sType;
7050     void* pNext;
7051     VkShaderCorePropertiesFlagsAMD shaderCoreFeatures;
7052     uint32_t activeComputeUnitCount;
7053     safe_VkPhysicalDeviceShaderCoreProperties2AMD(const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct);
7054     safe_VkPhysicalDeviceShaderCoreProperties2AMD(const safe_VkPhysicalDeviceShaderCoreProperties2AMD& copy_src);
7055     safe_VkPhysicalDeviceShaderCoreProperties2AMD& operator=(const safe_VkPhysicalDeviceShaderCoreProperties2AMD& copy_src);
7056     safe_VkPhysicalDeviceShaderCoreProperties2AMD();
7057     ~safe_VkPhysicalDeviceShaderCoreProperties2AMD();
7058     void initialize(const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct);
7059     void initialize(const safe_VkPhysicalDeviceShaderCoreProperties2AMD* copy_src);
ptrsafe_VkPhysicalDeviceShaderCoreProperties2AMD7060     VkPhysicalDeviceShaderCoreProperties2AMD *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD *>(this); }
ptrsafe_VkPhysicalDeviceShaderCoreProperties2AMD7061     VkPhysicalDeviceShaderCoreProperties2AMD const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD const *>(this); }
7062 };
7063 
7064 struct safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD {
7065     VkStructureType sType;
7066     void* pNext;
7067     VkBool32 deviceCoherentMemory;
7068     safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct);
7069     safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& copy_src);
7070     safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& operator=(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& copy_src);
7071     safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD();
7072     ~safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD();
7073     void initialize(const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct);
7074     void initialize(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD* copy_src);
ptrsafe_VkPhysicalDeviceCoherentMemoryFeaturesAMD7075     VkPhysicalDeviceCoherentMemoryFeaturesAMD *ptr() { return reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD *>(this); }
ptrsafe_VkPhysicalDeviceCoherentMemoryFeaturesAMD7076     VkPhysicalDeviceCoherentMemoryFeaturesAMD const *ptr() const { return reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD const *>(this); }
7077 };
7078 
7079 struct safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
7080     VkStructureType sType;
7081     void* pNext;
7082     VkBool32 shaderImageInt64Atomics;
7083     VkBool32 sparseImageInt64Atomics;
7084     safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* in_struct);
7085     safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& copy_src);
7086     safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& operator=(const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& copy_src);
7087     safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT();
7088     ~safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT();
7089     void initialize(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* in_struct);
7090     void initialize(const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT7091     VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT7092     VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const *>(this); }
7093 };
7094 
7095 struct safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT {
7096     VkStructureType sType;
7097     void* pNext;
7098     VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS];
7099     VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS];
7100     safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const VkPhysicalDeviceMemoryBudgetPropertiesEXT* in_struct);
7101     safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& copy_src);
7102     safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& operator=(const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& copy_src);
7103     safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT();
7104     ~safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT();
7105     void initialize(const VkPhysicalDeviceMemoryBudgetPropertiesEXT* in_struct);
7106     void initialize(const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT* copy_src);
ptrsafe_VkPhysicalDeviceMemoryBudgetPropertiesEXT7107     VkPhysicalDeviceMemoryBudgetPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT *>(this); }
ptrsafe_VkPhysicalDeviceMemoryBudgetPropertiesEXT7108     VkPhysicalDeviceMemoryBudgetPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT const *>(this); }
7109 };
7110 
7111 struct safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT {
7112     VkStructureType sType;
7113     void* pNext;
7114     VkBool32 memoryPriority;
7115     safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(const VkPhysicalDeviceMemoryPriorityFeaturesEXT* in_struct);
7116     safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& copy_src);
7117     safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& operator=(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& copy_src);
7118     safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT();
7119     ~safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT();
7120     void initialize(const VkPhysicalDeviceMemoryPriorityFeaturesEXT* in_struct);
7121     void initialize(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceMemoryPriorityFeaturesEXT7122     VkPhysicalDeviceMemoryPriorityFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceMemoryPriorityFeaturesEXT7123     VkPhysicalDeviceMemoryPriorityFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT const *>(this); }
7124 };
7125 
7126 struct safe_VkMemoryPriorityAllocateInfoEXT {
7127     VkStructureType sType;
7128     const void* pNext;
7129     float priority;
7130     safe_VkMemoryPriorityAllocateInfoEXT(const VkMemoryPriorityAllocateInfoEXT* in_struct);
7131     safe_VkMemoryPriorityAllocateInfoEXT(const safe_VkMemoryPriorityAllocateInfoEXT& copy_src);
7132     safe_VkMemoryPriorityAllocateInfoEXT& operator=(const safe_VkMemoryPriorityAllocateInfoEXT& copy_src);
7133     safe_VkMemoryPriorityAllocateInfoEXT();
7134     ~safe_VkMemoryPriorityAllocateInfoEXT();
7135     void initialize(const VkMemoryPriorityAllocateInfoEXT* in_struct);
7136     void initialize(const safe_VkMemoryPriorityAllocateInfoEXT* copy_src);
ptrsafe_VkMemoryPriorityAllocateInfoEXT7137     VkMemoryPriorityAllocateInfoEXT *ptr() { return reinterpret_cast<VkMemoryPriorityAllocateInfoEXT *>(this); }
ptrsafe_VkMemoryPriorityAllocateInfoEXT7138     VkMemoryPriorityAllocateInfoEXT const *ptr() const { return reinterpret_cast<VkMemoryPriorityAllocateInfoEXT const *>(this); }
7139 };
7140 
7141 struct safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
7142     VkStructureType sType;
7143     void* pNext;
7144     VkBool32 dedicatedAllocationImageAliasing;
7145     safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* in_struct);
7146     safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& copy_src);
7147     safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& operator=(const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& copy_src);
7148     safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV();
7149     ~safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV();
7150     void initialize(const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* in_struct);
7151     void initialize(const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* copy_src);
ptrsafe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV7152     VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>(this); }
ptrsafe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV7153     VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const *>(this); }
7154 };
7155 
7156 struct safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT {
7157     VkStructureType sType;
7158     void* pNext;
7159     VkBool32 bufferDeviceAddress;
7160     VkBool32 bufferDeviceAddressCaptureReplay;
7161     VkBool32 bufferDeviceAddressMultiDevice;
7162     safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* in_struct);
7163     safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& copy_src);
7164     safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& operator=(const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& copy_src);
7165     safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT();
7166     ~safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT();
7167     void initialize(const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* in_struct);
7168     void initialize(const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT7169     VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT7170     VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const *>(this); }
7171 };
7172 
7173 struct safe_VkBufferDeviceAddressCreateInfoEXT {
7174     VkStructureType sType;
7175     const void* pNext;
7176     VkDeviceAddress deviceAddress;
7177     safe_VkBufferDeviceAddressCreateInfoEXT(const VkBufferDeviceAddressCreateInfoEXT* in_struct);
7178     safe_VkBufferDeviceAddressCreateInfoEXT(const safe_VkBufferDeviceAddressCreateInfoEXT& copy_src);
7179     safe_VkBufferDeviceAddressCreateInfoEXT& operator=(const safe_VkBufferDeviceAddressCreateInfoEXT& copy_src);
7180     safe_VkBufferDeviceAddressCreateInfoEXT();
7181     ~safe_VkBufferDeviceAddressCreateInfoEXT();
7182     void initialize(const VkBufferDeviceAddressCreateInfoEXT* in_struct);
7183     void initialize(const safe_VkBufferDeviceAddressCreateInfoEXT* copy_src);
ptrsafe_VkBufferDeviceAddressCreateInfoEXT7184     VkBufferDeviceAddressCreateInfoEXT *ptr() { return reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT *>(this); }
ptrsafe_VkBufferDeviceAddressCreateInfoEXT7185     VkBufferDeviceAddressCreateInfoEXT const *ptr() const { return reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT const *>(this); }
7186 };
7187 
7188 struct safe_VkPhysicalDeviceToolPropertiesEXT {
7189     VkStructureType sType;
7190     void* pNext;
7191     char name[VK_MAX_EXTENSION_NAME_SIZE];
7192     char version[VK_MAX_EXTENSION_NAME_SIZE];
7193     VkToolPurposeFlagsEXT purposes;
7194     char description[VK_MAX_DESCRIPTION_SIZE];
7195     char layer[VK_MAX_EXTENSION_NAME_SIZE];
7196     safe_VkPhysicalDeviceToolPropertiesEXT(const VkPhysicalDeviceToolPropertiesEXT* in_struct);
7197     safe_VkPhysicalDeviceToolPropertiesEXT(const safe_VkPhysicalDeviceToolPropertiesEXT& copy_src);
7198     safe_VkPhysicalDeviceToolPropertiesEXT& operator=(const safe_VkPhysicalDeviceToolPropertiesEXT& copy_src);
7199     safe_VkPhysicalDeviceToolPropertiesEXT();
7200     ~safe_VkPhysicalDeviceToolPropertiesEXT();
7201     void initialize(const VkPhysicalDeviceToolPropertiesEXT* in_struct);
7202     void initialize(const safe_VkPhysicalDeviceToolPropertiesEXT* copy_src);
ptrsafe_VkPhysicalDeviceToolPropertiesEXT7203     VkPhysicalDeviceToolPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceToolPropertiesEXT *>(this); }
ptrsafe_VkPhysicalDeviceToolPropertiesEXT7204     VkPhysicalDeviceToolPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceToolPropertiesEXT const *>(this); }
7205 };
7206 
7207 struct safe_VkValidationFeaturesEXT {
7208     VkStructureType sType;
7209     const void* pNext;
7210     uint32_t enabledValidationFeatureCount;
7211     const VkValidationFeatureEnableEXT* pEnabledValidationFeatures;
7212     uint32_t disabledValidationFeatureCount;
7213     const VkValidationFeatureDisableEXT* pDisabledValidationFeatures;
7214     safe_VkValidationFeaturesEXT(const VkValidationFeaturesEXT* in_struct);
7215     safe_VkValidationFeaturesEXT(const safe_VkValidationFeaturesEXT& copy_src);
7216     safe_VkValidationFeaturesEXT& operator=(const safe_VkValidationFeaturesEXT& copy_src);
7217     safe_VkValidationFeaturesEXT();
7218     ~safe_VkValidationFeaturesEXT();
7219     void initialize(const VkValidationFeaturesEXT* in_struct);
7220     void initialize(const safe_VkValidationFeaturesEXT* copy_src);
ptrsafe_VkValidationFeaturesEXT7221     VkValidationFeaturesEXT *ptr() { return reinterpret_cast<VkValidationFeaturesEXT *>(this); }
ptrsafe_VkValidationFeaturesEXT7222     VkValidationFeaturesEXT const *ptr() const { return reinterpret_cast<VkValidationFeaturesEXT const *>(this); }
7223 };
7224 
7225 struct safe_VkCooperativeMatrixPropertiesNV {
7226     VkStructureType sType;
7227     void* pNext;
7228     uint32_t MSize;
7229     uint32_t NSize;
7230     uint32_t KSize;
7231     VkComponentTypeNV AType;
7232     VkComponentTypeNV BType;
7233     VkComponentTypeNV CType;
7234     VkComponentTypeNV DType;
7235     VkScopeNV scope;
7236     safe_VkCooperativeMatrixPropertiesNV(const VkCooperativeMatrixPropertiesNV* in_struct);
7237     safe_VkCooperativeMatrixPropertiesNV(const safe_VkCooperativeMatrixPropertiesNV& copy_src);
7238     safe_VkCooperativeMatrixPropertiesNV& operator=(const safe_VkCooperativeMatrixPropertiesNV& copy_src);
7239     safe_VkCooperativeMatrixPropertiesNV();
7240     ~safe_VkCooperativeMatrixPropertiesNV();
7241     void initialize(const VkCooperativeMatrixPropertiesNV* in_struct);
7242     void initialize(const safe_VkCooperativeMatrixPropertiesNV* copy_src);
ptrsafe_VkCooperativeMatrixPropertiesNV7243     VkCooperativeMatrixPropertiesNV *ptr() { return reinterpret_cast<VkCooperativeMatrixPropertiesNV *>(this); }
ptrsafe_VkCooperativeMatrixPropertiesNV7244     VkCooperativeMatrixPropertiesNV const *ptr() const { return reinterpret_cast<VkCooperativeMatrixPropertiesNV const *>(this); }
7245 };
7246 
7247 struct safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV {
7248     VkStructureType sType;
7249     void* pNext;
7250     VkBool32 cooperativeMatrix;
7251     VkBool32 cooperativeMatrixRobustBufferAccess;
7252     safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(const VkPhysicalDeviceCooperativeMatrixFeaturesNV* in_struct);
7253     safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& copy_src);
7254     safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& operator=(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& copy_src);
7255     safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV();
7256     ~safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV();
7257     void initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesNV* in_struct);
7258     void initialize(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV* copy_src);
ptrsafe_VkPhysicalDeviceCooperativeMatrixFeaturesNV7259     VkPhysicalDeviceCooperativeMatrixFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV *>(this); }
ptrsafe_VkPhysicalDeviceCooperativeMatrixFeaturesNV7260     VkPhysicalDeviceCooperativeMatrixFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV const *>(this); }
7261 };
7262 
7263 struct safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV {
7264     VkStructureType sType;
7265     void* pNext;
7266     VkShaderStageFlags cooperativeMatrixSupportedStages;
7267     safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(const VkPhysicalDeviceCooperativeMatrixPropertiesNV* in_struct);
7268     safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& copy_src);
7269     safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& operator=(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& copy_src);
7270     safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV();
7271     ~safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV();
7272     void initialize(const VkPhysicalDeviceCooperativeMatrixPropertiesNV* in_struct);
7273     void initialize(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV* copy_src);
ptrsafe_VkPhysicalDeviceCooperativeMatrixPropertiesNV7274     VkPhysicalDeviceCooperativeMatrixPropertiesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV *>(this); }
ptrsafe_VkPhysicalDeviceCooperativeMatrixPropertiesNV7275     VkPhysicalDeviceCooperativeMatrixPropertiesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV const *>(this); }
7276 };
7277 
7278 struct safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV {
7279     VkStructureType sType;
7280     void* pNext;
7281     VkBool32 coverageReductionMode;
7282     safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(const VkPhysicalDeviceCoverageReductionModeFeaturesNV* in_struct);
7283     safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& copy_src);
7284     safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& operator=(const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& copy_src);
7285     safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV();
7286     ~safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV();
7287     void initialize(const VkPhysicalDeviceCoverageReductionModeFeaturesNV* in_struct);
7288     void initialize(const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV* copy_src);
ptrsafe_VkPhysicalDeviceCoverageReductionModeFeaturesNV7289     VkPhysicalDeviceCoverageReductionModeFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV *>(this); }
ptrsafe_VkPhysicalDeviceCoverageReductionModeFeaturesNV7290     VkPhysicalDeviceCoverageReductionModeFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV const *>(this); }
7291 };
7292 
7293 struct safe_VkPipelineCoverageReductionStateCreateInfoNV {
7294     VkStructureType sType;
7295     const void* pNext;
7296     VkPipelineCoverageReductionStateCreateFlagsNV flags;
7297     VkCoverageReductionModeNV coverageReductionMode;
7298     safe_VkPipelineCoverageReductionStateCreateInfoNV(const VkPipelineCoverageReductionStateCreateInfoNV* in_struct);
7299     safe_VkPipelineCoverageReductionStateCreateInfoNV(const safe_VkPipelineCoverageReductionStateCreateInfoNV& copy_src);
7300     safe_VkPipelineCoverageReductionStateCreateInfoNV& operator=(const safe_VkPipelineCoverageReductionStateCreateInfoNV& copy_src);
7301     safe_VkPipelineCoverageReductionStateCreateInfoNV();
7302     ~safe_VkPipelineCoverageReductionStateCreateInfoNV();
7303     void initialize(const VkPipelineCoverageReductionStateCreateInfoNV* in_struct);
7304     void initialize(const safe_VkPipelineCoverageReductionStateCreateInfoNV* copy_src);
ptrsafe_VkPipelineCoverageReductionStateCreateInfoNV7305     VkPipelineCoverageReductionStateCreateInfoNV *ptr() { return reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV *>(this); }
ptrsafe_VkPipelineCoverageReductionStateCreateInfoNV7306     VkPipelineCoverageReductionStateCreateInfoNV const *ptr() const { return reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV const *>(this); }
7307 };
7308 
7309 struct safe_VkFramebufferMixedSamplesCombinationNV {
7310     VkStructureType sType;
7311     void* pNext;
7312     VkCoverageReductionModeNV coverageReductionMode;
7313     VkSampleCountFlagBits rasterizationSamples;
7314     VkSampleCountFlags depthStencilSamples;
7315     VkSampleCountFlags colorSamples;
7316     safe_VkFramebufferMixedSamplesCombinationNV(const VkFramebufferMixedSamplesCombinationNV* in_struct);
7317     safe_VkFramebufferMixedSamplesCombinationNV(const safe_VkFramebufferMixedSamplesCombinationNV& copy_src);
7318     safe_VkFramebufferMixedSamplesCombinationNV& operator=(const safe_VkFramebufferMixedSamplesCombinationNV& copy_src);
7319     safe_VkFramebufferMixedSamplesCombinationNV();
7320     ~safe_VkFramebufferMixedSamplesCombinationNV();
7321     void initialize(const VkFramebufferMixedSamplesCombinationNV* in_struct);
7322     void initialize(const safe_VkFramebufferMixedSamplesCombinationNV* copy_src);
ptrsafe_VkFramebufferMixedSamplesCombinationNV7323     VkFramebufferMixedSamplesCombinationNV *ptr() { return reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>(this); }
ptrsafe_VkFramebufferMixedSamplesCombinationNV7324     VkFramebufferMixedSamplesCombinationNV const *ptr() const { return reinterpret_cast<VkFramebufferMixedSamplesCombinationNV const *>(this); }
7325 };
7326 
7327 struct safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT {
7328     VkStructureType sType;
7329     void* pNext;
7330     VkBool32 fragmentShaderSampleInterlock;
7331     VkBool32 fragmentShaderPixelInterlock;
7332     VkBool32 fragmentShaderShadingRateInterlock;
7333     safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* in_struct);
7334     safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& copy_src);
7335     safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& operator=(const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& copy_src);
7336     safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT();
7337     ~safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT();
7338     void initialize(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* in_struct);
7339     void initialize(const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT7340     VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT7341     VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const *>(this); }
7342 };
7343 
7344 struct safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT {
7345     VkStructureType sType;
7346     void* pNext;
7347     VkBool32 ycbcrImageArrays;
7348     safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* in_struct);
7349     safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& copy_src);
7350     safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& operator=(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& copy_src);
7351     safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT();
7352     ~safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT();
7353     void initialize(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* in_struct);
7354     void initialize(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT7355     VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT7356     VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const *>(this); }
7357 };
7358 
7359 #ifdef VK_USE_PLATFORM_WIN32_KHR
7360 struct safe_VkSurfaceFullScreenExclusiveInfoEXT {
7361     VkStructureType sType;
7362     void* pNext;
7363     VkFullScreenExclusiveEXT fullScreenExclusive;
7364     safe_VkSurfaceFullScreenExclusiveInfoEXT(const VkSurfaceFullScreenExclusiveInfoEXT* in_struct);
7365     safe_VkSurfaceFullScreenExclusiveInfoEXT(const safe_VkSurfaceFullScreenExclusiveInfoEXT& copy_src);
7366     safe_VkSurfaceFullScreenExclusiveInfoEXT& operator=(const safe_VkSurfaceFullScreenExclusiveInfoEXT& copy_src);
7367     safe_VkSurfaceFullScreenExclusiveInfoEXT();
7368     ~safe_VkSurfaceFullScreenExclusiveInfoEXT();
7369     void initialize(const VkSurfaceFullScreenExclusiveInfoEXT* in_struct);
7370     void initialize(const safe_VkSurfaceFullScreenExclusiveInfoEXT* copy_src);
ptrsafe_VkSurfaceFullScreenExclusiveInfoEXT7371     VkSurfaceFullScreenExclusiveInfoEXT *ptr() { return reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT *>(this); }
ptrsafe_VkSurfaceFullScreenExclusiveInfoEXT7372     VkSurfaceFullScreenExclusiveInfoEXT const *ptr() const { return reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT const *>(this); }
7373 };
7374 #endif // VK_USE_PLATFORM_WIN32_KHR
7375 
7376 #ifdef VK_USE_PLATFORM_WIN32_KHR
7377 struct safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT {
7378     VkStructureType sType;
7379     void* pNext;
7380     VkBool32 fullScreenExclusiveSupported;
7381     safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct);
7382     safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& copy_src);
7383     safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& operator=(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& copy_src);
7384     safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT();
7385     ~safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT();
7386     void initialize(const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct);
7387     void initialize(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT* copy_src);
ptrsafe_VkSurfaceCapabilitiesFullScreenExclusiveEXT7388     VkSurfaceCapabilitiesFullScreenExclusiveEXT *ptr() { return reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT *>(this); }
ptrsafe_VkSurfaceCapabilitiesFullScreenExclusiveEXT7389     VkSurfaceCapabilitiesFullScreenExclusiveEXT const *ptr() const { return reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT const *>(this); }
7390 };
7391 #endif // VK_USE_PLATFORM_WIN32_KHR
7392 
7393 #ifdef VK_USE_PLATFORM_WIN32_KHR
7394 struct safe_VkSurfaceFullScreenExclusiveWin32InfoEXT {
7395     VkStructureType sType;
7396     const void* pNext;
7397     HMONITOR hmonitor;
7398     safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct);
7399     safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& copy_src);
7400     safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& operator=(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& copy_src);
7401     safe_VkSurfaceFullScreenExclusiveWin32InfoEXT();
7402     ~safe_VkSurfaceFullScreenExclusiveWin32InfoEXT();
7403     void initialize(const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct);
7404     void initialize(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT* copy_src);
ptrsafe_VkSurfaceFullScreenExclusiveWin32InfoEXT7405     VkSurfaceFullScreenExclusiveWin32InfoEXT *ptr() { return reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT *>(this); }
ptrsafe_VkSurfaceFullScreenExclusiveWin32InfoEXT7406     VkSurfaceFullScreenExclusiveWin32InfoEXT const *ptr() const { return reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT const *>(this); }
7407 };
7408 #endif // VK_USE_PLATFORM_WIN32_KHR
7409 
7410 struct safe_VkHeadlessSurfaceCreateInfoEXT {
7411     VkStructureType sType;
7412     const void* pNext;
7413     VkHeadlessSurfaceCreateFlagsEXT flags;
7414     safe_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT* in_struct);
7415     safe_VkHeadlessSurfaceCreateInfoEXT(const safe_VkHeadlessSurfaceCreateInfoEXT& copy_src);
7416     safe_VkHeadlessSurfaceCreateInfoEXT& operator=(const safe_VkHeadlessSurfaceCreateInfoEXT& copy_src);
7417     safe_VkHeadlessSurfaceCreateInfoEXT();
7418     ~safe_VkHeadlessSurfaceCreateInfoEXT();
7419     void initialize(const VkHeadlessSurfaceCreateInfoEXT* in_struct);
7420     void initialize(const safe_VkHeadlessSurfaceCreateInfoEXT* copy_src);
ptrsafe_VkHeadlessSurfaceCreateInfoEXT7421     VkHeadlessSurfaceCreateInfoEXT *ptr() { return reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT *>(this); }
ptrsafe_VkHeadlessSurfaceCreateInfoEXT7422     VkHeadlessSurfaceCreateInfoEXT const *ptr() const { return reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT const *>(this); }
7423 };
7424 
7425 struct safe_VkPhysicalDeviceLineRasterizationFeaturesEXT {
7426     VkStructureType sType;
7427     void* pNext;
7428     VkBool32 rectangularLines;
7429     VkBool32 bresenhamLines;
7430     VkBool32 smoothLines;
7431     VkBool32 stippledRectangularLines;
7432     VkBool32 stippledBresenhamLines;
7433     VkBool32 stippledSmoothLines;
7434     safe_VkPhysicalDeviceLineRasterizationFeaturesEXT(const VkPhysicalDeviceLineRasterizationFeaturesEXT* in_struct);
7435     safe_VkPhysicalDeviceLineRasterizationFeaturesEXT(const safe_VkPhysicalDeviceLineRasterizationFeaturesEXT& copy_src);
7436     safe_VkPhysicalDeviceLineRasterizationFeaturesEXT& operator=(const safe_VkPhysicalDeviceLineRasterizationFeaturesEXT& copy_src);
7437     safe_VkPhysicalDeviceLineRasterizationFeaturesEXT();
7438     ~safe_VkPhysicalDeviceLineRasterizationFeaturesEXT();
7439     void initialize(const VkPhysicalDeviceLineRasterizationFeaturesEXT* in_struct);
7440     void initialize(const safe_VkPhysicalDeviceLineRasterizationFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceLineRasterizationFeaturesEXT7441     VkPhysicalDeviceLineRasterizationFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceLineRasterizationFeaturesEXT7442     VkPhysicalDeviceLineRasterizationFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT const *>(this); }
7443 };
7444 
7445 struct safe_VkPhysicalDeviceLineRasterizationPropertiesEXT {
7446     VkStructureType sType;
7447     void* pNext;
7448     uint32_t lineSubPixelPrecisionBits;
7449     safe_VkPhysicalDeviceLineRasterizationPropertiesEXT(const VkPhysicalDeviceLineRasterizationPropertiesEXT* in_struct);
7450     safe_VkPhysicalDeviceLineRasterizationPropertiesEXT(const safe_VkPhysicalDeviceLineRasterizationPropertiesEXT& copy_src);
7451     safe_VkPhysicalDeviceLineRasterizationPropertiesEXT& operator=(const safe_VkPhysicalDeviceLineRasterizationPropertiesEXT& copy_src);
7452     safe_VkPhysicalDeviceLineRasterizationPropertiesEXT();
7453     ~safe_VkPhysicalDeviceLineRasterizationPropertiesEXT();
7454     void initialize(const VkPhysicalDeviceLineRasterizationPropertiesEXT* in_struct);
7455     void initialize(const safe_VkPhysicalDeviceLineRasterizationPropertiesEXT* copy_src);
ptrsafe_VkPhysicalDeviceLineRasterizationPropertiesEXT7456     VkPhysicalDeviceLineRasterizationPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT *>(this); }
ptrsafe_VkPhysicalDeviceLineRasterizationPropertiesEXT7457     VkPhysicalDeviceLineRasterizationPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT const *>(this); }
7458 };
7459 
7460 struct safe_VkPipelineRasterizationLineStateCreateInfoEXT {
7461     VkStructureType sType;
7462     const void* pNext;
7463     VkLineRasterizationModeEXT lineRasterizationMode;
7464     VkBool32 stippledLineEnable;
7465     uint32_t lineStippleFactor;
7466     uint16_t lineStipplePattern;
7467     safe_VkPipelineRasterizationLineStateCreateInfoEXT(const VkPipelineRasterizationLineStateCreateInfoEXT* in_struct);
7468     safe_VkPipelineRasterizationLineStateCreateInfoEXT(const safe_VkPipelineRasterizationLineStateCreateInfoEXT& copy_src);
7469     safe_VkPipelineRasterizationLineStateCreateInfoEXT& operator=(const safe_VkPipelineRasterizationLineStateCreateInfoEXT& copy_src);
7470     safe_VkPipelineRasterizationLineStateCreateInfoEXT();
7471     ~safe_VkPipelineRasterizationLineStateCreateInfoEXT();
7472     void initialize(const VkPipelineRasterizationLineStateCreateInfoEXT* in_struct);
7473     void initialize(const safe_VkPipelineRasterizationLineStateCreateInfoEXT* copy_src);
ptrsafe_VkPipelineRasterizationLineStateCreateInfoEXT7474     VkPipelineRasterizationLineStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT *>(this); }
ptrsafe_VkPipelineRasterizationLineStateCreateInfoEXT7475     VkPipelineRasterizationLineStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT const *>(this); }
7476 };
7477 
7478 struct safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT {
7479     VkStructureType sType;
7480     void* pNext;
7481     VkBool32 shaderBufferFloat32Atomics;
7482     VkBool32 shaderBufferFloat32AtomicAdd;
7483     VkBool32 shaderBufferFloat64Atomics;
7484     VkBool32 shaderBufferFloat64AtomicAdd;
7485     VkBool32 shaderSharedFloat32Atomics;
7486     VkBool32 shaderSharedFloat32AtomicAdd;
7487     VkBool32 shaderSharedFloat64Atomics;
7488     VkBool32 shaderSharedFloat64AtomicAdd;
7489     VkBool32 shaderImageFloat32Atomics;
7490     VkBool32 shaderImageFloat32AtomicAdd;
7491     VkBool32 sparseImageFloat32Atomics;
7492     VkBool32 sparseImageFloat32AtomicAdd;
7493     safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* in_struct);
7494     safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& copy_src);
7495     safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& operator=(const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& copy_src);
7496     safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT();
7497     ~safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT();
7498     void initialize(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* in_struct);
7499     void initialize(const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT7500     VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT7501     VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const *>(this); }
7502 };
7503 
7504 struct safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT {
7505     VkStructureType sType;
7506     void* pNext;
7507     VkBool32 indexTypeUint8;
7508     safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* in_struct);
7509     safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT& copy_src);
7510     safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT& operator=(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT& copy_src);
7511     safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT();
7512     ~safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT();
7513     void initialize(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* in_struct);
7514     void initialize(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT7515     VkPhysicalDeviceIndexTypeUint8FeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT7516     VkPhysicalDeviceIndexTypeUint8FeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT const *>(this); }
7517 };
7518 
7519 struct safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT {
7520     VkStructureType sType;
7521     void* pNext;
7522     VkBool32 extendedDynamicState;
7523     safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* in_struct);
7524     safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& copy_src);
7525     safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& operator=(const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& copy_src);
7526     safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT();
7527     ~safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT();
7528     void initialize(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* in_struct);
7529     void initialize(const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT7530     VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT7531     VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const *>(this); }
7532 };
7533 
7534 struct safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
7535     VkStructureType sType;
7536     void* pNext;
7537     VkBool32 shaderDemoteToHelperInvocation;
7538     safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* in_struct);
7539     safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& copy_src);
7540     safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& operator=(const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& copy_src);
7541     safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT();
7542     ~safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT();
7543     void initialize(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* in_struct);
7544     void initialize(const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT7545     VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT7546     VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const *>(this); }
7547 };
7548 
7549 struct safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
7550     VkStructureType sType;
7551     void* pNext;
7552     uint32_t maxGraphicsShaderGroupCount;
7553     uint32_t maxIndirectSequenceCount;
7554     uint32_t maxIndirectCommandsTokenCount;
7555     uint32_t maxIndirectCommandsStreamCount;
7556     uint32_t maxIndirectCommandsTokenOffset;
7557     uint32_t maxIndirectCommandsStreamStride;
7558     uint32_t minSequencesCountBufferOffsetAlignment;
7559     uint32_t minSequencesIndexBufferOffsetAlignment;
7560     uint32_t minIndirectCommandsBufferOffsetAlignment;
7561     safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* in_struct);
7562     safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& copy_src);
7563     safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& operator=(const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& copy_src);
7564     safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV();
7565     ~safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV();
7566     void initialize(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* in_struct);
7567     void initialize(const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* copy_src);
ptrsafe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV7568     VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *>(this); }
ptrsafe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV7569     VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const *>(this); }
7570 };
7571 
7572 struct safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
7573     VkStructureType sType;
7574     void* pNext;
7575     VkBool32 deviceGeneratedCommands;
7576     safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* in_struct);
7577     safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& copy_src);
7578     safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& operator=(const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& copy_src);
7579     safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV();
7580     ~safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV();
7581     void initialize(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* in_struct);
7582     void initialize(const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* copy_src);
ptrsafe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV7583     VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *>(this); }
ptrsafe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV7584     VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const *>(this); }
7585 };
7586 
7587 struct safe_VkGraphicsShaderGroupCreateInfoNV {
7588     VkStructureType sType;
7589     const void* pNext;
7590     uint32_t stageCount;
7591     safe_VkPipelineShaderStageCreateInfo* pStages;
7592     safe_VkPipelineVertexInputStateCreateInfo* pVertexInputState;
7593     safe_VkPipelineTessellationStateCreateInfo* pTessellationState;
7594     safe_VkGraphicsShaderGroupCreateInfoNV(const VkGraphicsShaderGroupCreateInfoNV* in_struct);
7595     safe_VkGraphicsShaderGroupCreateInfoNV(const safe_VkGraphicsShaderGroupCreateInfoNV& copy_src);
7596     safe_VkGraphicsShaderGroupCreateInfoNV& operator=(const safe_VkGraphicsShaderGroupCreateInfoNV& copy_src);
7597     safe_VkGraphicsShaderGroupCreateInfoNV();
7598     ~safe_VkGraphicsShaderGroupCreateInfoNV();
7599     void initialize(const VkGraphicsShaderGroupCreateInfoNV* in_struct);
7600     void initialize(const safe_VkGraphicsShaderGroupCreateInfoNV* copy_src);
ptrsafe_VkGraphicsShaderGroupCreateInfoNV7601     VkGraphicsShaderGroupCreateInfoNV *ptr() { return reinterpret_cast<VkGraphicsShaderGroupCreateInfoNV *>(this); }
ptrsafe_VkGraphicsShaderGroupCreateInfoNV7602     VkGraphicsShaderGroupCreateInfoNV const *ptr() const { return reinterpret_cast<VkGraphicsShaderGroupCreateInfoNV const *>(this); }
7603 };
7604 
7605 struct safe_VkGraphicsPipelineShaderGroupsCreateInfoNV {
7606     VkStructureType sType;
7607     const void* pNext;
7608     uint32_t groupCount;
7609     safe_VkGraphicsShaderGroupCreateInfoNV* pGroups;
7610     uint32_t pipelineCount;
7611     VkPipeline* pPipelines;
7612     safe_VkGraphicsPipelineShaderGroupsCreateInfoNV(const VkGraphicsPipelineShaderGroupsCreateInfoNV* in_struct);
7613     safe_VkGraphicsPipelineShaderGroupsCreateInfoNV(const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV& copy_src);
7614     safe_VkGraphicsPipelineShaderGroupsCreateInfoNV& operator=(const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV& copy_src);
7615     safe_VkGraphicsPipelineShaderGroupsCreateInfoNV();
7616     ~safe_VkGraphicsPipelineShaderGroupsCreateInfoNV();
7617     void initialize(const VkGraphicsPipelineShaderGroupsCreateInfoNV* in_struct);
7618     void initialize(const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV* copy_src);
ptrsafe_VkGraphicsPipelineShaderGroupsCreateInfoNV7619     VkGraphicsPipelineShaderGroupsCreateInfoNV *ptr() { return reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV *>(this); }
ptrsafe_VkGraphicsPipelineShaderGroupsCreateInfoNV7620     VkGraphicsPipelineShaderGroupsCreateInfoNV const *ptr() const { return reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV const *>(this); }
7621 };
7622 
7623 struct safe_VkIndirectCommandsLayoutTokenNV {
7624     VkStructureType sType;
7625     const void* pNext;
7626     VkIndirectCommandsTokenTypeNV tokenType;
7627     uint32_t stream;
7628     uint32_t offset;
7629     uint32_t vertexBindingUnit;
7630     VkBool32 vertexDynamicStride;
7631     VkPipelineLayout pushconstantPipelineLayout;
7632     VkShaderStageFlags pushconstantShaderStageFlags;
7633     uint32_t pushconstantOffset;
7634     uint32_t pushconstantSize;
7635     VkIndirectStateFlagsNV indirectStateFlags;
7636     uint32_t indexTypeCount;
7637     const VkIndexType* pIndexTypes;
7638     const uint32_t* pIndexTypeValues;
7639     safe_VkIndirectCommandsLayoutTokenNV(const VkIndirectCommandsLayoutTokenNV* in_struct);
7640     safe_VkIndirectCommandsLayoutTokenNV(const safe_VkIndirectCommandsLayoutTokenNV& copy_src);
7641     safe_VkIndirectCommandsLayoutTokenNV& operator=(const safe_VkIndirectCommandsLayoutTokenNV& copy_src);
7642     safe_VkIndirectCommandsLayoutTokenNV();
7643     ~safe_VkIndirectCommandsLayoutTokenNV();
7644     void initialize(const VkIndirectCommandsLayoutTokenNV* in_struct);
7645     void initialize(const safe_VkIndirectCommandsLayoutTokenNV* copy_src);
ptrsafe_VkIndirectCommandsLayoutTokenNV7646     VkIndirectCommandsLayoutTokenNV *ptr() { return reinterpret_cast<VkIndirectCommandsLayoutTokenNV *>(this); }
ptrsafe_VkIndirectCommandsLayoutTokenNV7647     VkIndirectCommandsLayoutTokenNV const *ptr() const { return reinterpret_cast<VkIndirectCommandsLayoutTokenNV const *>(this); }
7648 };
7649 
7650 struct safe_VkIndirectCommandsLayoutCreateInfoNV {
7651     VkStructureType sType;
7652     const void* pNext;
7653     VkIndirectCommandsLayoutUsageFlagsNV flags;
7654     VkPipelineBindPoint pipelineBindPoint;
7655     uint32_t tokenCount;
7656     safe_VkIndirectCommandsLayoutTokenNV* pTokens;
7657     uint32_t streamCount;
7658     const uint32_t* pStreamStrides;
7659     safe_VkIndirectCommandsLayoutCreateInfoNV(const VkIndirectCommandsLayoutCreateInfoNV* in_struct);
7660     safe_VkIndirectCommandsLayoutCreateInfoNV(const safe_VkIndirectCommandsLayoutCreateInfoNV& copy_src);
7661     safe_VkIndirectCommandsLayoutCreateInfoNV& operator=(const safe_VkIndirectCommandsLayoutCreateInfoNV& copy_src);
7662     safe_VkIndirectCommandsLayoutCreateInfoNV();
7663     ~safe_VkIndirectCommandsLayoutCreateInfoNV();
7664     void initialize(const VkIndirectCommandsLayoutCreateInfoNV* in_struct);
7665     void initialize(const safe_VkIndirectCommandsLayoutCreateInfoNV* copy_src);
ptrsafe_VkIndirectCommandsLayoutCreateInfoNV7666     VkIndirectCommandsLayoutCreateInfoNV *ptr() { return reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNV *>(this); }
ptrsafe_VkIndirectCommandsLayoutCreateInfoNV7667     VkIndirectCommandsLayoutCreateInfoNV const *ptr() const { return reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNV const *>(this); }
7668 };
7669 
7670 struct safe_VkGeneratedCommandsInfoNV {
7671     VkStructureType sType;
7672     const void* pNext;
7673     VkPipelineBindPoint pipelineBindPoint;
7674     VkPipeline pipeline;
7675     VkIndirectCommandsLayoutNV indirectCommandsLayout;
7676     uint32_t streamCount;
7677     VkIndirectCommandsStreamNV* pStreams;
7678     uint32_t sequencesCount;
7679     VkBuffer preprocessBuffer;
7680     VkDeviceSize preprocessOffset;
7681     VkDeviceSize preprocessSize;
7682     VkBuffer sequencesCountBuffer;
7683     VkDeviceSize sequencesCountOffset;
7684     VkBuffer sequencesIndexBuffer;
7685     VkDeviceSize sequencesIndexOffset;
7686     safe_VkGeneratedCommandsInfoNV(const VkGeneratedCommandsInfoNV* in_struct);
7687     safe_VkGeneratedCommandsInfoNV(const safe_VkGeneratedCommandsInfoNV& copy_src);
7688     safe_VkGeneratedCommandsInfoNV& operator=(const safe_VkGeneratedCommandsInfoNV& copy_src);
7689     safe_VkGeneratedCommandsInfoNV();
7690     ~safe_VkGeneratedCommandsInfoNV();
7691     void initialize(const VkGeneratedCommandsInfoNV* in_struct);
7692     void initialize(const safe_VkGeneratedCommandsInfoNV* copy_src);
ptrsafe_VkGeneratedCommandsInfoNV7693     VkGeneratedCommandsInfoNV *ptr() { return reinterpret_cast<VkGeneratedCommandsInfoNV *>(this); }
ptrsafe_VkGeneratedCommandsInfoNV7694     VkGeneratedCommandsInfoNV const *ptr() const { return reinterpret_cast<VkGeneratedCommandsInfoNV const *>(this); }
7695 };
7696 
7697 struct safe_VkGeneratedCommandsMemoryRequirementsInfoNV {
7698     VkStructureType sType;
7699     const void* pNext;
7700     VkPipelineBindPoint pipelineBindPoint;
7701     VkPipeline pipeline;
7702     VkIndirectCommandsLayoutNV indirectCommandsLayout;
7703     uint32_t maxSequencesCount;
7704     safe_VkGeneratedCommandsMemoryRequirementsInfoNV(const VkGeneratedCommandsMemoryRequirementsInfoNV* in_struct);
7705     safe_VkGeneratedCommandsMemoryRequirementsInfoNV(const safe_VkGeneratedCommandsMemoryRequirementsInfoNV& copy_src);
7706     safe_VkGeneratedCommandsMemoryRequirementsInfoNV& operator=(const safe_VkGeneratedCommandsMemoryRequirementsInfoNV& copy_src);
7707     safe_VkGeneratedCommandsMemoryRequirementsInfoNV();
7708     ~safe_VkGeneratedCommandsMemoryRequirementsInfoNV();
7709     void initialize(const VkGeneratedCommandsMemoryRequirementsInfoNV* in_struct);
7710     void initialize(const safe_VkGeneratedCommandsMemoryRequirementsInfoNV* copy_src);
ptrsafe_VkGeneratedCommandsMemoryRequirementsInfoNV7711     VkGeneratedCommandsMemoryRequirementsInfoNV *ptr() { return reinterpret_cast<VkGeneratedCommandsMemoryRequirementsInfoNV *>(this); }
ptrsafe_VkGeneratedCommandsMemoryRequirementsInfoNV7712     VkGeneratedCommandsMemoryRequirementsInfoNV const *ptr() const { return reinterpret_cast<VkGeneratedCommandsMemoryRequirementsInfoNV const *>(this); }
7713 };
7714 
7715 struct safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT {
7716     VkStructureType sType;
7717     void* pNext;
7718     VkBool32 texelBufferAlignment;
7719     safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct);
7720     safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& copy_src);
7721     safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& operator=(const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& copy_src);
7722     safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT();
7723     ~safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT();
7724     void initialize(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct);
7725     void initialize(const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT7726     VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT7727     VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const *>(this); }
7728 };
7729 
7730 struct safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT {
7731     VkStructureType sType;
7732     void* pNext;
7733     VkDeviceSize storageTexelBufferOffsetAlignmentBytes;
7734     VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
7735     VkDeviceSize uniformTexelBufferOffsetAlignmentBytes;
7736     VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
7737     safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* in_struct);
7738     safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(const safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT& copy_src);
7739     safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT& operator=(const safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT& copy_src);
7740     safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT();
7741     ~safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT();
7742     void initialize(const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* in_struct);
7743     void initialize(const safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* copy_src);
ptrsafe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT7744     VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *>(this); }
ptrsafe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT7745     VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const *>(this); }
7746 };
7747 
7748 struct safe_VkRenderPassTransformBeginInfoQCOM {
7749     VkStructureType sType;
7750     void* pNext;
7751     VkSurfaceTransformFlagBitsKHR transform;
7752     safe_VkRenderPassTransformBeginInfoQCOM(const VkRenderPassTransformBeginInfoQCOM* in_struct);
7753     safe_VkRenderPassTransformBeginInfoQCOM(const safe_VkRenderPassTransformBeginInfoQCOM& copy_src);
7754     safe_VkRenderPassTransformBeginInfoQCOM& operator=(const safe_VkRenderPassTransformBeginInfoQCOM& copy_src);
7755     safe_VkRenderPassTransformBeginInfoQCOM();
7756     ~safe_VkRenderPassTransformBeginInfoQCOM();
7757     void initialize(const VkRenderPassTransformBeginInfoQCOM* in_struct);
7758     void initialize(const safe_VkRenderPassTransformBeginInfoQCOM* copy_src);
ptrsafe_VkRenderPassTransformBeginInfoQCOM7759     VkRenderPassTransformBeginInfoQCOM *ptr() { return reinterpret_cast<VkRenderPassTransformBeginInfoQCOM *>(this); }
ptrsafe_VkRenderPassTransformBeginInfoQCOM7760     VkRenderPassTransformBeginInfoQCOM const *ptr() const { return reinterpret_cast<VkRenderPassTransformBeginInfoQCOM const *>(this); }
7761 };
7762 
7763 struct safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM {
7764     VkStructureType sType;
7765     void* pNext;
7766     VkSurfaceTransformFlagBitsKHR transform;
7767     VkRect2D renderArea;
7768     safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* in_struct);
7769     safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM& copy_src);
7770     safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM& operator=(const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM& copy_src);
7771     safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM();
7772     ~safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM();
7773     void initialize(const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* in_struct);
7774     void initialize(const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM* copy_src);
ptrsafe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM7775     VkCommandBufferInheritanceRenderPassTransformInfoQCOM *ptr() { return reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM *>(this); }
ptrsafe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM7776     VkCommandBufferInheritanceRenderPassTransformInfoQCOM const *ptr() const { return reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM const *>(this); }
7777 };
7778 
7779 struct safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT {
7780     VkStructureType sType;
7781     void* pNext;
7782     VkBool32 deviceMemoryReport;
7783     safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* in_struct);
7784     safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& copy_src);
7785     safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& operator=(const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& copy_src);
7786     safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT();
7787     ~safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT();
7788     void initialize(const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* in_struct);
7789     void initialize(const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT7790     VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT7791     VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const *>(this); }
7792 };
7793 
7794 struct safe_VkDeviceMemoryReportCallbackDataEXT {
7795     VkStructureType sType;
7796     const void* pNext;
7797     VkDeviceMemoryReportFlagsEXT flags;
7798     VkDeviceMemoryReportEventTypeEXT type;
7799     uint64_t memoryObjectId;
7800     VkDeviceSize size;
7801     VkObjectType objectType;
7802     uint64_t objectHandle;
7803     uint32_t heapIndex;
7804     safe_VkDeviceMemoryReportCallbackDataEXT(const VkDeviceMemoryReportCallbackDataEXT* in_struct);
7805     safe_VkDeviceMemoryReportCallbackDataEXT(const safe_VkDeviceMemoryReportCallbackDataEXT& copy_src);
7806     safe_VkDeviceMemoryReportCallbackDataEXT& operator=(const safe_VkDeviceMemoryReportCallbackDataEXT& copy_src);
7807     safe_VkDeviceMemoryReportCallbackDataEXT();
7808     ~safe_VkDeviceMemoryReportCallbackDataEXT();
7809     void initialize(const VkDeviceMemoryReportCallbackDataEXT* in_struct);
7810     void initialize(const safe_VkDeviceMemoryReportCallbackDataEXT* copy_src);
ptrsafe_VkDeviceMemoryReportCallbackDataEXT7811     VkDeviceMemoryReportCallbackDataEXT *ptr() { return reinterpret_cast<VkDeviceMemoryReportCallbackDataEXT *>(this); }
ptrsafe_VkDeviceMemoryReportCallbackDataEXT7812     VkDeviceMemoryReportCallbackDataEXT const *ptr() const { return reinterpret_cast<VkDeviceMemoryReportCallbackDataEXT const *>(this); }
7813 };
7814 
7815 struct safe_VkDeviceDeviceMemoryReportCreateInfoEXT {
7816     VkStructureType sType;
7817     const void* pNext;
7818     VkDeviceMemoryReportFlagsEXT flags;
7819     PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback;
7820     void* pUserData;
7821     safe_VkDeviceDeviceMemoryReportCreateInfoEXT(const VkDeviceDeviceMemoryReportCreateInfoEXT* in_struct);
7822     safe_VkDeviceDeviceMemoryReportCreateInfoEXT(const safe_VkDeviceDeviceMemoryReportCreateInfoEXT& copy_src);
7823     safe_VkDeviceDeviceMemoryReportCreateInfoEXT& operator=(const safe_VkDeviceDeviceMemoryReportCreateInfoEXT& copy_src);
7824     safe_VkDeviceDeviceMemoryReportCreateInfoEXT();
7825     ~safe_VkDeviceDeviceMemoryReportCreateInfoEXT();
7826     void initialize(const VkDeviceDeviceMemoryReportCreateInfoEXT* in_struct);
7827     void initialize(const safe_VkDeviceDeviceMemoryReportCreateInfoEXT* copy_src);
ptrsafe_VkDeviceDeviceMemoryReportCreateInfoEXT7828     VkDeviceDeviceMemoryReportCreateInfoEXT *ptr() { return reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT *>(this); }
ptrsafe_VkDeviceDeviceMemoryReportCreateInfoEXT7829     VkDeviceDeviceMemoryReportCreateInfoEXT const *ptr() const { return reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT const *>(this); }
7830 };
7831 
7832 struct safe_VkPhysicalDeviceRobustness2FeaturesEXT {
7833     VkStructureType sType;
7834     void* pNext;
7835     VkBool32 robustBufferAccess2;
7836     VkBool32 robustImageAccess2;
7837     VkBool32 nullDescriptor;
7838     safe_VkPhysicalDeviceRobustness2FeaturesEXT(const VkPhysicalDeviceRobustness2FeaturesEXT* in_struct);
7839     safe_VkPhysicalDeviceRobustness2FeaturesEXT(const safe_VkPhysicalDeviceRobustness2FeaturesEXT& copy_src);
7840     safe_VkPhysicalDeviceRobustness2FeaturesEXT& operator=(const safe_VkPhysicalDeviceRobustness2FeaturesEXT& copy_src);
7841     safe_VkPhysicalDeviceRobustness2FeaturesEXT();
7842     ~safe_VkPhysicalDeviceRobustness2FeaturesEXT();
7843     void initialize(const VkPhysicalDeviceRobustness2FeaturesEXT* in_struct);
7844     void initialize(const safe_VkPhysicalDeviceRobustness2FeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceRobustness2FeaturesEXT7845     VkPhysicalDeviceRobustness2FeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceRobustness2FeaturesEXT7846     VkPhysicalDeviceRobustness2FeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT const *>(this); }
7847 };
7848 
7849 struct safe_VkPhysicalDeviceRobustness2PropertiesEXT {
7850     VkStructureType sType;
7851     void* pNext;
7852     VkDeviceSize robustStorageBufferAccessSizeAlignment;
7853     VkDeviceSize robustUniformBufferAccessSizeAlignment;
7854     safe_VkPhysicalDeviceRobustness2PropertiesEXT(const VkPhysicalDeviceRobustness2PropertiesEXT* in_struct);
7855     safe_VkPhysicalDeviceRobustness2PropertiesEXT(const safe_VkPhysicalDeviceRobustness2PropertiesEXT& copy_src);
7856     safe_VkPhysicalDeviceRobustness2PropertiesEXT& operator=(const safe_VkPhysicalDeviceRobustness2PropertiesEXT& copy_src);
7857     safe_VkPhysicalDeviceRobustness2PropertiesEXT();
7858     ~safe_VkPhysicalDeviceRobustness2PropertiesEXT();
7859     void initialize(const VkPhysicalDeviceRobustness2PropertiesEXT* in_struct);
7860     void initialize(const safe_VkPhysicalDeviceRobustness2PropertiesEXT* copy_src);
ptrsafe_VkPhysicalDeviceRobustness2PropertiesEXT7861     VkPhysicalDeviceRobustness2PropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT *>(this); }
ptrsafe_VkPhysicalDeviceRobustness2PropertiesEXT7862     VkPhysicalDeviceRobustness2PropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT const *>(this); }
7863 };
7864 
7865 struct safe_VkSamplerCustomBorderColorCreateInfoEXT {
7866     VkStructureType sType;
7867     const void* pNext;
7868     VkClearColorValue customBorderColor;
7869     VkFormat format;
7870     safe_VkSamplerCustomBorderColorCreateInfoEXT(const VkSamplerCustomBorderColorCreateInfoEXT* in_struct);
7871     safe_VkSamplerCustomBorderColorCreateInfoEXT(const safe_VkSamplerCustomBorderColorCreateInfoEXT& copy_src);
7872     safe_VkSamplerCustomBorderColorCreateInfoEXT& operator=(const safe_VkSamplerCustomBorderColorCreateInfoEXT& copy_src);
7873     safe_VkSamplerCustomBorderColorCreateInfoEXT();
7874     ~safe_VkSamplerCustomBorderColorCreateInfoEXT();
7875     void initialize(const VkSamplerCustomBorderColorCreateInfoEXT* in_struct);
7876     void initialize(const safe_VkSamplerCustomBorderColorCreateInfoEXT* copy_src);
ptrsafe_VkSamplerCustomBorderColorCreateInfoEXT7877     VkSamplerCustomBorderColorCreateInfoEXT *ptr() { return reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT *>(this); }
ptrsafe_VkSamplerCustomBorderColorCreateInfoEXT7878     VkSamplerCustomBorderColorCreateInfoEXT const *ptr() const { return reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT const *>(this); }
7879 };
7880 
7881 struct safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT {
7882     VkStructureType sType;
7883     void* pNext;
7884     uint32_t maxCustomBorderColorSamplers;
7885     safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const VkPhysicalDeviceCustomBorderColorPropertiesEXT* in_struct);
7886     safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT& copy_src);
7887     safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT& operator=(const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT& copy_src);
7888     safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT();
7889     ~safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT();
7890     void initialize(const VkPhysicalDeviceCustomBorderColorPropertiesEXT* in_struct);
7891     void initialize(const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT* copy_src);
ptrsafe_VkPhysicalDeviceCustomBorderColorPropertiesEXT7892     VkPhysicalDeviceCustomBorderColorPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT *>(this); }
ptrsafe_VkPhysicalDeviceCustomBorderColorPropertiesEXT7893     VkPhysicalDeviceCustomBorderColorPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT const *>(this); }
7894 };
7895 
7896 struct safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT {
7897     VkStructureType sType;
7898     void* pNext;
7899     VkBool32 customBorderColors;
7900     VkBool32 customBorderColorWithoutFormat;
7901     safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const VkPhysicalDeviceCustomBorderColorFeaturesEXT* in_struct);
7902     safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT& copy_src);
7903     safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT& operator=(const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT& copy_src);
7904     safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT();
7905     ~safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT();
7906     void initialize(const VkPhysicalDeviceCustomBorderColorFeaturesEXT* in_struct);
7907     void initialize(const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceCustomBorderColorFeaturesEXT7908     VkPhysicalDeviceCustomBorderColorFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceCustomBorderColorFeaturesEXT7909     VkPhysicalDeviceCustomBorderColorFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT const *>(this); }
7910 };
7911 
7912 struct safe_VkPhysicalDevicePrivateDataFeaturesEXT {
7913     VkStructureType sType;
7914     void* pNext;
7915     VkBool32 privateData;
7916     safe_VkPhysicalDevicePrivateDataFeaturesEXT(const VkPhysicalDevicePrivateDataFeaturesEXT* in_struct);
7917     safe_VkPhysicalDevicePrivateDataFeaturesEXT(const safe_VkPhysicalDevicePrivateDataFeaturesEXT& copy_src);
7918     safe_VkPhysicalDevicePrivateDataFeaturesEXT& operator=(const safe_VkPhysicalDevicePrivateDataFeaturesEXT& copy_src);
7919     safe_VkPhysicalDevicePrivateDataFeaturesEXT();
7920     ~safe_VkPhysicalDevicePrivateDataFeaturesEXT();
7921     void initialize(const VkPhysicalDevicePrivateDataFeaturesEXT* in_struct);
7922     void initialize(const safe_VkPhysicalDevicePrivateDataFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDevicePrivateDataFeaturesEXT7923     VkPhysicalDevicePrivateDataFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDevicePrivateDataFeaturesEXT7924     VkPhysicalDevicePrivateDataFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT const *>(this); }
7925 };
7926 
7927 struct safe_VkDevicePrivateDataCreateInfoEXT {
7928     VkStructureType sType;
7929     const void* pNext;
7930     uint32_t privateDataSlotRequestCount;
7931     safe_VkDevicePrivateDataCreateInfoEXT(const VkDevicePrivateDataCreateInfoEXT* in_struct);
7932     safe_VkDevicePrivateDataCreateInfoEXT(const safe_VkDevicePrivateDataCreateInfoEXT& copy_src);
7933     safe_VkDevicePrivateDataCreateInfoEXT& operator=(const safe_VkDevicePrivateDataCreateInfoEXT& copy_src);
7934     safe_VkDevicePrivateDataCreateInfoEXT();
7935     ~safe_VkDevicePrivateDataCreateInfoEXT();
7936     void initialize(const VkDevicePrivateDataCreateInfoEXT* in_struct);
7937     void initialize(const safe_VkDevicePrivateDataCreateInfoEXT* copy_src);
ptrsafe_VkDevicePrivateDataCreateInfoEXT7938     VkDevicePrivateDataCreateInfoEXT *ptr() { return reinterpret_cast<VkDevicePrivateDataCreateInfoEXT *>(this); }
ptrsafe_VkDevicePrivateDataCreateInfoEXT7939     VkDevicePrivateDataCreateInfoEXT const *ptr() const { return reinterpret_cast<VkDevicePrivateDataCreateInfoEXT const *>(this); }
7940 };
7941 
7942 struct safe_VkPrivateDataSlotCreateInfoEXT {
7943     VkStructureType sType;
7944     const void* pNext;
7945     VkPrivateDataSlotCreateFlagsEXT flags;
7946     safe_VkPrivateDataSlotCreateInfoEXT(const VkPrivateDataSlotCreateInfoEXT* in_struct);
7947     safe_VkPrivateDataSlotCreateInfoEXT(const safe_VkPrivateDataSlotCreateInfoEXT& copy_src);
7948     safe_VkPrivateDataSlotCreateInfoEXT& operator=(const safe_VkPrivateDataSlotCreateInfoEXT& copy_src);
7949     safe_VkPrivateDataSlotCreateInfoEXT();
7950     ~safe_VkPrivateDataSlotCreateInfoEXT();
7951     void initialize(const VkPrivateDataSlotCreateInfoEXT* in_struct);
7952     void initialize(const safe_VkPrivateDataSlotCreateInfoEXT* copy_src);
ptrsafe_VkPrivateDataSlotCreateInfoEXT7953     VkPrivateDataSlotCreateInfoEXT *ptr() { return reinterpret_cast<VkPrivateDataSlotCreateInfoEXT *>(this); }
ptrsafe_VkPrivateDataSlotCreateInfoEXT7954     VkPrivateDataSlotCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPrivateDataSlotCreateInfoEXT const *>(this); }
7955 };
7956 
7957 struct safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT {
7958     VkStructureType sType;
7959     void* pNext;
7960     VkBool32 pipelineCreationCacheControl;
7961     safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* in_struct);
7962     safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(const safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT& copy_src);
7963     safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT& operator=(const safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT& copy_src);
7964     safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT();
7965     ~safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT();
7966     void initialize(const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* in_struct);
7967     void initialize(const safe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT7968     VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT7969     VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT const *>(this); }
7970 };
7971 
7972 struct safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV {
7973     VkStructureType sType;
7974     void* pNext;
7975     VkBool32 diagnosticsConfig;
7976     safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* in_struct);
7977     safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV& copy_src);
7978     safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV& operator=(const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV& copy_src);
7979     safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV();
7980     ~safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV();
7981     void initialize(const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* in_struct);
7982     void initialize(const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV* copy_src);
ptrsafe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV7983     VkPhysicalDeviceDiagnosticsConfigFeaturesNV *ptr() { return reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV *>(this); }
ptrsafe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV7984     VkPhysicalDeviceDiagnosticsConfigFeaturesNV const *ptr() const { return reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV const *>(this); }
7985 };
7986 
7987 struct safe_VkDeviceDiagnosticsConfigCreateInfoNV {
7988     VkStructureType sType;
7989     const void* pNext;
7990     VkDeviceDiagnosticsConfigFlagsNV flags;
7991     safe_VkDeviceDiagnosticsConfigCreateInfoNV(const VkDeviceDiagnosticsConfigCreateInfoNV* in_struct);
7992     safe_VkDeviceDiagnosticsConfigCreateInfoNV(const safe_VkDeviceDiagnosticsConfigCreateInfoNV& copy_src);
7993     safe_VkDeviceDiagnosticsConfigCreateInfoNV& operator=(const safe_VkDeviceDiagnosticsConfigCreateInfoNV& copy_src);
7994     safe_VkDeviceDiagnosticsConfigCreateInfoNV();
7995     ~safe_VkDeviceDiagnosticsConfigCreateInfoNV();
7996     void initialize(const VkDeviceDiagnosticsConfigCreateInfoNV* in_struct);
7997     void initialize(const safe_VkDeviceDiagnosticsConfigCreateInfoNV* copy_src);
ptrsafe_VkDeviceDiagnosticsConfigCreateInfoNV7998     VkDeviceDiagnosticsConfigCreateInfoNV *ptr() { return reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV *>(this); }
ptrsafe_VkDeviceDiagnosticsConfigCreateInfoNV7999     VkDeviceDiagnosticsConfigCreateInfoNV const *ptr() const { return reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV const *>(this); }
8000 };
8001 
8002 struct safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT {
8003     VkStructureType sType;
8004     void* pNext;
8005     VkBool32 fragmentDensityMapDeferred;
8006     safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* in_struct);
8007     safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& copy_src);
8008     safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& operator=(const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& copy_src);
8009     safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT();
8010     ~safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT();
8011     void initialize(const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* in_struct);
8012     void initialize(const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT8013     VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT8014     VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const *>(this); }
8015 };
8016 
8017 struct safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT {
8018     VkStructureType sType;
8019     void* pNext;
8020     VkBool32 subsampledLoads;
8021     VkBool32 subsampledCoarseReconstructionEarlyAccess;
8022     uint32_t maxSubsampledArrayLayers;
8023     uint32_t maxDescriptorSetSubsampledSamplers;
8024     safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* in_struct);
8025     safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& copy_src);
8026     safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& operator=(const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& copy_src);
8027     safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT();
8028     ~safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT();
8029     void initialize(const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* in_struct);
8030     void initialize(const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* copy_src);
ptrsafe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT8031     VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *>(this); }
ptrsafe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT8032     VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const *>(this); }
8033 };
8034 
8035 struct safe_VkPhysicalDeviceImageRobustnessFeaturesEXT {
8036     VkStructureType sType;
8037     void* pNext;
8038     VkBool32 robustImageAccess;
8039     safe_VkPhysicalDeviceImageRobustnessFeaturesEXT(const VkPhysicalDeviceImageRobustnessFeaturesEXT* in_struct);
8040     safe_VkPhysicalDeviceImageRobustnessFeaturesEXT(const safe_VkPhysicalDeviceImageRobustnessFeaturesEXT& copy_src);
8041     safe_VkPhysicalDeviceImageRobustnessFeaturesEXT& operator=(const safe_VkPhysicalDeviceImageRobustnessFeaturesEXT& copy_src);
8042     safe_VkPhysicalDeviceImageRobustnessFeaturesEXT();
8043     ~safe_VkPhysicalDeviceImageRobustnessFeaturesEXT();
8044     void initialize(const VkPhysicalDeviceImageRobustnessFeaturesEXT* in_struct);
8045     void initialize(const safe_VkPhysicalDeviceImageRobustnessFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDeviceImageRobustnessFeaturesEXT8046     VkPhysicalDeviceImageRobustnessFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDeviceImageRobustnessFeaturesEXT8047     VkPhysicalDeviceImageRobustnessFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT const *>(this); }
8048 };
8049 
8050 struct safe_VkPhysicalDevice4444FormatsFeaturesEXT {
8051     VkStructureType sType;
8052     void* pNext;
8053     VkBool32 formatA4R4G4B4;
8054     VkBool32 formatA4B4G4R4;
8055     safe_VkPhysicalDevice4444FormatsFeaturesEXT(const VkPhysicalDevice4444FormatsFeaturesEXT* in_struct);
8056     safe_VkPhysicalDevice4444FormatsFeaturesEXT(const safe_VkPhysicalDevice4444FormatsFeaturesEXT& copy_src);
8057     safe_VkPhysicalDevice4444FormatsFeaturesEXT& operator=(const safe_VkPhysicalDevice4444FormatsFeaturesEXT& copy_src);
8058     safe_VkPhysicalDevice4444FormatsFeaturesEXT();
8059     ~safe_VkPhysicalDevice4444FormatsFeaturesEXT();
8060     void initialize(const VkPhysicalDevice4444FormatsFeaturesEXT* in_struct);
8061     void initialize(const safe_VkPhysicalDevice4444FormatsFeaturesEXT* copy_src);
ptrsafe_VkPhysicalDevice4444FormatsFeaturesEXT8062     VkPhysicalDevice4444FormatsFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT *>(this); }
ptrsafe_VkPhysicalDevice4444FormatsFeaturesEXT8063     VkPhysicalDevice4444FormatsFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT const *>(this); }
8064 };
8065 
8066 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
8067 struct safe_VkDirectFBSurfaceCreateInfoEXT {
8068     VkStructureType sType;
8069     const void* pNext;
8070     VkDirectFBSurfaceCreateFlagsEXT flags;
8071     IDirectFB* dfb;
8072     IDirectFBSurface* surface;
8073     safe_VkDirectFBSurfaceCreateInfoEXT(const VkDirectFBSurfaceCreateInfoEXT* in_struct);
8074     safe_VkDirectFBSurfaceCreateInfoEXT(const safe_VkDirectFBSurfaceCreateInfoEXT& copy_src);
8075     safe_VkDirectFBSurfaceCreateInfoEXT& operator=(const safe_VkDirectFBSurfaceCreateInfoEXT& copy_src);
8076     safe_VkDirectFBSurfaceCreateInfoEXT();
8077     ~safe_VkDirectFBSurfaceCreateInfoEXT();
8078     void initialize(const VkDirectFBSurfaceCreateInfoEXT* in_struct);
8079     void initialize(const safe_VkDirectFBSurfaceCreateInfoEXT* copy_src);
ptrsafe_VkDirectFBSurfaceCreateInfoEXT8080     VkDirectFBSurfaceCreateInfoEXT *ptr() { return reinterpret_cast<VkDirectFBSurfaceCreateInfoEXT *>(this); }
ptrsafe_VkDirectFBSurfaceCreateInfoEXT8081     VkDirectFBSurfaceCreateInfoEXT const *ptr() const { return reinterpret_cast<VkDirectFBSurfaceCreateInfoEXT const *>(this); }
8082 };
8083 #endif // VK_USE_PLATFORM_DIRECTFB_EXT
8084 
8085 #ifdef VK_ENABLE_BETA_EXTENSIONS
8086 union safe_VkDeviceOrHostAddressKHR {
8087     VkDeviceAddress deviceAddress;
8088     void* hostAddress;
8089     safe_VkDeviceOrHostAddressKHR(const VkDeviceOrHostAddressKHR* in_struct);
8090     safe_VkDeviceOrHostAddressKHR(const safe_VkDeviceOrHostAddressKHR& copy_src);
8091     safe_VkDeviceOrHostAddressKHR& operator=(const safe_VkDeviceOrHostAddressKHR& copy_src);
8092     safe_VkDeviceOrHostAddressKHR();
8093     ~safe_VkDeviceOrHostAddressKHR();
8094     void initialize(const VkDeviceOrHostAddressKHR* in_struct);
8095     void initialize(const safe_VkDeviceOrHostAddressKHR* copy_src);
ptr()8096     VkDeviceOrHostAddressKHR *ptr() { return reinterpret_cast<VkDeviceOrHostAddressKHR *>(this); }
ptr()8097     VkDeviceOrHostAddressKHR const *ptr() const { return reinterpret_cast<VkDeviceOrHostAddressKHR const *>(this); }
8098 };
8099 #endif // VK_ENABLE_BETA_EXTENSIONS
8100 
8101 #ifdef VK_ENABLE_BETA_EXTENSIONS
8102 union safe_VkDeviceOrHostAddressConstKHR {
8103     VkDeviceAddress deviceAddress;
8104     const void* hostAddress;
8105     safe_VkDeviceOrHostAddressConstKHR(const VkDeviceOrHostAddressConstKHR* in_struct);
8106     safe_VkDeviceOrHostAddressConstKHR(const safe_VkDeviceOrHostAddressConstKHR& copy_src);
8107     safe_VkDeviceOrHostAddressConstKHR& operator=(const safe_VkDeviceOrHostAddressConstKHR& copy_src);
8108     safe_VkDeviceOrHostAddressConstKHR();
8109     ~safe_VkDeviceOrHostAddressConstKHR();
8110     void initialize(const VkDeviceOrHostAddressConstKHR* in_struct);
8111     void initialize(const safe_VkDeviceOrHostAddressConstKHR* copy_src);
ptr()8112     VkDeviceOrHostAddressConstKHR *ptr() { return reinterpret_cast<VkDeviceOrHostAddressConstKHR *>(this); }
ptr()8113     VkDeviceOrHostAddressConstKHR const *ptr() const { return reinterpret_cast<VkDeviceOrHostAddressConstKHR const *>(this); }
8114 };
8115 #endif // VK_ENABLE_BETA_EXTENSIONS
8116 
8117 #ifdef VK_ENABLE_BETA_EXTENSIONS
8118 struct safe_VkRayTracingShaderGroupCreateInfoKHR {
8119     VkStructureType sType;
8120     const void* pNext;
8121     VkRayTracingShaderGroupTypeKHR type;
8122     uint32_t generalShader;
8123     uint32_t closestHitShader;
8124     uint32_t anyHitShader;
8125     uint32_t intersectionShader;
8126     const void* pShaderGroupCaptureReplayHandle;
8127     safe_VkRayTracingShaderGroupCreateInfoKHR(const VkRayTracingShaderGroupCreateInfoKHR* in_struct);
8128     safe_VkRayTracingShaderGroupCreateInfoKHR(const safe_VkRayTracingShaderGroupCreateInfoKHR& copy_src);
8129     safe_VkRayTracingShaderGroupCreateInfoKHR& operator=(const safe_VkRayTracingShaderGroupCreateInfoKHR& copy_src);
8130     safe_VkRayTracingShaderGroupCreateInfoKHR();
8131     ~safe_VkRayTracingShaderGroupCreateInfoKHR();
8132     void initialize(const VkRayTracingShaderGroupCreateInfoKHR* in_struct);
8133     void initialize(const safe_VkRayTracingShaderGroupCreateInfoKHR* copy_src);
ptrsafe_VkRayTracingShaderGroupCreateInfoKHR8134     VkRayTracingShaderGroupCreateInfoKHR *ptr() { return reinterpret_cast<VkRayTracingShaderGroupCreateInfoKHR *>(this); }
ptrsafe_VkRayTracingShaderGroupCreateInfoKHR8135     VkRayTracingShaderGroupCreateInfoKHR const *ptr() const { return reinterpret_cast<VkRayTracingShaderGroupCreateInfoKHR const *>(this); }
8136 };
8137 #endif // VK_ENABLE_BETA_EXTENSIONS
8138 
8139 #ifdef VK_ENABLE_BETA_EXTENSIONS
8140 struct safe_VkRayTracingPipelineInterfaceCreateInfoKHR {
8141     VkStructureType sType;
8142     const void* pNext;
8143     uint32_t maxPayloadSize;
8144     uint32_t maxAttributeSize;
8145     uint32_t maxCallableSize;
8146     safe_VkRayTracingPipelineInterfaceCreateInfoKHR(const VkRayTracingPipelineInterfaceCreateInfoKHR* in_struct);
8147     safe_VkRayTracingPipelineInterfaceCreateInfoKHR(const safe_VkRayTracingPipelineInterfaceCreateInfoKHR& copy_src);
8148     safe_VkRayTracingPipelineInterfaceCreateInfoKHR& operator=(const safe_VkRayTracingPipelineInterfaceCreateInfoKHR& copy_src);
8149     safe_VkRayTracingPipelineInterfaceCreateInfoKHR();
8150     ~safe_VkRayTracingPipelineInterfaceCreateInfoKHR();
8151     void initialize(const VkRayTracingPipelineInterfaceCreateInfoKHR* in_struct);
8152     void initialize(const safe_VkRayTracingPipelineInterfaceCreateInfoKHR* copy_src);
ptrsafe_VkRayTracingPipelineInterfaceCreateInfoKHR8153     VkRayTracingPipelineInterfaceCreateInfoKHR *ptr() { return reinterpret_cast<VkRayTracingPipelineInterfaceCreateInfoKHR *>(this); }
ptrsafe_VkRayTracingPipelineInterfaceCreateInfoKHR8154     VkRayTracingPipelineInterfaceCreateInfoKHR const *ptr() const { return reinterpret_cast<VkRayTracingPipelineInterfaceCreateInfoKHR const *>(this); }
8155 };
8156 #endif // VK_ENABLE_BETA_EXTENSIONS
8157 
8158 #ifdef VK_ENABLE_BETA_EXTENSIONS
8159 struct safe_VkRayTracingPipelineCreateInfoKHR {
8160     VkStructureType sType;
8161     const void* pNext;
8162     VkPipelineCreateFlags flags;
8163     uint32_t stageCount;
8164     safe_VkPipelineShaderStageCreateInfo* pStages;
8165     uint32_t groupCount;
8166     safe_VkRayTracingShaderGroupCreateInfoKHR* pGroups;
8167     uint32_t maxRecursionDepth;
8168     safe_VkPipelineLibraryCreateInfoKHR libraries;
8169     safe_VkRayTracingPipelineInterfaceCreateInfoKHR* pLibraryInterface;
8170     VkPipelineLayout layout;
8171     VkPipeline basePipelineHandle;
8172     int32_t basePipelineIndex;
8173     safe_VkRayTracingPipelineCreateInfoKHR(const VkRayTracingPipelineCreateInfoKHR* in_struct);
8174     safe_VkRayTracingPipelineCreateInfoKHR(const safe_VkRayTracingPipelineCreateInfoKHR& copy_src);
8175     safe_VkRayTracingPipelineCreateInfoKHR& operator=(const safe_VkRayTracingPipelineCreateInfoKHR& copy_src);
8176     safe_VkRayTracingPipelineCreateInfoKHR();
8177     ~safe_VkRayTracingPipelineCreateInfoKHR();
8178     void initialize(const VkRayTracingPipelineCreateInfoKHR* in_struct);
8179     void initialize(const safe_VkRayTracingPipelineCreateInfoKHR* copy_src);
ptrsafe_VkRayTracingPipelineCreateInfoKHR8180     VkRayTracingPipelineCreateInfoKHR *ptr() { return reinterpret_cast<VkRayTracingPipelineCreateInfoKHR *>(this); }
ptrsafe_VkRayTracingPipelineCreateInfoKHR8181     VkRayTracingPipelineCreateInfoKHR const *ptr() const { return reinterpret_cast<VkRayTracingPipelineCreateInfoKHR const *>(this); }
8182 };
8183 #endif // VK_ENABLE_BETA_EXTENSIONS
8184 
8185 #ifdef VK_ENABLE_BETA_EXTENSIONS
8186 struct safe_VkAccelerationStructureGeometryTrianglesDataKHR {
8187     VkStructureType sType;
8188     const void* pNext;
8189     VkFormat vertexFormat;
8190     safe_VkDeviceOrHostAddressConstKHR vertexData;
8191     VkDeviceSize vertexStride;
8192     VkIndexType indexType;
8193     safe_VkDeviceOrHostAddressConstKHR indexData;
8194     safe_VkDeviceOrHostAddressConstKHR transformData;
8195     safe_VkAccelerationStructureGeometryTrianglesDataKHR(const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct);
8196     safe_VkAccelerationStructureGeometryTrianglesDataKHR(const safe_VkAccelerationStructureGeometryTrianglesDataKHR& copy_src);
8197     safe_VkAccelerationStructureGeometryTrianglesDataKHR& operator=(const safe_VkAccelerationStructureGeometryTrianglesDataKHR& copy_src);
8198     safe_VkAccelerationStructureGeometryTrianglesDataKHR();
8199     ~safe_VkAccelerationStructureGeometryTrianglesDataKHR();
8200     void initialize(const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct);
8201     void initialize(const safe_VkAccelerationStructureGeometryTrianglesDataKHR* copy_src);
ptrsafe_VkAccelerationStructureGeometryTrianglesDataKHR8202     VkAccelerationStructureGeometryTrianglesDataKHR *ptr() { return reinterpret_cast<VkAccelerationStructureGeometryTrianglesDataKHR *>(this); }
ptrsafe_VkAccelerationStructureGeometryTrianglesDataKHR8203     VkAccelerationStructureGeometryTrianglesDataKHR const *ptr() const { return reinterpret_cast<VkAccelerationStructureGeometryTrianglesDataKHR const *>(this); }
8204 };
8205 #endif // VK_ENABLE_BETA_EXTENSIONS
8206 
8207 #ifdef VK_ENABLE_BETA_EXTENSIONS
8208 struct safe_VkAccelerationStructureGeometryAabbsDataKHR {
8209     VkStructureType sType;
8210     const void* pNext;
8211     safe_VkDeviceOrHostAddressConstKHR data;
8212     VkDeviceSize stride;
8213     safe_VkAccelerationStructureGeometryAabbsDataKHR(const VkAccelerationStructureGeometryAabbsDataKHR* in_struct);
8214     safe_VkAccelerationStructureGeometryAabbsDataKHR(const safe_VkAccelerationStructureGeometryAabbsDataKHR& copy_src);
8215     safe_VkAccelerationStructureGeometryAabbsDataKHR& operator=(const safe_VkAccelerationStructureGeometryAabbsDataKHR& copy_src);
8216     safe_VkAccelerationStructureGeometryAabbsDataKHR();
8217     ~safe_VkAccelerationStructureGeometryAabbsDataKHR();
8218     void initialize(const VkAccelerationStructureGeometryAabbsDataKHR* in_struct);
8219     void initialize(const safe_VkAccelerationStructureGeometryAabbsDataKHR* copy_src);
ptrsafe_VkAccelerationStructureGeometryAabbsDataKHR8220     VkAccelerationStructureGeometryAabbsDataKHR *ptr() { return reinterpret_cast<VkAccelerationStructureGeometryAabbsDataKHR *>(this); }
ptrsafe_VkAccelerationStructureGeometryAabbsDataKHR8221     VkAccelerationStructureGeometryAabbsDataKHR const *ptr() const { return reinterpret_cast<VkAccelerationStructureGeometryAabbsDataKHR const *>(this); }
8222 };
8223 #endif // VK_ENABLE_BETA_EXTENSIONS
8224 
8225 #ifdef VK_ENABLE_BETA_EXTENSIONS
8226 struct safe_VkAccelerationStructureGeometryInstancesDataKHR {
8227     VkStructureType sType;
8228     const void* pNext;
8229     VkBool32 arrayOfPointers;
8230     safe_VkDeviceOrHostAddressConstKHR data;
8231     safe_VkAccelerationStructureGeometryInstancesDataKHR(const VkAccelerationStructureGeometryInstancesDataKHR* in_struct);
8232     safe_VkAccelerationStructureGeometryInstancesDataKHR(const safe_VkAccelerationStructureGeometryInstancesDataKHR& copy_src);
8233     safe_VkAccelerationStructureGeometryInstancesDataKHR& operator=(const safe_VkAccelerationStructureGeometryInstancesDataKHR& copy_src);
8234     safe_VkAccelerationStructureGeometryInstancesDataKHR();
8235     ~safe_VkAccelerationStructureGeometryInstancesDataKHR();
8236     void initialize(const VkAccelerationStructureGeometryInstancesDataKHR* in_struct);
8237     void initialize(const safe_VkAccelerationStructureGeometryInstancesDataKHR* copy_src);
ptrsafe_VkAccelerationStructureGeometryInstancesDataKHR8238     VkAccelerationStructureGeometryInstancesDataKHR *ptr() { return reinterpret_cast<VkAccelerationStructureGeometryInstancesDataKHR *>(this); }
ptrsafe_VkAccelerationStructureGeometryInstancesDataKHR8239     VkAccelerationStructureGeometryInstancesDataKHR const *ptr() const { return reinterpret_cast<VkAccelerationStructureGeometryInstancesDataKHR const *>(this); }
8240 };
8241 #endif // VK_ENABLE_BETA_EXTENSIONS
8242 
8243 #ifdef VK_ENABLE_BETA_EXTENSIONS
8244 struct safe_VkAccelerationStructureGeometryKHR {
8245     VkStructureType sType;
8246     const void* pNext;
8247     VkGeometryTypeKHR geometryType;
8248     VkAccelerationStructureGeometryDataKHR geometry;
8249     VkGeometryFlagsKHR flags;
8250     safe_VkAccelerationStructureGeometryKHR(const VkAccelerationStructureGeometryKHR* in_struct);
8251     safe_VkAccelerationStructureGeometryKHR(const safe_VkAccelerationStructureGeometryKHR& copy_src);
8252     safe_VkAccelerationStructureGeometryKHR& operator=(const safe_VkAccelerationStructureGeometryKHR& copy_src);
8253     safe_VkAccelerationStructureGeometryKHR();
8254     ~safe_VkAccelerationStructureGeometryKHR();
8255     void initialize(const VkAccelerationStructureGeometryKHR* in_struct);
8256     void initialize(const safe_VkAccelerationStructureGeometryKHR* copy_src);
ptrsafe_VkAccelerationStructureGeometryKHR8257     VkAccelerationStructureGeometryKHR *ptr() { return reinterpret_cast<VkAccelerationStructureGeometryKHR *>(this); }
ptrsafe_VkAccelerationStructureGeometryKHR8258     VkAccelerationStructureGeometryKHR const *ptr() const { return reinterpret_cast<VkAccelerationStructureGeometryKHR const *>(this); }
8259 };
8260 #endif // VK_ENABLE_BETA_EXTENSIONS
8261 
8262 #ifdef VK_ENABLE_BETA_EXTENSIONS
8263 struct safe_VkAccelerationStructureBuildGeometryInfoKHR {
8264     VkStructureType sType;
8265     const void* pNext;
8266     VkAccelerationStructureTypeKHR type;
8267     VkBuildAccelerationStructureFlagsKHR flags;
8268     VkBool32 update;
8269     VkAccelerationStructureKHR srcAccelerationStructure;
8270     VkAccelerationStructureKHR dstAccelerationStructure;
8271     VkBool32 geometryArrayOfPointers;
8272     uint32_t geometryCount;
8273     safe_VkAccelerationStructureGeometryKHR** ppGeometries;
8274     safe_VkDeviceOrHostAddressKHR scratchData;
8275     safe_VkAccelerationStructureBuildGeometryInfoKHR(const VkAccelerationStructureBuildGeometryInfoKHR* in_struct);
8276     safe_VkAccelerationStructureBuildGeometryInfoKHR(const safe_VkAccelerationStructureBuildGeometryInfoKHR& copy_src);
8277     safe_VkAccelerationStructureBuildGeometryInfoKHR& operator=(const safe_VkAccelerationStructureBuildGeometryInfoKHR& copy_src);
8278     safe_VkAccelerationStructureBuildGeometryInfoKHR();
8279     ~safe_VkAccelerationStructureBuildGeometryInfoKHR();
8280     void initialize(const VkAccelerationStructureBuildGeometryInfoKHR* in_struct);
8281     void initialize(const safe_VkAccelerationStructureBuildGeometryInfoKHR* copy_src);
ptrsafe_VkAccelerationStructureBuildGeometryInfoKHR8282     VkAccelerationStructureBuildGeometryInfoKHR *ptr() { return reinterpret_cast<VkAccelerationStructureBuildGeometryInfoKHR *>(this); }
ptrsafe_VkAccelerationStructureBuildGeometryInfoKHR8283     VkAccelerationStructureBuildGeometryInfoKHR const *ptr() const { return reinterpret_cast<VkAccelerationStructureBuildGeometryInfoKHR const *>(this); }
8284 };
8285 #endif // VK_ENABLE_BETA_EXTENSIONS
8286 
8287 #ifdef VK_ENABLE_BETA_EXTENSIONS
8288 struct safe_VkAccelerationStructureCreateGeometryTypeInfoKHR {
8289     VkStructureType sType;
8290     const void* pNext;
8291     VkGeometryTypeKHR geometryType;
8292     uint32_t maxPrimitiveCount;
8293     VkIndexType indexType;
8294     uint32_t maxVertexCount;
8295     VkFormat vertexFormat;
8296     VkBool32 allowsTransforms;
8297     safe_VkAccelerationStructureCreateGeometryTypeInfoKHR(const VkAccelerationStructureCreateGeometryTypeInfoKHR* in_struct);
8298     safe_VkAccelerationStructureCreateGeometryTypeInfoKHR(const safe_VkAccelerationStructureCreateGeometryTypeInfoKHR& copy_src);
8299     safe_VkAccelerationStructureCreateGeometryTypeInfoKHR& operator=(const safe_VkAccelerationStructureCreateGeometryTypeInfoKHR& copy_src);
8300     safe_VkAccelerationStructureCreateGeometryTypeInfoKHR();
8301     ~safe_VkAccelerationStructureCreateGeometryTypeInfoKHR();
8302     void initialize(const VkAccelerationStructureCreateGeometryTypeInfoKHR* in_struct);
8303     void initialize(const safe_VkAccelerationStructureCreateGeometryTypeInfoKHR* copy_src);
ptrsafe_VkAccelerationStructureCreateGeometryTypeInfoKHR8304     VkAccelerationStructureCreateGeometryTypeInfoKHR *ptr() { return reinterpret_cast<VkAccelerationStructureCreateGeometryTypeInfoKHR *>(this); }
ptrsafe_VkAccelerationStructureCreateGeometryTypeInfoKHR8305     VkAccelerationStructureCreateGeometryTypeInfoKHR const *ptr() const { return reinterpret_cast<VkAccelerationStructureCreateGeometryTypeInfoKHR const *>(this); }
8306 };
8307 #endif // VK_ENABLE_BETA_EXTENSIONS
8308 
8309 #ifdef VK_ENABLE_BETA_EXTENSIONS
8310 struct safe_VkAccelerationStructureCreateInfoKHR {
8311     VkStructureType sType;
8312     const void* pNext;
8313     VkDeviceSize compactedSize;
8314     VkAccelerationStructureTypeKHR type;
8315     VkBuildAccelerationStructureFlagsKHR flags;
8316     uint32_t maxGeometryCount;
8317     safe_VkAccelerationStructureCreateGeometryTypeInfoKHR* pGeometryInfos;
8318     VkDeviceAddress deviceAddress;
8319     safe_VkAccelerationStructureCreateInfoKHR(const VkAccelerationStructureCreateInfoKHR* in_struct);
8320     safe_VkAccelerationStructureCreateInfoKHR(const safe_VkAccelerationStructureCreateInfoKHR& copy_src);
8321     safe_VkAccelerationStructureCreateInfoKHR& operator=(const safe_VkAccelerationStructureCreateInfoKHR& copy_src);
8322     safe_VkAccelerationStructureCreateInfoKHR();
8323     ~safe_VkAccelerationStructureCreateInfoKHR();
8324     void initialize(const VkAccelerationStructureCreateInfoKHR* in_struct);
8325     void initialize(const safe_VkAccelerationStructureCreateInfoKHR* copy_src);
ptrsafe_VkAccelerationStructureCreateInfoKHR8326     VkAccelerationStructureCreateInfoKHR *ptr() { return reinterpret_cast<VkAccelerationStructureCreateInfoKHR *>(this); }
ptrsafe_VkAccelerationStructureCreateInfoKHR8327     VkAccelerationStructureCreateInfoKHR const *ptr() const { return reinterpret_cast<VkAccelerationStructureCreateInfoKHR const *>(this); }
8328 };
8329 #endif // VK_ENABLE_BETA_EXTENSIONS
8330 
8331 #ifdef VK_ENABLE_BETA_EXTENSIONS
8332 struct safe_VkAccelerationStructureMemoryRequirementsInfoKHR {
8333     VkStructureType sType;
8334     const void* pNext;
8335     VkAccelerationStructureMemoryRequirementsTypeKHR type;
8336     VkAccelerationStructureBuildTypeKHR buildType;
8337     VkAccelerationStructureKHR accelerationStructure;
8338     safe_VkAccelerationStructureMemoryRequirementsInfoKHR(const VkAccelerationStructureMemoryRequirementsInfoKHR* in_struct);
8339     safe_VkAccelerationStructureMemoryRequirementsInfoKHR(const safe_VkAccelerationStructureMemoryRequirementsInfoKHR& copy_src);
8340     safe_VkAccelerationStructureMemoryRequirementsInfoKHR& operator=(const safe_VkAccelerationStructureMemoryRequirementsInfoKHR& copy_src);
8341     safe_VkAccelerationStructureMemoryRequirementsInfoKHR();
8342     ~safe_VkAccelerationStructureMemoryRequirementsInfoKHR();
8343     void initialize(const VkAccelerationStructureMemoryRequirementsInfoKHR* in_struct);
8344     void initialize(const safe_VkAccelerationStructureMemoryRequirementsInfoKHR* copy_src);
ptrsafe_VkAccelerationStructureMemoryRequirementsInfoKHR8345     VkAccelerationStructureMemoryRequirementsInfoKHR *ptr() { return reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoKHR *>(this); }
ptrsafe_VkAccelerationStructureMemoryRequirementsInfoKHR8346     VkAccelerationStructureMemoryRequirementsInfoKHR const *ptr() const { return reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoKHR const *>(this); }
8347 };
8348 #endif // VK_ENABLE_BETA_EXTENSIONS
8349 
8350 #ifdef VK_ENABLE_BETA_EXTENSIONS
8351 struct safe_VkPhysicalDeviceRayTracingFeaturesKHR {
8352     VkStructureType sType;
8353     void* pNext;
8354     VkBool32 rayTracing;
8355     VkBool32 rayTracingShaderGroupHandleCaptureReplay;
8356     VkBool32 rayTracingShaderGroupHandleCaptureReplayMixed;
8357     VkBool32 rayTracingAccelerationStructureCaptureReplay;
8358     VkBool32 rayTracingIndirectTraceRays;
8359     VkBool32 rayTracingIndirectAccelerationStructureBuild;
8360     VkBool32 rayTracingHostAccelerationStructureCommands;
8361     VkBool32 rayQuery;
8362     VkBool32 rayTracingPrimitiveCulling;
8363     safe_VkPhysicalDeviceRayTracingFeaturesKHR(const VkPhysicalDeviceRayTracingFeaturesKHR* in_struct);
8364     safe_VkPhysicalDeviceRayTracingFeaturesKHR(const safe_VkPhysicalDeviceRayTracingFeaturesKHR& copy_src);
8365     safe_VkPhysicalDeviceRayTracingFeaturesKHR& operator=(const safe_VkPhysicalDeviceRayTracingFeaturesKHR& copy_src);
8366     safe_VkPhysicalDeviceRayTracingFeaturesKHR();
8367     ~safe_VkPhysicalDeviceRayTracingFeaturesKHR();
8368     void initialize(const VkPhysicalDeviceRayTracingFeaturesKHR* in_struct);
8369     void initialize(const safe_VkPhysicalDeviceRayTracingFeaturesKHR* copy_src);
ptrsafe_VkPhysicalDeviceRayTracingFeaturesKHR8370     VkPhysicalDeviceRayTracingFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceRayTracingFeaturesKHR *>(this); }
ptrsafe_VkPhysicalDeviceRayTracingFeaturesKHR8371     VkPhysicalDeviceRayTracingFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceRayTracingFeaturesKHR const *>(this); }
8372 };
8373 #endif // VK_ENABLE_BETA_EXTENSIONS
8374 
8375 #ifdef VK_ENABLE_BETA_EXTENSIONS
8376 struct safe_VkPhysicalDeviceRayTracingPropertiesKHR {
8377     VkStructureType sType;
8378     void* pNext;
8379     uint32_t shaderGroupHandleSize;
8380     uint32_t maxRecursionDepth;
8381     uint32_t maxShaderGroupStride;
8382     uint32_t shaderGroupBaseAlignment;
8383     uint64_t maxGeometryCount;
8384     uint64_t maxInstanceCount;
8385     uint64_t maxPrimitiveCount;
8386     uint32_t maxDescriptorSetAccelerationStructures;
8387     uint32_t shaderGroupHandleCaptureReplaySize;
8388     safe_VkPhysicalDeviceRayTracingPropertiesKHR(const VkPhysicalDeviceRayTracingPropertiesKHR* in_struct);
8389     safe_VkPhysicalDeviceRayTracingPropertiesKHR(const safe_VkPhysicalDeviceRayTracingPropertiesKHR& copy_src);
8390     safe_VkPhysicalDeviceRayTracingPropertiesKHR& operator=(const safe_VkPhysicalDeviceRayTracingPropertiesKHR& copy_src);
8391     safe_VkPhysicalDeviceRayTracingPropertiesKHR();
8392     ~safe_VkPhysicalDeviceRayTracingPropertiesKHR();
8393     void initialize(const VkPhysicalDeviceRayTracingPropertiesKHR* in_struct);
8394     void initialize(const safe_VkPhysicalDeviceRayTracingPropertiesKHR* copy_src);
ptrsafe_VkPhysicalDeviceRayTracingPropertiesKHR8395     VkPhysicalDeviceRayTracingPropertiesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesKHR *>(this); }
ptrsafe_VkPhysicalDeviceRayTracingPropertiesKHR8396     VkPhysicalDeviceRayTracingPropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesKHR const *>(this); }
8397 };
8398 #endif // VK_ENABLE_BETA_EXTENSIONS
8399 
8400 #ifdef VK_ENABLE_BETA_EXTENSIONS
8401 struct safe_VkAccelerationStructureDeviceAddressInfoKHR {
8402     VkStructureType sType;
8403     const void* pNext;
8404     VkAccelerationStructureKHR accelerationStructure;
8405     safe_VkAccelerationStructureDeviceAddressInfoKHR(const VkAccelerationStructureDeviceAddressInfoKHR* in_struct);
8406     safe_VkAccelerationStructureDeviceAddressInfoKHR(const safe_VkAccelerationStructureDeviceAddressInfoKHR& copy_src);
8407     safe_VkAccelerationStructureDeviceAddressInfoKHR& operator=(const safe_VkAccelerationStructureDeviceAddressInfoKHR& copy_src);
8408     safe_VkAccelerationStructureDeviceAddressInfoKHR();
8409     ~safe_VkAccelerationStructureDeviceAddressInfoKHR();
8410     void initialize(const VkAccelerationStructureDeviceAddressInfoKHR* in_struct);
8411     void initialize(const safe_VkAccelerationStructureDeviceAddressInfoKHR* copy_src);
ptrsafe_VkAccelerationStructureDeviceAddressInfoKHR8412     VkAccelerationStructureDeviceAddressInfoKHR *ptr() { return reinterpret_cast<VkAccelerationStructureDeviceAddressInfoKHR *>(this); }
ptrsafe_VkAccelerationStructureDeviceAddressInfoKHR8413     VkAccelerationStructureDeviceAddressInfoKHR const *ptr() const { return reinterpret_cast<VkAccelerationStructureDeviceAddressInfoKHR const *>(this); }
8414 };
8415 #endif // VK_ENABLE_BETA_EXTENSIONS
8416 
8417 #ifdef VK_ENABLE_BETA_EXTENSIONS
8418 struct safe_VkAccelerationStructureVersionKHR {
8419     VkStructureType sType;
8420     const void* pNext;
8421     const uint8_t* versionData;
8422     safe_VkAccelerationStructureVersionKHR(const VkAccelerationStructureVersionKHR* in_struct);
8423     safe_VkAccelerationStructureVersionKHR(const safe_VkAccelerationStructureVersionKHR& copy_src);
8424     safe_VkAccelerationStructureVersionKHR& operator=(const safe_VkAccelerationStructureVersionKHR& copy_src);
8425     safe_VkAccelerationStructureVersionKHR();
8426     ~safe_VkAccelerationStructureVersionKHR();
8427     void initialize(const VkAccelerationStructureVersionKHR* in_struct);
8428     void initialize(const safe_VkAccelerationStructureVersionKHR* copy_src);
ptrsafe_VkAccelerationStructureVersionKHR8429     VkAccelerationStructureVersionKHR *ptr() { return reinterpret_cast<VkAccelerationStructureVersionKHR *>(this); }
ptrsafe_VkAccelerationStructureVersionKHR8430     VkAccelerationStructureVersionKHR const *ptr() const { return reinterpret_cast<VkAccelerationStructureVersionKHR const *>(this); }
8431 };
8432 #endif // VK_ENABLE_BETA_EXTENSIONS
8433 
8434 #ifdef VK_ENABLE_BETA_EXTENSIONS
8435 struct safe_VkCopyAccelerationStructureToMemoryInfoKHR {
8436     VkStructureType sType;
8437     const void* pNext;
8438     VkAccelerationStructureKHR src;
8439     safe_VkDeviceOrHostAddressKHR dst;
8440     VkCopyAccelerationStructureModeKHR mode;
8441     safe_VkCopyAccelerationStructureToMemoryInfoKHR(const VkCopyAccelerationStructureToMemoryInfoKHR* in_struct);
8442     safe_VkCopyAccelerationStructureToMemoryInfoKHR(const safe_VkCopyAccelerationStructureToMemoryInfoKHR& copy_src);
8443     safe_VkCopyAccelerationStructureToMemoryInfoKHR& operator=(const safe_VkCopyAccelerationStructureToMemoryInfoKHR& copy_src);
8444     safe_VkCopyAccelerationStructureToMemoryInfoKHR();
8445     ~safe_VkCopyAccelerationStructureToMemoryInfoKHR();
8446     void initialize(const VkCopyAccelerationStructureToMemoryInfoKHR* in_struct);
8447     void initialize(const safe_VkCopyAccelerationStructureToMemoryInfoKHR* copy_src);
ptrsafe_VkCopyAccelerationStructureToMemoryInfoKHR8448     VkCopyAccelerationStructureToMemoryInfoKHR *ptr() { return reinterpret_cast<VkCopyAccelerationStructureToMemoryInfoKHR *>(this); }
ptrsafe_VkCopyAccelerationStructureToMemoryInfoKHR8449     VkCopyAccelerationStructureToMemoryInfoKHR const *ptr() const { return reinterpret_cast<VkCopyAccelerationStructureToMemoryInfoKHR const *>(this); }
8450 };
8451 #endif // VK_ENABLE_BETA_EXTENSIONS
8452 
8453 #ifdef VK_ENABLE_BETA_EXTENSIONS
8454 struct safe_VkCopyMemoryToAccelerationStructureInfoKHR {
8455     VkStructureType sType;
8456     const void* pNext;
8457     safe_VkDeviceOrHostAddressConstKHR src;
8458     VkAccelerationStructureKHR dst;
8459     VkCopyAccelerationStructureModeKHR mode;
8460     safe_VkCopyMemoryToAccelerationStructureInfoKHR(const VkCopyMemoryToAccelerationStructureInfoKHR* in_struct);
8461     safe_VkCopyMemoryToAccelerationStructureInfoKHR(const safe_VkCopyMemoryToAccelerationStructureInfoKHR& copy_src);
8462     safe_VkCopyMemoryToAccelerationStructureInfoKHR& operator=(const safe_VkCopyMemoryToAccelerationStructureInfoKHR& copy_src);
8463     safe_VkCopyMemoryToAccelerationStructureInfoKHR();
8464     ~safe_VkCopyMemoryToAccelerationStructureInfoKHR();
8465     void initialize(const VkCopyMemoryToAccelerationStructureInfoKHR* in_struct);
8466     void initialize(const safe_VkCopyMemoryToAccelerationStructureInfoKHR* copy_src);
ptrsafe_VkCopyMemoryToAccelerationStructureInfoKHR8467     VkCopyMemoryToAccelerationStructureInfoKHR *ptr() { return reinterpret_cast<VkCopyMemoryToAccelerationStructureInfoKHR *>(this); }
ptrsafe_VkCopyMemoryToAccelerationStructureInfoKHR8468     VkCopyMemoryToAccelerationStructureInfoKHR const *ptr() const { return reinterpret_cast<VkCopyMemoryToAccelerationStructureInfoKHR const *>(this); }
8469 };
8470 #endif // VK_ENABLE_BETA_EXTENSIONS
8471 
8472 #ifdef VK_ENABLE_BETA_EXTENSIONS
8473 struct safe_VkCopyAccelerationStructureInfoKHR {
8474     VkStructureType sType;
8475     const void* pNext;
8476     VkAccelerationStructureKHR src;
8477     VkAccelerationStructureKHR dst;
8478     VkCopyAccelerationStructureModeKHR mode;
8479     safe_VkCopyAccelerationStructureInfoKHR(const VkCopyAccelerationStructureInfoKHR* in_struct);
8480     safe_VkCopyAccelerationStructureInfoKHR(const safe_VkCopyAccelerationStructureInfoKHR& copy_src);
8481     safe_VkCopyAccelerationStructureInfoKHR& operator=(const safe_VkCopyAccelerationStructureInfoKHR& copy_src);
8482     safe_VkCopyAccelerationStructureInfoKHR();
8483     ~safe_VkCopyAccelerationStructureInfoKHR();
8484     void initialize(const VkCopyAccelerationStructureInfoKHR* in_struct);
8485     void initialize(const safe_VkCopyAccelerationStructureInfoKHR* copy_src);
ptrsafe_VkCopyAccelerationStructureInfoKHR8486     VkCopyAccelerationStructureInfoKHR *ptr() { return reinterpret_cast<VkCopyAccelerationStructureInfoKHR *>(this); }
ptrsafe_VkCopyAccelerationStructureInfoKHR8487     VkCopyAccelerationStructureInfoKHR const *ptr() const { return reinterpret_cast<VkCopyAccelerationStructureInfoKHR const *>(this); }
8488 };
8489 #endif // VK_ENABLE_BETA_EXTENSIONS
8490